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 EXPANDER_EXTRA_PADDING 4
 243 #define GTK_TREE_VIEW_SEARCH_DIALOG_TIMEOUT 5000
 244 #define AUTO_EXPAND_TIMEOUT 500
 245
 246 /* Translate from bin_window coordinates to rbtree (tree coordinates) and
 247  * vice versa.
 248  */
 249 #define TREE_WINDOW_Y_TO_RBTREE_Y(tree_view,y) ((y) + tree_view->priv->dy)
 250 #define RBTREE_Y_TO_TREE_WINDOW_Y(tree_view,y) ((y) - tree_view->priv->dy)
 251
 252 typedef struct _GtkTreeViewColumnReorder GtkTreeViewColumnReorder;
 253 struct _GtkTreeViewColumnReorder
 254 {
 255   gint left_align;
 256   gint right_align;
 257   GtkTreeViewColumn *left_column;
 258   GtkTreeViewColumn *right_column;
 259 };
 260
 261 typedef struct _GtkTreeViewChild GtkTreeViewChild;
 262 struct _GtkTreeViewChild
 263 {
 264   GtkWidget *widget;
 265   gint x;
 266   gint y;
 267   gint width;
 268   gint height;
 269 };
 270
 271
 272 typedef struct _TreeViewDragInfo TreeViewDragInfo;
 273 struct _TreeViewDragInfo
 274 {
 275   GdkModifierType start_button_mask;
 276   GtkTargetList *_unused_source_target_list;
 277   GdkDragAction source_actions;
 278
 279   GtkTargetList *_unused_dest_target_list;
 280
 281   guint source_set : 1;
 282   guint dest_set : 1;
 283 };
 284
 285
 286 struct _GtkTreeViewPrivate
 287 {
 288   GtkTreeModel *model;
 289
 290   /* tree information */
 291   GtkRBTree *tree;
 292
 293   /* Container info */
 294   GList *children;
 295   gint width;
 296   gint height;
 297
 298   /* Adjustments */
 299   GtkAdjustment *hadjustment;
 300   GtkAdjustment *vadjustment;
 301   gint           min_display_width;
 302   gint           min_display_height;
 303
 304   /* Sub windows */
 305   GdkWindow *bin_window;
 306   GdkWindow *header_window;
 307
 308   /* Scroll position state keeping */
 309   GtkTreeRowReference *top_row;
 310   gint top_row_dy;
 311   /* dy == y pos of top_row + top_row_dy */
 312   /* we cache it for simplicity of the code */
 313   gint dy;
 314
 315   guint presize_handler_timer;
 316   guint validate_rows_timer;
 317   guint scroll_sync_timer;
 318
 319   /* Indentation and expander layout */
 320   GtkTreeViewColumn *expander_column;
 321
 322   gint level_indentation;
 323
 324   /* Key navigation (focus), selection */
 325   gint cursor_offset;
 326
 327   GtkTreeRowReference *anchor;
 328   GtkRBNode *cursor_node;
 329   GtkRBTree *cursor_tree;
 330
 331   GtkTreeViewColumn *focus_column;
 332
 333   /* Current pressed node, previously pressed, prelight */
 334   GtkRBNode *button_pressed_node;
 335   GtkRBTree *button_pressed_tree;
 336
 337   gint pressed_button;
 338   gint press_start_x;
 339   gint press_start_y;
 340
 341   gint event_last_x;
 342   gint event_last_y;
 343
 344   guint last_button_time;
 345   gint last_button_x;
 346   gint last_button_y;
 347
 348   GtkRBNode *prelight_node;
 349   GtkRBTree *prelight_tree;
 350
 351   /* Cell Editing */
 352   GtkTreeViewColumn *edited_column;
 353
 354   /* The node that's currently being collapsed or expanded */
 355   GtkRBNode *expanded_collapsed_node;
 356   GtkRBTree *expanded_collapsed_tree;
 357   guint expand_collapse_timeout;
 358
 359   /* Auto expand/collapse timeout in hover mode */
 360   guint auto_expand_timeout;
 361
 362   /* Selection information */
 363   GtkTreeSelection *selection;
 364
 365   /* Header information */
 366   gint n_columns;
 367   GList *columns;
 368   gint header_height;
 369
 370   GtkTreeViewColumnDropFunc column_drop_func;
 371   gpointer column_drop_func_data;
 372   GDestroyNotify column_drop_func_data_destroy;
 373   GList *column_drag_info;
 374   GtkTreeViewColumnReorder *cur_reorder;
 375
 376   gint prev_width_before_expander;
 377
 378   /* Interactive Header reordering */
 379   GdkWindow *drag_window;
 380   GdkWindow *drag_highlight_window;
 381   GtkTreeViewColumn *drag_column;
 382   gint drag_column_x;
 383
 384   /* Interactive Header Resizing */
 385   gint drag_pos;
 386   gint x_drag;
 387
 388   /* Column width allocation */
 389   gint minimum_width;
 390   gint natural_width;
 391   gint n_expand_columns;
 392
 393   /* ATK Hack */
 394   GtkTreeDestroyCountFunc destroy_count_func;
 395   gpointer destroy_count_data;
 396   GDestroyNotify destroy_count_destroy;
 397
 398   /* Scroll timeout (e.g. during dnd, rubber banding) */
 399   guint scroll_timeout;
 400
 401   /* Row drag-and-drop */
 402   GtkTreeRowReference *drag_dest_row;
 403   GtkTreeViewDropPosition drag_dest_pos;
 404   guint open_dest_timeout;
 405
 406   /* Rubber banding */
 407   gint rubber_band_status;
 408   gint rubber_band_x;
 409   gint rubber_band_y;
 410   gint rubber_band_extend;
 411   gint rubber_band_modify;
 412
 413   GtkRBNode *rubber_band_start_node;
 414   GtkRBTree *rubber_band_start_tree;
 415
 416   GtkRBNode *rubber_band_end_node;
 417   GtkRBTree *rubber_band_end_tree;
 418
 419   /* fixed height */
 420   gint fixed_height;
 421
 422   /* Scroll-to functionality when unrealized */
 423   GtkTreeRowReference *scroll_to_path;
 424   GtkTreeViewColumn *scroll_to_column;
 425   gfloat scroll_to_row_align;
 426   gfloat scroll_to_col_align;
 427
 428   /* Interactive search */
 429   gint selected_iter;
 430   gint search_column;
 431   GtkTreeViewSearchPositionFunc search_position_func;
 432   GtkTreeViewSearchEqualFunc search_equal_func;
 433   gpointer search_user_data;
 434   GDestroyNotify search_destroy;
 435   gpointer search_position_user_data;
 436   GDestroyNotify search_position_destroy;
 437   GtkWidget *search_window;
 438   GtkWidget *search_entry;
 439   gulong search_entry_changed_id;
 440   guint typeselect_flush_timeout;
 441
 442   /* Grid and tree lines */
 443   GtkTreeViewGridLines grid_lines;
 444   double grid_line_dashes[2];
 445   int grid_line_width;
 446
 447   gboolean tree_lines_enabled;
 448   double tree_line_dashes[2];
 449   int tree_line_width;
 450
 451   /* Row separators */
 452   GtkTreeViewRowSeparatorFunc row_separator_func;
 453   gpointer row_separator_data;
 454   GDestroyNotify row_separator_destroy;
 455
 456   /* Tooltip support */
 457   gint tooltip_column;
 458
 459   /* Here comes the bitfield */
 460   guint scroll_to_use_align : 1;
 461
 462   guint fixed_height_mode : 1;
 463   guint fixed_height_check : 1;
 464
 465   guint activate_on_single_click : 1;
 466   guint reorderable : 1;
 467   guint header_has_focus : 1;
 468   guint drag_column_window_state : 3;
 469   /* hint to display rows in alternating colors */
 470   guint has_rules : 1;
 471   guint mark_rows_col_dirty : 1;
 472
 473   /* for DnD */
 474   guint empty_view_drop : 1;
 475
 476   guint modify_selection_pressed : 1;
 477   guint extend_selection_pressed : 1;
 478
 479   guint init_hadjust_value : 1;
 480
 481   guint in_top_row_to_dy : 1;
 482
 483   /* interactive search */
 484   guint enable_search : 1;
 485   guint disable_popdown : 1;
 486   guint search_custom_entry_set : 1;
 487
 488   guint hover_selection : 1;
 489   guint hover_expand : 1;
 490   guint imcontext_changed : 1;
 491
 492   guint rubber_banding_enable : 1;
 493
 494   guint in_grab : 1;
 495
 496   /* Whether our key press handler is to avoid sending an unhandled binding to the search entry */
 497   guint search_entry_avoid_unhandled_binding : 1;
 498
 499   /* GtkScrollablePolicy needs to be checked when
 500    * driving the scrollable adjustment values */
 501   guint hscroll_policy : 1;
 502   guint vscroll_policy : 1;
 503
 504   /* GtkTreeView flags */
 505   guint is_list : 1;
 506   guint show_expanders : 1;
 507   guint in_column_resize : 1;
 508   guint arrow_prelit : 1;
 509   guint headers_visible : 1;
 510   guint draw_keyfocus : 1;
 511   guint model_setup : 1;
 512   guint in_column_drag : 1;
 513 };
 514
 515
 516 /* Signals */
 517 enum
 518 {
 519   ROW_ACTIVATED,
 520   TEST_EXPAND_ROW,
 521   TEST_COLLAPSE_ROW,
 522   ROW_EXPANDED,
 523   ROW_COLLAPSED,
 524   COLUMNS_CHANGED,
 525   CURSOR_CHANGED,
 526   MOVE_CURSOR,
 527   SELECT_ALL,
 528   UNSELECT_ALL,
 529   SELECT_CURSOR_ROW,
 530   TOGGLE_CURSOR_ROW,
 531   EXPAND_COLLAPSE_CURSOR_ROW,
 532   SELECT_CURSOR_PARENT,
 533   START_INTERACTIVE_SEARCH,
 534   LAST_SIGNAL
 535 };
 536
 537 /* Properties */
 538 enum {
 539   PROP_0,
 540   PROP_MODEL,
 541   PROP_HADJUSTMENT,
 542   PROP_VADJUSTMENT,
 543   PROP_HSCROLL_POLICY,
 544   PROP_VSCROLL_POLICY,
 545   PROP_HEADERS_VISIBLE,
 546   PROP_HEADERS_CLICKABLE,
 547   PROP_EXPANDER_COLUMN,
 548   PROP_REORDERABLE,
 549   PROP_RULES_HINT,
 550   PROP_ENABLE_SEARCH,
 551   PROP_SEARCH_COLUMN,
 552   PROP_FIXED_HEIGHT_MODE,
 553   PROP_HOVER_SELECTION,
 554   PROP_HOVER_EXPAND,
 555   PROP_SHOW_EXPANDERS,
 556   PROP_LEVEL_INDENTATION,
 557   PROP_RUBBER_BANDING,
 558   PROP_ENABLE_GRID_LINES,
 559   PROP_ENABLE_TREE_LINES,
 560   PROP_TOOLTIP_COLUMN,
 561   PROP_ACTIVATE_ON_SINGLE_CLICK
 562 };
 563
 564 /* object signals */
 565 static void     gtk_tree_view_finalize             (GObject          *object);
 566 static void     gtk_tree_view_set_property         (GObject         *object,
 567                                                     guint            prop_id,
 568                                                     const GValue    *value,
 569                                                     GParamSpec      *pspec);
 570 static void     gtk_tree_view_get_property         (GObject         *object,
 571                                                     guint            prop_id,
 572                                                     GValue          *value,
 573                                                     GParamSpec      *pspec);
 574
 575 /* gtkwidget signals */
 576 static void     gtk_tree_view_destroy              (GtkWidget        *widget);
 577 static void     gtk_tree_view_realize              (GtkWidget        *widget);
 578 static void     gtk_tree_view_unrealize            (GtkWidget        *widget);
 579 static void     gtk_tree_view_map                  (GtkWidget        *widget);
 580 static void     gtk_tree_view_get_preferred_width  (GtkWidget        *widget,
 581                                                     gint             *minimum,
 582                                                     gint             *natural);
 583 static void     gtk_tree_view_get_preferred_height (GtkWidget        *widget,
 584                                                     gint             *minimum,
 585                                                     gint             *natural);
 586 static void     gtk_tree_view_size_allocate        (GtkWidget        *widget,
 587                                                     GtkAllocation    *allocation);
 588 static gboolean gtk_tree_view_draw                 (GtkWidget        *widget,
 589                                                     cairo_t          *cr);
 590 static gboolean gtk_tree_view_key_press            (GtkWidget        *widget,
 591                                                     GdkEventKey      *event);
 592 static gboolean gtk_tree_view_key_release          (GtkWidget        *widget,
 593                                                     GdkEventKey      *event);
 594 static gboolean gtk_tree_view_motion               (GtkWidget        *widget,
 595                                                     GdkEventMotion   *event);
 596 static gboolean gtk_tree_view_enter_notify         (GtkWidget        *widget,
 597                                                     GdkEventCrossing *event);
 598 static gboolean gtk_tree_view_leave_notify         (GtkWidget        *widget,
 599                                                     GdkEventCrossing *event);
 600 static gboolean gtk_tree_view_button_press         (GtkWidget        *widget,
 601                                                     GdkEventButton   *event);
 602 static gboolean gtk_tree_view_button_release       (GtkWidget        *widget,
 603                                                     GdkEventButton   *event);
 604 static gboolean gtk_tree_view_grab_broken          (GtkWidget          *widget,
 605                                                     GdkEventGrabBroken *event);
 606 #if 0
 607 static gboolean gtk_tree_view_configure            (GtkWidget         *widget,
 608                                                     GdkEventConfigure *event);
 609 #endif
 610
 611 static GtkWidgetPath * gtk_tree_view_get_path_for_child (GtkContainer *container,
 612                                                          GtkWidget    *child);
 613
 614 static void     gtk_tree_view_set_focus_child      (GtkContainer     *container,
 615                                                     GtkWidget        *child);
 616 static gint     gtk_tree_view_focus_out            (GtkWidget        *widget,
 617                                                     GdkEventFocus    *event);
 618 static gint     gtk_tree_view_focus                (GtkWidget        *widget,
 619                                                     GtkDirectionType  direction);
 620 static void     gtk_tree_view_grab_focus           (GtkWidget        *widget);
 621 static void     gtk_tree_view_style_updated        (GtkWidget        *widget);
 622 static void     gtk_tree_view_grab_notify          (GtkWidget        *widget,
 623                                                     gboolean          was_grabbed);
 624 static void     gtk_tree_view_state_flags_changed  (GtkWidget        *widget,
 625                                                     GtkStateFlags     previous_state);
 626
 627 /* container signals */
 628 static void     gtk_tree_view_remove               (GtkContainer     *container,
 629                                                     GtkWidget        *widget);
 630 static void     gtk_tree_view_forall               (GtkContainer     *container,
 631                                                     gboolean          include_internals,
 632                                                     GtkCallback       callback,
 633                                                     gpointer          callback_data);
 634
 635 /* Source side drag signals */
 636 static void gtk_tree_view_drag_begin       (GtkWidget        *widget,
 637                                             GdkDragContext   *context);
 638 static void gtk_tree_view_drag_end         (GtkWidget        *widget,
 639                                             GdkDragContext   *context);
 640 static void gtk_tree_view_drag_data_get    (GtkWidget        *widget,
 641                                             GdkDragContext   *context,
 642                                             GtkSelectionData *selection_data,
 643                                             guint             info,
 644                                             guint             time);
 645 static void gtk_tree_view_drag_data_delete (GtkWidget        *widget,
 646                                             GdkDragContext   *context);
 647
 648 /* Target side drag signals */
 649 static void     gtk_tree_view_drag_leave         (GtkWidget        *widget,
 650                                                   GdkDragContext   *context,
 651                                                   guint             time);
 652 static gboolean gtk_tree_view_drag_motion        (GtkWidget        *widget,
 653                                                   GdkDragContext   *context,
 654                                                   gint              x,
 655                                                   gint              y,
 656                                                   guint             time);
 657 static gboolean gtk_tree_view_drag_drop          (GtkWidget        *widget,
 658                                                   GdkDragContext   *context,
 659                                                   gint              x,
 660                                                   gint              y,
 661                                                   guint             time);
 662 static void     gtk_tree_view_drag_data_received (GtkWidget        *widget,
 663                                                   GdkDragContext   *context,
 664                                                   gint              x,
 665                                                   gint              y,
 666                                                   GtkSelectionData *selection_data,
 667                                                   guint             info,
 668                                                   guint             time);
 669
 670 /* tree_model signals */
 671 static gboolean gtk_tree_view_real_move_cursor            (GtkTreeView     *tree_view,
 672                                                            GtkMovementStep  step,
 673                                                            gint             count);
 674 static gboolean gtk_tree_view_real_select_all             (GtkTreeView     *tree_view);
 675 static gboolean gtk_tree_view_real_unselect_all           (GtkTreeView     *tree_view);
 676 static gboolean gtk_tree_view_real_select_cursor_row      (GtkTreeView     *tree_view,
 677                                                            gboolean         start_editing);
 678 static gboolean gtk_tree_view_real_toggle_cursor_row      (GtkTreeView     *tree_view);
 679 static gboolean gtk_tree_view_real_expand_collapse_cursor_row (GtkTreeView     *tree_view,
 680                                                                gboolean         logical,
 681                                                                gboolean         expand,
 682                                                                gboolean         open_all);
 683 static gboolean gtk_tree_view_real_select_cursor_parent   (GtkTreeView     *tree_view);
 684 static void gtk_tree_view_row_changed                     (GtkTreeModel    *model,
 685                                                            GtkTreePath     *path,
 686                                                            GtkTreeIter     *iter,
 687                                                            gpointer         data);
 688 static void gtk_tree_view_row_inserted                    (GtkTreeModel    *model,
 689                                                            GtkTreePath     *path,
 690                                                            GtkTreeIter     *iter,
 691                                                            gpointer         data);
 692 static void gtk_tree_view_row_has_child_toggled           (GtkTreeModel    *model,
 693                                                            GtkTreePath     *path,
 694                                                            GtkTreeIter     *iter,
 695                                                            gpointer         data);
 696 static void gtk_tree_view_row_deleted                     (GtkTreeModel    *model,
 697                                                            GtkTreePath     *path,
 698                                                            gpointer         data);
 699 static void gtk_tree_view_rows_reordered                  (GtkTreeModel    *model,
 700                                                            GtkTreePath     *parent,
 701                                                            GtkTreeIter     *iter,
 702                                                            gint            *new_order,
 703                                                            gpointer         data);
 704
 705 /* Incremental reflow */
 706 static gboolean validate_row             (GtkTreeView *tree_view,
 707                                           GtkRBTree   *tree,
 708                                           GtkRBNode   *node,
 709                                           GtkTreeIter *iter,
 710                                           GtkTreePath *path);
 711 static void     validate_visible_area    (GtkTreeView *tree_view);
 712 static gboolean validate_rows_handler    (GtkTreeView *tree_view);
 713 static gboolean do_validate_rows         (GtkTreeView *tree_view,
 714                                           gboolean     queue_resize);
 715 static gboolean validate_rows            (GtkTreeView *tree_view);
 716 static gboolean presize_handler_callback (gpointer     data);
 717 static void     install_presize_handler  (GtkTreeView *tree_view);
 718 static void     install_scroll_sync_handler (GtkTreeView *tree_view);
 719 static void     gtk_tree_view_set_top_row   (GtkTreeView *tree_view,
 720                                              GtkTreePath *path,
 721                                              gint         offset);
 722 static void     gtk_tree_view_dy_to_top_row (GtkTreeView *tree_view);
 723 static void     gtk_tree_view_top_row_to_dy (GtkTreeView *tree_view);
 724 static void     invalidate_empty_focus      (GtkTreeView *tree_view);
 725
 726 /* Internal functions */
 727 static gboolean gtk_tree_view_is_expander_column             (GtkTreeView        *tree_view,
 728                                                               GtkTreeViewColumn  *column);
 729 static inline gboolean gtk_tree_view_draw_expanders          (GtkTreeView        *tree_view);
 730 static void     gtk_tree_view_add_move_binding               (GtkBindingSet      *binding_set,
 731                                                               guint               keyval,
 732                                                               guint               modmask,
 733                                                               gboolean            add_shifted_binding,
 734                                                               GtkMovementStep     step,
 735                                                               gint                count);
 736 static gint     gtk_tree_view_unref_and_check_selection_tree (GtkTreeView        *tree_view,
 737                                                               GtkRBTree          *tree);
 738 static void     gtk_tree_view_queue_draw_path                (GtkTreeView        *tree_view,
 739                                                               GtkTreePath        *path,
 740                                                               const GdkRectangle *clip_rect);
 741 static void     gtk_tree_view_queue_draw_arrow               (GtkTreeView        *tree_view,
 742                                                               GtkRBTree          *tree,
 743                                                               GtkRBNode          *node);
 744 static void     gtk_tree_view_draw_arrow                     (GtkTreeView        *tree_view,
 745                                                               cairo_t            *cr,
 746                                                               GtkRBTree          *tree,
 747                                                               GtkRBNode          *node);
 748 static void     gtk_tree_view_get_arrow_xrange               (GtkTreeView        *tree_view,
 749                                                               GtkRBTree          *tree,
 750                                                               gint               *x1,
 751                                                               gint               *x2);
 752 static void     gtk_tree_view_adjustment_changed             (GtkAdjustment      *adjustment,
 753                                                               GtkTreeView        *tree_view);
 754 static void     gtk_tree_view_build_tree                     (GtkTreeView        *tree_view,
 755                                                               GtkRBTree          *tree,
 756                                                               GtkTreeIter        *iter,
 757                                                               gint                depth,
 758                                                               gboolean            recurse);
 759 static void     gtk_tree_view_clamp_node_visible             (GtkTreeView        *tree_view,
 760                                                               GtkRBTree          *tree,
 761                                                               GtkRBNode          *node);
 762 static void     gtk_tree_view_clamp_column_visible           (GtkTreeView        *tree_view,
 763                                                               GtkTreeViewColumn  *column,
 764                                                               gboolean            focus_to_cell);
 765 static gboolean gtk_tree_view_maybe_begin_dragging_row       (GtkTreeView        *tree_view,
 766                                                               GdkEventMotion     *event);
 767 static void     gtk_tree_view_focus_to_cursor                (GtkTreeView        *tree_view);
 768 static void     gtk_tree_view_move_cursor_up_down            (GtkTreeView        *tree_view,
 769                                                               gint                count);
 770 static void     gtk_tree_view_move_cursor_page_up_down       (GtkTreeView        *tree_view,
 771                                                               gint                count);
 772 static void     gtk_tree_view_move_cursor_left_right         (GtkTreeView        *tree_view,
 773                                                               gint                count);
 774 static void     gtk_tree_view_move_cursor_start_end          (GtkTreeView        *tree_view,
 775                                                               gint                count);
 776 static gboolean gtk_tree_view_real_collapse_row              (GtkTreeView        *tree_view,
 777                                                               GtkTreePath        *path,
 778                                                               GtkRBTree          *tree,
 779                                                               GtkRBNode          *node,
 780                                                               gboolean            animate);
 781 static gboolean gtk_tree_view_real_expand_row                (GtkTreeView        *tree_view,
 782                                                               GtkTreePath        *path,
 783                                                               GtkRBTree          *tree,
 784                                                               GtkRBNode          *node,
 785                                                               gboolean            open_all,
 786                                                               gboolean            animate);
 787 static void     gtk_tree_view_real_set_cursor                (GtkTreeView        *tree_view,
 788                                                               GtkTreePath        *path,
 789                                                               SetCursorFlags      flags);
 790 static gboolean gtk_tree_view_has_can_focus_cell             (GtkTreeView        *tree_view);
 791 static void     column_sizing_notify                         (GObject            *object,
 792                                                               GParamSpec         *pspec,
 793                                                               gpointer            data);
 794 static void     gtk_tree_view_stop_rubber_band               (GtkTreeView        *tree_view);
 795 static void     update_prelight                              (GtkTreeView        *tree_view,
 796                                                               int                 x,
 797                                                               int                 y);
 798
 799 static inline gint gtk_tree_view_get_effective_header_height (GtkTreeView *tree_view);
 800
 801 static inline gint gtk_tree_view_get_cell_area_y_offset      (GtkTreeView *tree_view,
 802                                                               GtkRBTree   *tree,
 803                                                               GtkRBNode   *node,
 804                                                               gint         vertical_separator);
 805 static inline gint gtk_tree_view_get_cell_area_height        (GtkTreeView *tree_view,
 806                                                               GtkRBNode   *node,
 807                                                               gint         vertical_separator);
 808
 809 static inline gint gtk_tree_view_get_row_y_offset            (GtkTreeView *tree_view,
 810                                                               GtkRBTree   *tree,
 811                                                               GtkRBNode   *node);
 812 static inline gint gtk_tree_view_get_row_height              (GtkTreeView *tree_view,
 813                                                               GtkRBNode   *node);
 814
 815 /* interactive search */
 816 static void     gtk_tree_view_ensure_interactive_directory (GtkTreeView *tree_view);
 817 static void     gtk_tree_view_search_dialog_hide        (GtkWidget        *search_dialog,
 818                                                          GtkTreeView      *tree_view,
 819                                                          GdkDevice        *device);
 820 static void     gtk_tree_view_search_position_func      (GtkTreeView      *tree_view,
 821                                                          GtkWidget        *search_dialog,
 822                                                          gpointer          user_data);
 823 static void     gtk_tree_view_search_disable_popdown    (GtkEntry         *entry,
 824                                                          GtkMenu          *menu,
 825                                                          gpointer          data);
 826 static void     gtk_tree_view_search_preedit_changed    (GtkIMContext     *im_context,
 827                                                          GtkTreeView      *tree_view);
 828 static void     gtk_tree_view_search_activate           (GtkEntry         *entry,
 829                                                          GtkTreeView      *tree_view);
 830 static gboolean gtk_tree_view_real_search_enable_popdown(gpointer          data);
 831 static void     gtk_tree_view_search_enable_popdown     (GtkWidget        *widget,
 832                                                          gpointer          data);
 833 static gboolean gtk_tree_view_search_delete_event       (GtkWidget        *widget,
 834                                                          GdkEventAny      *event,
 835                                                          GtkTreeView      *tree_view);
 836 static gboolean gtk_tree_view_search_button_press_event (GtkWidget        *widget,
 837                                                          GdkEventButton   *event,
 838                                                          GtkTreeView      *tree_view);
 839 static gboolean gtk_tree_view_search_scroll_event       (GtkWidget        *entry,
 840                                                          GdkEventScroll   *event,
 841                                                          GtkTreeView      *tree_view);
 842 static gboolean gtk_tree_view_search_key_press_event    (GtkWidget        *entry,
 843                                                          GdkEventKey      *event,
 844                                                          GtkTreeView      *tree_view);
 845 static gboolean gtk_tree_view_search_move               (GtkWidget        *window,
 846                                                          GtkTreeView      *tree_view,
 847                                                          gboolean          up);
 848 static gboolean gtk_tree_view_search_equal_func         (GtkTreeModel     *model,
 849                                                          gint              column,
 850                                                          const gchar      *key,
 851                                                          GtkTreeIter      *iter,
 852                                                          gpointer          search_data);
 853 static gboolean gtk_tree_view_search_iter               (GtkTreeModel     *model,
 854                                                          GtkTreeSelection *selection,
 855                                                          GtkTreeIter      *iter,
 856                                                          const gchar      *text,
 857                                                          gint             *count,
 858                                                          gint              n);
 859 static void     gtk_tree_view_search_init               (GtkWidget        *entry,
 860                                                          GtkTreeView      *tree_view);
 861 static void     gtk_tree_view_put                       (GtkTreeView      *tree_view,
 862                                                          GtkWidget        *child_widget,
 863                                                          gint              x,
 864                                                          gint              y,
 865                                                          gint              width,
 866                                                          gint              height);
 867 static gboolean gtk_tree_view_start_editing             (GtkTreeView      *tree_view,
 868                                                          GtkTreePath      *cursor_path,
 869                                                          gboolean          edit_only);
 870 static void gtk_tree_view_stop_editing                  (GtkTreeView *tree_view,
 871                                                          gboolean     cancel_editing);
 872 static gboolean gtk_tree_view_real_start_interactive_search (GtkTreeView *tree_view,
 873                                                              GdkDevice   *device,
 874                                                              gboolean     keybinding);
 875 static gboolean gtk_tree_view_start_interactive_search      (GtkTreeView *tree_view);
 876 static GtkTreeViewColumn *gtk_tree_view_get_drop_column (GtkTreeView       *tree_view,
 877                                                          GtkTreeViewColumn *column,
 878                                                          gint               drop_position);
 879
 880 /* GtkBuildable */
 881 static void     gtk_tree_view_buildable_add_child          (GtkBuildable      *tree_view,
 882                                                             GtkBuilder        *builder,
 883                                                             GObject           *child,
 884                                                             const gchar       *type);
 885 static GObject *gtk_tree_view_buildable_get_internal_child (GtkBuildable      *buildable,
 886                                                             GtkBuilder        *builder,
 887                                                             const gchar       *childname);
 888 static void     gtk_tree_view_buildable_init               (GtkBuildableIface *iface);
 889
 890 static GtkAdjustment *gtk_tree_view_do_get_hadjustment (GtkTreeView   *tree_view);
 891 static void           gtk_tree_view_do_set_hadjustment (GtkTreeView   *tree_view,
 892                                                         GtkAdjustment *adjustment);
 893 static GtkAdjustment *gtk_tree_view_do_get_vadjustment (GtkTreeView   *tree_view);
 894 static void           gtk_tree_view_do_set_vadjustment (GtkTreeView   *tree_view,
 895                                                         GtkAdjustment *adjustment);
 896
 897 static gboolean scroll_row_timeout                   (gpointer     data);
 898 static void     add_scroll_timeout                   (GtkTreeView *tree_view);
 899 static void     remove_scroll_timeout                (GtkTreeView *tree_view);
 900
 901 static guint tree_view_signals [LAST_SIGNAL] = { 0 };
 902
 903 \f
 904
 905 /* GType Methods
 906  */
 907
 908 G_DEFINE_TYPE_WITH_CODE (GtkTreeView, gtk_tree_view, GTK_TYPE_CONTAINER,
 909                          G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE,
 910                                                 gtk_tree_view_buildable_init)
 911                          G_IMPLEMENT_INTERFACE (GTK_TYPE_SCROLLABLE, NULL))
 912
 913 static void
 914 gtk_tree_view_class_init (GtkTreeViewClass *class)
 915 {
 916   GObjectClass *o_class;
 917   GtkWidgetClass *widget_class;
 918   GtkContainerClass *container_class;
 919   GtkBindingSet *binding_set;
 920
 921   binding_set = gtk_binding_set_by_class (class);
 922
 923   o_class = (GObjectClass *) class;
 924   widget_class = (GtkWidgetClass *) class;
 925   container_class = (GtkContainerClass *) class;
 926
 927   /* GObject signals */
 928   o_class->set_property = gtk_tree_view_set_property;
 929   o_class->get_property = gtk_tree_view_get_property;
 930   o_class->finalize = gtk_tree_view_finalize;
 931
 932   /* GtkWidget signals */
 933   widget_class->destroy = gtk_tree_view_destroy;
 934   widget_class->map = gtk_tree_view_map;
 935   widget_class->realize = gtk_tree_view_realize;
 936   widget_class->unrealize = gtk_tree_view_unrealize;
 937   widget_class->get_preferred_width = gtk_tree_view_get_preferred_width;
 938   widget_class->get_preferred_height = gtk_tree_view_get_preferred_height;
 939   widget_class->size_allocate = gtk_tree_view_size_allocate;
 940   widget_class->button_press_event = gtk_tree_view_button_press;
 941   widget_class->button_release_event = gtk_tree_view_button_release;
 942   widget_class->grab_broken_event = gtk_tree_view_grab_broken;
 943   /*widget_class->configure_event = gtk_tree_view_configure;*/
 944   widget_class->motion_notify_event = gtk_tree_view_motion;
 945   widget_class->draw = gtk_tree_view_draw;
 946   widget_class->key_press_event = gtk_tree_view_key_press;
 947   widget_class->key_release_event = gtk_tree_view_key_release;
 948   widget_class->enter_notify_event = gtk_tree_view_enter_notify;
 949   widget_class->leave_notify_event = gtk_tree_view_leave_notify;
 950   widget_class->focus_out_event = gtk_tree_view_focus_out;
 951   widget_class->drag_begin = gtk_tree_view_drag_begin;
 952   widget_class->drag_end = gtk_tree_view_drag_end;
 953   widget_class->drag_data_get = gtk_tree_view_drag_data_get;
 954   widget_class->drag_data_delete = gtk_tree_view_drag_data_delete;
 955   widget_class->drag_leave = gtk_tree_view_drag_leave;
 956   widget_class->drag_motion = gtk_tree_view_drag_motion;
 957   widget_class->drag_drop = gtk_tree_view_drag_drop;
 958   widget_class->drag_data_received = gtk_tree_view_drag_data_received;
 959   widget_class->focus = gtk_tree_view_focus;
 960   widget_class->grab_focus = gtk_tree_view_grab_focus;
 961   widget_class->style_updated = gtk_tree_view_style_updated;
 962   widget_class->grab_notify = gtk_tree_view_grab_notify;
 963   widget_class->state_flags_changed = gtk_tree_view_state_flags_changed;
 964
 965   /* GtkContainer signals */
 966   container_class->remove = gtk_tree_view_remove;
 967   container_class->forall = gtk_tree_view_forall;
 968   container_class->set_focus_child = gtk_tree_view_set_focus_child;
 969   container_class->get_path_for_child = gtk_tree_view_get_path_for_child;
 970
 971   class->move_cursor = gtk_tree_view_real_move_cursor;
 972   class->select_all = gtk_tree_view_real_select_all;
 973   class->unselect_all = gtk_tree_view_real_unselect_all;
 974   class->select_cursor_row = gtk_tree_view_real_select_cursor_row;
 975   class->toggle_cursor_row = gtk_tree_view_real_toggle_cursor_row;
 976   class->expand_collapse_cursor_row = gtk_tree_view_real_expand_collapse_cursor_row;
 977   class->select_cursor_parent = gtk_tree_view_real_select_cursor_parent;
 978   class->start_interactive_search = gtk_tree_view_start_interactive_search;
 979
 980   /* Properties */
 981
 982   g_object_class_install_property (o_class,
 983                                    PROP_MODEL,
 984                                    g_param_spec_object ("model",
 985                                                         P_("TreeView Model"),
 986                                                         P_("The model for the tree view"),
 987                                                         GTK_TYPE_TREE_MODEL,
 988                                                         GTK_PARAM_READWRITE));
 989
 990   g_object_class_override_property (o_class, PROP_HADJUSTMENT,    "hadjustment");
 991   g_object_class_override_property (o_class, PROP_VADJUSTMENT,    "vadjustment");
 992   g_object_class_override_property (o_class, PROP_HSCROLL_POLICY, "hscroll-policy");
 993   g_object_class_override_property (o_class, PROP_VSCROLL_POLICY, "vscroll-policy");
 994
 995   g_object_class_install_property (o_class,
 996                                    PROP_HEADERS_VISIBLE,
 997                                    g_param_spec_boolean ("headers-visible",
 998                                                          P_("Headers Visible"),
 999                                                          P_("Show the column header buttons"),
1000                                                          TRUE,
1001                                                          GTK_PARAM_READWRITE));
1002
1003   g_object_class_install_property (o_class,
1004                                    PROP_HEADERS_CLICKABLE,
1005                                    g_param_spec_boolean ("headers-clickable",
1006                                                          P_("Headers Clickable"),
1007                                                          P_("Column headers respond to click events"),
1008                                                          TRUE,
1009                                                          GTK_PARAM_READWRITE));
1010
1011   g_object_class_install_property (o_class,
1012                                    PROP_EXPANDER_COLUMN,
1013                                    g_param_spec_object ("expander-column",
1014                                                         P_("Expander Column"),
1015                                                         P_("Set the column for the expander column"),
1016                                                         GTK_TYPE_TREE_VIEW_COLUMN,
1017                                                         GTK_PARAM_READWRITE));
1018
1019   g_object_class_install_property (o_class,
1020                                    PROP_REORDERABLE,
1021                                    g_param_spec_boolean ("reorderable",
1022                                                          P_("Reorderable"),
1023                                                          P_("View is reorderable"),
1024                                                          FALSE,
1025                                                          GTK_PARAM_READWRITE));
1026
1027   g_object_class_install_property (o_class,
1028                                    PROP_RULES_HINT,
1029                                    g_param_spec_boolean ("rules-hint",
1030                                                          P_("Rules Hint"),
1031                                                          P_("Set a hint to the theme engine to draw rows in alternating colors"),
1032                                                          FALSE,
1033                                                          GTK_PARAM_READWRITE));
1034
1035     g_object_class_install_property (o_class,
1036                                      PROP_ENABLE_SEARCH,
1037                                      g_param_spec_boolean ("enable-search",
1038                                                            P_("Enable Search"),
1039                                                            P_("View allows user to search through columns interactively"),
1040                                                            TRUE,
1041                                                            GTK_PARAM_READWRITE));
1042
1043     g_object_class_install_property (o_class,
1044                                      PROP_SEARCH_COLUMN,
1045                                      g_param_spec_int ("search-column",
1046                                                        P_("Search Column"),
1047                                                        P_("Model column to search through during interactive search"),
1048                                                        -1,
1049                                                        G_MAXINT,
1050                                                        -1,
1051                                                        GTK_PARAM_READWRITE));
1052
1053     /**
1054      * GtkTreeView:fixed-height-mode:
1055      *
1056      * Setting the ::fixed-height-mode property to %TRUE speeds up
1057      * #GtkTreeView by assuming that all rows have the same height.
1058      * Only enable this option if all rows are the same height.
1059      * Please see gtk_tree_view_set_fixed_height_mode() for more
1060      * information on this option.
1061      *
1062      * Since: 2.4
1063      **/
1064     g_object_class_install_property (o_class,
1065                                      PROP_FIXED_HEIGHT_MODE,
1066                                      g_param_spec_boolean ("fixed-height-mode",
1067                                                            P_("Fixed Height Mode"),
1068                                                            P_("Speeds up GtkTreeView by assuming that all rows have the same height"),
1069                                                            FALSE,
1070                                                            GTK_PARAM_READWRITE));
1071
1072     /**
1073      * GtkTreeView:hover-selection:
1074      *
1075      * Enables or disables the hover selection mode of @tree_view.
1076      * Hover selection makes the selected row follow the pointer.
1077      * Currently, this works only for the selection modes
1078      * %GTK_SELECTION_SINGLE and %GTK_SELECTION_BROWSE.
1079      *
1080      * This mode is primarily intended for treeviews in popups, e.g.
1081      * in #GtkComboBox or #GtkEntryCompletion.
1082      *
1083      * Since: 2.6
1084      */
1085     g_object_class_install_property (o_class,
1086                                      PROP_HOVER_SELECTION,
1087                                      g_param_spec_boolean ("hover-selection",
1088                                                            P_("Hover Selection"),
1089                                                            P_("Whether the selection should follow the pointer"),
1090                                                            FALSE,
1091                                                            GTK_PARAM_READWRITE));
1092
1093     /**
1094      * GtkTreeView:hover-expand:
1095      *
1096      * Enables or disables the hover expansion mode of @tree_view.
1097      * Hover expansion makes rows expand or collapse if the pointer moves
1098      * over them.
1099      *
1100      * This mode is primarily intended for treeviews in popups, e.g.
1101      * in #GtkComboBox or #GtkEntryCompletion.
1102      *
1103      * Since: 2.6
1104      */
1105     g_object_class_install_property (o_class,
1106                                      PROP_HOVER_EXPAND,
1107                                      g_param_spec_boolean ("hover-expand",
1108                                                            P_("Hover Expand"),
1109                                                            P_("Whether rows should be expanded/collapsed when the pointer moves over them"),
1110                                                            FALSE,
1111                                                            GTK_PARAM_READWRITE));
1112
1113     /**
1114      * GtkTreeView:show-expanders:
1115      *
1116      * %TRUE if the view has expanders.
1117      *
1118      * Since: 2.12
1119      */
1120     g_object_class_install_property (o_class,
1121                                      PROP_SHOW_EXPANDERS,
1122                                      g_param_spec_boolean ("show-expanders",
1123                                                            P_("Show Expanders"),
1124                                                            P_("View has expanders"),
1125                                                            TRUE,
1126                                                            GTK_PARAM_READWRITE));
1127
1128     /**
1129      * GtkTreeView:level-indentation:
1130      *
1131      * Extra indentation for each level.
1132      *
1133      * Since: 2.12
1134      */
1135     g_object_class_install_property (o_class,
1136                                      PROP_LEVEL_INDENTATION,
1137                                      g_param_spec_int ("level-indentation",
1138                                                        P_("Level Indentation"),
1139                                                        P_("Extra indentation for each level"),
1140                                                        0,
1141                                                        G_MAXINT,
1142                                                        0,
1143                                                        GTK_PARAM_READWRITE));
1144
1145     g_object_class_install_property (o_class,
1146                                      PROP_RUBBER_BANDING,
1147                                      g_param_spec_boolean ("rubber-banding",
1148                                                            P_("Rubber Banding"),
1149                                                            P_("Whether to enable selection of multiple items by dragging the mouse pointer"),
1150                                                            FALSE,
1151                                                            GTK_PARAM_READWRITE));
1152
1153     g_object_class_install_property (o_class,
1154                                      PROP_ENABLE_GRID_LINES,
1155                                      g_param_spec_enum ("enable-grid-lines",
1156                                                         P_("Enable Grid Lines"),
1157                                                         P_("Whether grid lines should be drawn in the tree view"),
1158                                                         GTK_TYPE_TREE_VIEW_GRID_LINES,
1159                                                         GTK_TREE_VIEW_GRID_LINES_NONE,
1160                                                         GTK_PARAM_READWRITE));
1161
1162     g_object_class_install_property (o_class,
1163                                      PROP_ENABLE_TREE_LINES,
1164                                      g_param_spec_boolean ("enable-tree-lines",
1165                                                            P_("Enable Tree Lines"),
1166                                                            P_("Whether tree lines should be drawn in the tree view"),
1167                                                            FALSE,
1168                                                            GTK_PARAM_READWRITE));
1169
1170     g_object_class_install_property (o_class,
1171                                      PROP_TOOLTIP_COLUMN,
1172                                      g_param_spec_int ("tooltip-column",
1173                                                        P_("Tooltip Column"),
1174                                                        P_("The column in the model containing the tooltip texts for the rows"),
1175                                                        -1,
1176                                                        G_MAXINT,
1177                                                        -1,
1178                                                        GTK_PARAM_READWRITE));
1179
1180   /**
1181    * GtkTreeView:activate-on-single-click:
1182    *
1183    * The activate-on-single-click property specifies whether the "row-activated" signal
1184    * will be emitted after a single click.
1185    *
1186    * Since: 3.8
1187    */
1188   g_object_class_install_property (o_class,
1189                                    PROP_ACTIVATE_ON_SINGLE_CLICK,
1190                                    g_param_spec_boolean ("activate-on-single-click",
1191                                                          P_("Activate on Single Click"),
1192                                                          P_("Activate row on a single click"),
1193                                                          FALSE,
1194                                                          GTK_PARAM_READWRITE));
1195
1196   /* Style properties */
1197 #define _TREE_VIEW_EXPANDER_SIZE 14
1198 #define _TREE_VIEW_VERTICAL_SEPARATOR 2
1199 #define _TREE_VIEW_HORIZONTAL_SEPARATOR 2
1200
1201   gtk_widget_class_install_style_property (widget_class,
1202                                            g_param_spec_int ("expander-size",
1203                                                              P_("Expander Size"),
1204                                                              P_("Size of the expander arrow"),
1205                                                              0,
1206                                                              G_MAXINT,
1207                                                              _TREE_VIEW_EXPANDER_SIZE,
1208                                                              GTK_PARAM_READABLE));
1209
1210   gtk_widget_class_install_style_property (widget_class,
1211                                            g_param_spec_int ("vertical-separator",
1212                                                              P_("Vertical Separator Width"),
1213                                                              P_("Vertical space between cells.  Must be an even number"),
1214                                                              0,
1215                                                              G_MAXINT,
1216                                                              _TREE_VIEW_VERTICAL_SEPARATOR,
1217                                                              GTK_PARAM_READABLE));
1218
1219   gtk_widget_class_install_style_property (widget_class,
1220                                            g_param_spec_int ("horizontal-separator",
1221                                                              P_("Horizontal Separator Width"),
1222                                                              P_("Horizontal space between cells.  Must be an even number"),
1223                                                              0,
1224                                                              G_MAXINT,
1225                                                              _TREE_VIEW_HORIZONTAL_SEPARATOR,
1226                                                              GTK_PARAM_READABLE));
1227
1228   gtk_widget_class_install_style_property (widget_class,
1229                                            g_param_spec_boolean ("allow-rules",
1230                                                                  P_("Allow Rules"),
1231                                                                  P_("Allow drawing of alternating color rows"),
1232                                                                  TRUE,
1233                                                                  GTK_PARAM_READABLE));
1234
1235   gtk_widget_class_install_style_property (widget_class,
1236                                            g_param_spec_boolean ("indent-expanders",
1237                                                                  P_("Indent Expanders"),
1238                                                                  P_("Make the expanders indented"),
1239                                                                  TRUE,
1240                                                                  GTK_PARAM_READABLE));
1241
1242   gtk_widget_class_install_style_property (widget_class,
1243                                            g_param_spec_boxed ("even-row-color",
1244                                                                P_("Even Row Color"),
1245                                                                P_("Color to use for even rows"),
1246                                                                GDK_TYPE_COLOR,
1247                                                                GTK_PARAM_READABLE));
1248
1249   gtk_widget_class_install_style_property (widget_class,
1250                                            g_param_spec_boxed ("odd-row-color",
1251                                                                P_("Odd Row Color"),
1252                                                                P_("Color to use for odd rows"),
1253                                                                GDK_TYPE_COLOR,
1254                                                                GTK_PARAM_READABLE));
1255
1256   gtk_widget_class_install_style_property (widget_class,
1257                                            g_param_spec_int ("grid-line-width",
1258                                                              P_("Grid line width"),
1259                                                              P_("Width, in pixels, of the tree view grid lines"),
1260                                                              0, G_MAXINT, 1,
1261                                                              GTK_PARAM_READABLE));
1262
1263   gtk_widget_class_install_style_property (widget_class,
1264                                            g_param_spec_int ("tree-line-width",
1265                                                              P_("Tree line width"),
1266                                                              P_("Width, in pixels, of the tree view lines"),
1267                                                              0, G_MAXINT, 1,
1268                                                              GTK_PARAM_READABLE));
1269
1270   gtk_widget_class_install_style_property (widget_class,
1271                                            g_param_spec_string ("grid-line-pattern",
1272                                                                 P_("Grid line pattern"),
1273                                                                 P_("Dash pattern used to draw the tree view grid lines"),
1274                                                                 "\1\1",
1275                                                                 GTK_PARAM_READABLE));
1276
1277   gtk_widget_class_install_style_property (widget_class,
1278                                            g_param_spec_string ("tree-line-pattern",
1279                                                                 P_("Tree line pattern"),
1280                                                                 P_("Dash pattern used to draw the tree view lines"),
1281                                                                 "\1\1",
1282                                                                 GTK_PARAM_READABLE));
1283
1284   /* Signals */
1285   /**
1286    * GtkTreeView::row-activated:
1287    * @tree_view: the object on which the signal is emitted
1288    * @path: the #GtkTreePath for the activated row
1289    * @column: the #GtkTreeViewColumn in which the activation occurred
1290    *
1291    * The "row-activated" signal is emitted when the method
1292    * gtk_tree_view_row_activated() is called, when the user double
1293    * clicks a treeview row with the "activate-on-single-click"
1294    * property set to %FALSE, or when the user single clicks a row when
1295    * the "activate-on-single-click" property set to %TRUE. It is also
1296    * emitted when a non-editable row is selected and one of the keys:
1297    * Space, Shift+Space, Return or Enter is pressed.
1298    *
1299    * For selection handling refer to the <link linkend="TreeWidget">tree
1300    * widget conceptual overview</link> as well as #GtkTreeSelection.
1301    */
1302   tree_view_signals[ROW_ACTIVATED] =
1303     g_signal_new (I_("row-activated"),
1304                   G_TYPE_FROM_CLASS (o_class),
1305                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1306                   G_STRUCT_OFFSET (GtkTreeViewClass, row_activated),
1307                   NULL, NULL,
1308                   _gtk_marshal_VOID__BOXED_OBJECT,
1309                   G_TYPE_NONE, 2,
1310                   GTK_TYPE_TREE_PATH,
1311                   GTK_TYPE_TREE_VIEW_COLUMN);
1312
1313   /**
1314    * GtkTreeView::test-expand-row:
1315    * @tree_view: the object on which the signal is emitted
1316    * @iter: the tree iter of the row to expand
1317    * @path: a tree path that points to the row
1318    *
1319    * The given row is about to be expanded (show its children nodes). Use this
1320    * signal if you need to control the expandability of individual rows.
1321    *
1322    * Returns: %FALSE to allow expansion, %TRUE to reject
1323    */
1324   tree_view_signals[TEST_EXPAND_ROW] =
1325     g_signal_new (I_("test-expand-row"),
1326                   G_TYPE_FROM_CLASS (o_class),
1327                   G_SIGNAL_RUN_LAST,
1328                   G_STRUCT_OFFSET (GtkTreeViewClass, test_expand_row),
1329                   _gtk_boolean_handled_accumulator, NULL,
1330                   _gtk_marshal_BOOLEAN__BOXED_BOXED,
1331                   G_TYPE_BOOLEAN, 2,
1332                   GTK_TYPE_TREE_ITER,
1333                   GTK_TYPE_TREE_PATH);
1334
1335   /**
1336    * GtkTreeView::test-collapse-row:
1337    * @tree_view: the object on which the signal is emitted
1338    * @iter: the tree iter of the row to collapse
1339    * @path: a tree path that points to the row
1340    *
1341    * The given row is about to be collapsed (hide its children nodes). Use this
1342    * signal if you need to control the collapsibility of individual rows.
1343    *
1344    * Returns: %FALSE to allow collapsing, %TRUE to reject
1345    */
1346   tree_view_signals[TEST_COLLAPSE_ROW] =
1347     g_signal_new (I_("test-collapse-row"),
1348                   G_TYPE_FROM_CLASS (o_class),
1349                   G_SIGNAL_RUN_LAST,
1350                   G_STRUCT_OFFSET (GtkTreeViewClass, test_collapse_row),
1351                   _gtk_boolean_handled_accumulator, NULL,
1352                   _gtk_marshal_BOOLEAN__BOXED_BOXED,
1353                   G_TYPE_BOOLEAN, 2,
1354                   GTK_TYPE_TREE_ITER,
1355                   GTK_TYPE_TREE_PATH);
1356
1357   /**
1358    * GtkTreeView::row-expanded:
1359    * @tree_view: the object on which the signal is emitted
1360    * @iter: the tree iter of the expanded row
1361    * @path: a tree path that points to the row
1362    *
1363    * The given row has been expanded (child nodes are shown).
1364    */
1365   tree_view_signals[ROW_EXPANDED] =
1366     g_signal_new (I_("row-expanded"),
1367                   G_TYPE_FROM_CLASS (o_class),
1368                   G_SIGNAL_RUN_LAST,
1369                   G_STRUCT_OFFSET (GtkTreeViewClass, row_expanded),
1370                   NULL, NULL,
1371                   _gtk_marshal_VOID__BOXED_BOXED,
1372                   G_TYPE_NONE, 2,
1373                   GTK_TYPE_TREE_ITER,
1374                   GTK_TYPE_TREE_PATH);
1375
1376   /**
1377    * GtkTreeView::row-collapsed:
1378    * @tree_view: the object on which the signal is emitted
1379    * @iter: the tree iter of the collapsed row
1380    * @path: a tree path that points to the row
1381    *
1382    * The given row has been collapsed (child nodes are hidden).
1383    */
1384   tree_view_signals[ROW_COLLAPSED] =
1385     g_signal_new (I_("row-collapsed"),
1386                   G_TYPE_FROM_CLASS (o_class),
1387                   G_SIGNAL_RUN_LAST,
1388                   G_STRUCT_OFFSET (GtkTreeViewClass, row_collapsed),
1389                   NULL, NULL,
1390                   _gtk_marshal_VOID__BOXED_BOXED,
1391                   G_TYPE_NONE, 2,
1392                   GTK_TYPE_TREE_ITER,
1393                   GTK_TYPE_TREE_PATH);
1394
1395   /**
1396    * GtkTreeView::columns-changed:
1397    * @tree_view: the object on which the signal is emitted
1398    *
1399    * The number of columns of the treeview has changed.
1400    */
1401   tree_view_signals[COLUMNS_CHANGED] =
1402     g_signal_new (I_("columns-changed"),
1403                   G_TYPE_FROM_CLASS (o_class),
1404                   G_SIGNAL_RUN_LAST,
1405                   G_STRUCT_OFFSET (GtkTreeViewClass, columns_changed),
1406                   NULL, NULL,
1407                   _gtk_marshal_VOID__VOID,
1408                   G_TYPE_NONE, 0);
1409
1410   /**
1411    * GtkTreeView::cursor-changed:
1412    * @tree_view: the object on which the signal is emitted
1413    *
1414    * The position of the cursor (focused cell) has changed.
1415    */
1416   tree_view_signals[CURSOR_CHANGED] =
1417     g_signal_new (I_("cursor-changed"),
1418                   G_TYPE_FROM_CLASS (o_class),
1419                   G_SIGNAL_RUN_LAST,
1420                   G_STRUCT_OFFSET (GtkTreeViewClass, cursor_changed),
1421                   NULL, NULL,
1422                   _gtk_marshal_VOID__VOID,
1423                   G_TYPE_NONE, 0);
1424
1425   tree_view_signals[MOVE_CURSOR] =
1426     g_signal_new (I_("move-cursor"),
1427                   G_TYPE_FROM_CLASS (o_class),
1428                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1429                   G_STRUCT_OFFSET (GtkTreeViewClass, move_cursor),
1430                   NULL, NULL,
1431                   _gtk_marshal_BOOLEAN__ENUM_INT,
1432                   G_TYPE_BOOLEAN, 2,
1433                   GTK_TYPE_MOVEMENT_STEP,
1434                   G_TYPE_INT);
1435
1436   tree_view_signals[SELECT_ALL] =
1437     g_signal_new (I_("select-all"),
1438                   G_TYPE_FROM_CLASS (o_class),
1439                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1440                   G_STRUCT_OFFSET (GtkTreeViewClass, select_all),
1441                   NULL, NULL,
1442                   _gtk_marshal_BOOLEAN__VOID,
1443                   G_TYPE_BOOLEAN, 0);
1444
1445   tree_view_signals[UNSELECT_ALL] =
1446     g_signal_new (I_("unselect-all"),
1447                   G_TYPE_FROM_CLASS (o_class),
1448                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1449                   G_STRUCT_OFFSET (GtkTreeViewClass, unselect_all),
1450                   NULL, NULL,
1451                   _gtk_marshal_BOOLEAN__VOID,
1452                   G_TYPE_BOOLEAN, 0);
1453
1454   tree_view_signals[SELECT_CURSOR_ROW] =
1455     g_signal_new (I_("select-cursor-row"),
1456                   G_TYPE_FROM_CLASS (o_class),
1457                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1458                   G_STRUCT_OFFSET (GtkTreeViewClass, select_cursor_row),
1459                   NULL, NULL,
1460                   _gtk_marshal_BOOLEAN__BOOLEAN,
1461                   G_TYPE_BOOLEAN, 1,
1462                   G_TYPE_BOOLEAN);
1463
1464   tree_view_signals[TOGGLE_CURSOR_ROW] =
1465     g_signal_new (I_("toggle-cursor-row"),
1466                   G_TYPE_FROM_CLASS (o_class),
1467                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1468                   G_STRUCT_OFFSET (GtkTreeViewClass, toggle_cursor_row),
1469                   NULL, NULL,
1470                   _gtk_marshal_BOOLEAN__VOID,
1471                   G_TYPE_BOOLEAN, 0);
1472
1473   tree_view_signals[EXPAND_COLLAPSE_CURSOR_ROW] =
1474     g_signal_new (I_("expand-collapse-cursor-row"),
1475                   G_TYPE_FROM_CLASS (o_class),
1476                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1477                   G_STRUCT_OFFSET (GtkTreeViewClass, expand_collapse_cursor_row),
1478                   NULL, NULL,
1479                   _gtk_marshal_BOOLEAN__BOOLEAN_BOOLEAN_BOOLEAN,
1480                   G_TYPE_BOOLEAN, 3,
1481                   G_TYPE_BOOLEAN,
1482                   G_TYPE_BOOLEAN,
1483                   G_TYPE_BOOLEAN);
1484
1485   tree_view_signals[SELECT_CURSOR_PARENT] =
1486     g_signal_new (I_("select-cursor-parent"),
1487                   G_TYPE_FROM_CLASS (o_class),
1488                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1489                   G_STRUCT_OFFSET (GtkTreeViewClass, select_cursor_parent),
1490                   NULL, NULL,
1491                   _gtk_marshal_BOOLEAN__VOID,
1492                   G_TYPE_BOOLEAN, 0);
1493
1494   tree_view_signals[START_INTERACTIVE_SEARCH] =
1495     g_signal_new (I_("start-interactive-search"),
1496                   G_TYPE_FROM_CLASS (o_class),
1497                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1498                   G_STRUCT_OFFSET (GtkTreeViewClass, start_interactive_search),
1499                   NULL, NULL,
1500                   _gtk_marshal_BOOLEAN__VOID,
1501                   G_TYPE_BOOLEAN, 0);
1502
1503   /* Key bindings */
1504   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_Up, 0, TRUE,
1505                                   GTK_MOVEMENT_DISPLAY_LINES, -1);
1506   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_KP_Up, 0, TRUE,
1507                                   GTK_MOVEMENT_DISPLAY_LINES, -1);
1508
1509   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_Down, 0, TRUE,
1510                                   GTK_MOVEMENT_DISPLAY_LINES, 1);
1511   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_KP_Down, 0, TRUE,
1512                                   GTK_MOVEMENT_DISPLAY_LINES, 1);
1513
1514   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_p, GDK_CONTROL_MASK, FALSE,
1515                                   GTK_MOVEMENT_DISPLAY_LINES, -1);
1516
1517   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_n, GDK_CONTROL_MASK, FALSE,
1518                                   GTK_MOVEMENT_DISPLAY_LINES, 1);
1519
1520   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_Home, 0, TRUE,
1521                                   GTK_MOVEMENT_BUFFER_ENDS, -1);
1522   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_KP_Home, 0, TRUE,
1523                                   GTK_MOVEMENT_BUFFER_ENDS, -1);
1524
1525   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_End, 0, TRUE,
1526                                   GTK_MOVEMENT_BUFFER_ENDS, 1);
1527   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_KP_End, 0, TRUE,
1528                                   GTK_MOVEMENT_BUFFER_ENDS, 1);
1529
1530   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_Page_Up, 0, TRUE,
1531                                   GTK_MOVEMENT_PAGES, -1);
1532   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_KP_Page_Up, 0, TRUE,
1533                                   GTK_MOVEMENT_PAGES, -1);
1534
1535   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_Page_Down, 0, TRUE,
1536                                   GTK_MOVEMENT_PAGES, 1);
1537   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_KP_Page_Down, 0, TRUE,
1538                                   GTK_MOVEMENT_PAGES, 1);
1539
1540
1541   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Right, 0, "move-cursor", 2,
1542                                 G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
1543                                 G_TYPE_INT, 1);
1544
1545   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Left, 0, "move-cursor", 2,
1546                                 G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
1547                                 G_TYPE_INT, -1);
1548
1549   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Right, 0, "move-cursor", 2,
1550                                 G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
1551                                 G_TYPE_INT, 1);
1552
1553   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Left, 0, "move-cursor", 2,
1554                                 G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
1555                                 G_TYPE_INT, -1);
1556
1557   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Right, GDK_CONTROL_MASK,
1558                                 "move-cursor", 2,
1559                                 G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
1560                                 G_TYPE_INT, 1);
1561
1562   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Left, GDK_CONTROL_MASK,
1563                                 "move-cursor", 2,
1564                                 G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
1565                                 G_TYPE_INT, -1);
1566
1567   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Right, GDK_CONTROL_MASK,
1568                                 "move-cursor", 2,
1569                                 G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
1570                                 G_TYPE_INT, 1);
1571
1572   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Left, GDK_CONTROL_MASK,
1573                                 "move-cursor", 2,
1574                                 G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
1575                                 G_TYPE_INT, -1);
1576
1577   gtk_binding_entry_add_signal (binding_set, GDK_KEY_space, GDK_CONTROL_MASK, "toggle-cursor-row", 0);
1578   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Space, GDK_CONTROL_MASK, "toggle-cursor-row", 0);
1579
1580   gtk_binding_entry_add_signal (binding_set, GDK_KEY_a, GDK_CONTROL_MASK, "select-all", 0);
1581   gtk_binding_entry_add_signal (binding_set, GDK_KEY_slash, GDK_CONTROL_MASK, "select-all", 0);
1582
1583   gtk_binding_entry_add_signal (binding_set, GDK_KEY_A, GDK_CONTROL_MASK | GDK_SHIFT_MASK, "unselect-all", 0);
1584   gtk_binding_entry_add_signal (binding_set, GDK_KEY_backslash, GDK_CONTROL_MASK, "unselect-all", 0);
1585
1586   gtk_binding_entry_add_signal (binding_set, GDK_KEY_space, GDK_SHIFT_MASK, "select-cursor-row", 1,
1587                                 G_TYPE_BOOLEAN, TRUE);
1588   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Space, GDK_SHIFT_MASK, "select-cursor-row", 1,
1589                                 G_TYPE_BOOLEAN, TRUE);
1590
1591   gtk_binding_entry_add_signal (binding_set, GDK_KEY_space, 0, "select-cursor-row", 1,
1592                                 G_TYPE_BOOLEAN, TRUE);
1593   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Space, 0, "select-cursor-row", 1,
1594                                 G_TYPE_BOOLEAN, TRUE);
1595   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Return, 0, "select-cursor-row", 1,
1596                                 G_TYPE_BOOLEAN, TRUE);
1597   gtk_binding_entry_add_signal (binding_set, GDK_KEY_ISO_Enter, 0, "select-cursor-row", 1,
1598                                 G_TYPE_BOOLEAN, TRUE);
1599   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Enter, 0, "select-cursor-row", 1,
1600                                 G_TYPE_BOOLEAN, TRUE);
1601
1602   /* expand and collapse rows */
1603   gtk_binding_entry_add_signal (binding_set, GDK_KEY_plus, 0, "expand-collapse-cursor-row", 3,
1604                                 G_TYPE_BOOLEAN, TRUE,
1605                                 G_TYPE_BOOLEAN, TRUE,
1606                                 G_TYPE_BOOLEAN, FALSE);
1607
1608   gtk_binding_entry_add_signal (binding_set, GDK_KEY_asterisk, 0,
1609                                 "expand-collapse-cursor-row", 3,
1610                                 G_TYPE_BOOLEAN, TRUE,
1611                                 G_TYPE_BOOLEAN, TRUE,
1612                                 G_TYPE_BOOLEAN, TRUE);
1613   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Multiply, 0,
1614                                 "expand-collapse-cursor-row", 3,
1615                                 G_TYPE_BOOLEAN, TRUE,
1616                                 G_TYPE_BOOLEAN, TRUE,
1617                                 G_TYPE_BOOLEAN, TRUE);
1618
1619   gtk_binding_entry_add_signal (binding_set, GDK_KEY_slash, 0,
1620                                 "expand-collapse-cursor-row", 3,
1621                                 G_TYPE_BOOLEAN, TRUE,
1622                                 G_TYPE_BOOLEAN, FALSE,
1623                                 G_TYPE_BOOLEAN, FALSE);
1624   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Divide, 0,
1625                                 "expand-collapse-cursor-row", 3,
1626                                 G_TYPE_BOOLEAN, TRUE,
1627                                 G_TYPE_BOOLEAN, FALSE,
1628                                 G_TYPE_BOOLEAN, FALSE);
1629
1630   /* Not doable on US keyboards */
1631   gtk_binding_entry_add_signal (binding_set, GDK_KEY_plus, GDK_SHIFT_MASK, "expand-collapse-cursor-row", 3,
1632                                 G_TYPE_BOOLEAN, TRUE,
1633                                 G_TYPE_BOOLEAN, TRUE,
1634                                 G_TYPE_BOOLEAN, TRUE);
1635   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Add, 0, "expand-collapse-cursor-row", 3,
1636                                 G_TYPE_BOOLEAN, TRUE,
1637                                 G_TYPE_BOOLEAN, TRUE,
1638                                 G_TYPE_BOOLEAN, FALSE);
1639   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Add, GDK_SHIFT_MASK, "expand-collapse-cursor-row", 3,
1640                                 G_TYPE_BOOLEAN, TRUE,
1641                                 G_TYPE_BOOLEAN, TRUE,
1642                                 G_TYPE_BOOLEAN, TRUE);
1643   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Add, GDK_SHIFT_MASK, "expand-collapse-cursor-row", 3,
1644                                 G_TYPE_BOOLEAN, TRUE,
1645                                 G_TYPE_BOOLEAN, TRUE,
1646                                 G_TYPE_BOOLEAN, TRUE);
1647   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Right, GDK_SHIFT_MASK,
1648                                 "expand-collapse-cursor-row", 3,
1649                                 G_TYPE_BOOLEAN, FALSE,
1650                                 G_TYPE_BOOLEAN, TRUE,
1651                                 G_TYPE_BOOLEAN, TRUE);
1652   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Right, GDK_SHIFT_MASK,
1653                                 "expand-collapse-cursor-row", 3,
1654                                 G_TYPE_BOOLEAN, FALSE,
1655                                 G_TYPE_BOOLEAN, TRUE,
1656                                 G_TYPE_BOOLEAN, TRUE);
1657   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Right,
1658                                 GDK_CONTROL_MASK | GDK_SHIFT_MASK,
1659                                 "expand-collapse-cursor-row", 3,
1660                                 G_TYPE_BOOLEAN, FALSE,
1661                                 G_TYPE_BOOLEAN, TRUE,
1662                                 G_TYPE_BOOLEAN, TRUE);
1663   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Right,
1664                                 GDK_CONTROL_MASK | GDK_SHIFT_MASK,
1665                                 "expand-collapse-cursor-row", 3,
1666                                 G_TYPE_BOOLEAN, FALSE,
1667                                 G_TYPE_BOOLEAN, TRUE,
1668                                 G_TYPE_BOOLEAN, TRUE);
1669
1670   gtk_binding_entry_add_signal (binding_set, GDK_KEY_minus, 0, "expand-collapse-cursor-row", 3,
1671                                 G_TYPE_BOOLEAN, TRUE,
1672                                 G_TYPE_BOOLEAN, FALSE,
1673                                 G_TYPE_BOOLEAN, FALSE);
1674   gtk_binding_entry_add_signal (binding_set, GDK_KEY_minus, GDK_SHIFT_MASK, "expand-collapse-cursor-row", 3,
1675                                 G_TYPE_BOOLEAN, TRUE,
1676                                 G_TYPE_BOOLEAN, FALSE,
1677                                 G_TYPE_BOOLEAN, TRUE);
1678   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Subtract, 0, "expand-collapse-cursor-row", 3,
1679                                 G_TYPE_BOOLEAN, TRUE,
1680                                 G_TYPE_BOOLEAN, FALSE,
1681                                 G_TYPE_BOOLEAN, FALSE);
1682   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Subtract, GDK_SHIFT_MASK, "expand-collapse-cursor-row", 3,
1683                                 G_TYPE_BOOLEAN, TRUE,
1684                                 G_TYPE_BOOLEAN, FALSE,
1685                                 G_TYPE_BOOLEAN, TRUE);
1686   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Left, GDK_SHIFT_MASK,
1687                                 "expand-collapse-cursor-row", 3,
1688                                 G_TYPE_BOOLEAN, FALSE,
1689                                 G_TYPE_BOOLEAN, FALSE,
1690                                 G_TYPE_BOOLEAN, TRUE);
1691   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Left, GDK_SHIFT_MASK,
1692                                 "expand-collapse-cursor-row", 3,
1693                                 G_TYPE_BOOLEAN, FALSE,
1694                                 G_TYPE_BOOLEAN, FALSE,
1695                                 G_TYPE_BOOLEAN, TRUE);
1696   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Left,
1697                                 GDK_CONTROL_MASK | GDK_SHIFT_MASK,
1698                                 "expand-collapse-cursor-row", 3,
1699                                 G_TYPE_BOOLEAN, FALSE,
1700                                 G_TYPE_BOOLEAN, FALSE,
1701                                 G_TYPE_BOOLEAN, TRUE);
1702   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Left,
1703                                 GDK_CONTROL_MASK | GDK_SHIFT_MASK,
1704                                 "expand-collapse-cursor-row", 3,
1705                                 G_TYPE_BOOLEAN, FALSE,
1706                                 G_TYPE_BOOLEAN, FALSE,
1707                                 G_TYPE_BOOLEAN, TRUE);
1708
1709   gtk_binding_entry_add_signal (binding_set, GDK_KEY_BackSpace, 0, "select-cursor-parent", 0);
1710   gtk_binding_entry_add_signal (binding_set, GDK_KEY_BackSpace, GDK_CONTROL_MASK, "select-cursor-parent", 0);
1711
1712   gtk_binding_entry_add_signal (binding_set, GDK_KEY_f, GDK_CONTROL_MASK, "start-interactive-search", 0);
1713
1714   gtk_binding_entry_add_signal (binding_set, GDK_KEY_F, GDK_CONTROL_MASK, "start-interactive-search", 0);
1715
1716   g_type_class_add_private (o_class, sizeof (GtkTreeViewPrivate));
1717
1718   gtk_widget_class_set_accessible_type (widget_class, GTK_TYPE_TREE_VIEW_ACCESSIBLE);
1719 }
1720
1721 static void
1722 gtk_tree_view_init (GtkTreeView *tree_view)
1723 {
1724   tree_view->priv = G_TYPE_INSTANCE_GET_PRIVATE (tree_view, GTK_TYPE_TREE_VIEW, GtkTreeViewPrivate);
1725
1726   gtk_widget_set_can_focus (GTK_WIDGET (tree_view), TRUE);
1727   gtk_widget_set_redraw_on_allocate (GTK_WIDGET (tree_view), FALSE);
1728
1729   tree_view->priv->show_expanders = TRUE;
1730   tree_view->priv->draw_keyfocus = TRUE;
1731   tree_view->priv->headers_visible = TRUE;
1732   tree_view->priv->activate_on_single_click = FALSE;
1733
1734   /* We need some padding */
1735   tree_view->priv->dy = 0;
1736   tree_view->priv->cursor_offset = 0;
1737   tree_view->priv->n_columns = 0;
1738   tree_view->priv->header_height = 1;
1739   tree_view->priv->x_drag = 0;
1740   tree_view->priv->drag_pos = -1;
1741   tree_view->priv->minimum_width = 0;
1742   tree_view->priv->natural_width = 0;
1743   tree_view->priv->n_expand_columns = 0;
1744   tree_view->priv->header_has_focus = FALSE;
1745   tree_view->priv->pressed_button = -1;
1746   tree_view->priv->press_start_x = -1;
1747   tree_view->priv->press_start_y = -1;
1748   tree_view->priv->reorderable = FALSE;
1749   tree_view->priv->presize_handler_timer = 0;
1750   tree_view->priv->scroll_sync_timer = 0;
1751   tree_view->priv->fixed_height = -1;
1752   tree_view->priv->fixed_height_mode = FALSE;
1753   tree_view->priv->fixed_height_check = 0;
1754   tree_view->priv->selection = _gtk_tree_selection_new_with_tree_view (tree_view);
1755   tree_view->priv->enable_search = TRUE;
1756   tree_view->priv->search_column = -1;
1757   tree_view->priv->search_position_func = gtk_tree_view_search_position_func;
1758   tree_view->priv->search_equal_func = gtk_tree_view_search_equal_func;
1759   tree_view->priv->search_custom_entry_set = FALSE;
1760   tree_view->priv->typeselect_flush_timeout = 0;
1761   tree_view->priv->init_hadjust_value = TRUE;
1762   tree_view->priv->width = 0;
1763
1764   tree_view->priv->hover_selection = FALSE;
1765   tree_view->priv->hover_expand = FALSE;
1766
1767   tree_view->priv->level_indentation = 0;
1768
1769   tree_view->priv->rubber_banding_enable = FALSE;
1770
1771   tree_view->priv->grid_lines = GTK_TREE_VIEW_GRID_LINES_NONE;
1772   tree_view->priv->tree_lines_enabled = FALSE;
1773
1774   tree_view->priv->tooltip_column = -1;
1775
1776   tree_view->priv->last_button_x = -1;
1777   tree_view->priv->last_button_y = -1;
1778
1779   tree_view->priv->event_last_x = -10000;
1780   tree_view->priv->event_last_y = -10000;
1781
1782   gtk_tree_view_do_set_vadjustment (tree_view, NULL);
1783   gtk_tree_view_do_set_hadjustment (tree_view, NULL);
1784
1785   gtk_style_context_add_class (gtk_widget_get_style_context (GTK_WIDGET (tree_view)),
1786                                GTK_STYLE_CLASS_VIEW);
1787 }
1788
1789 \f
1790
1791 /* GObject Methods
1792  */
1793
1794 static void
1795 gtk_tree_view_set_property (GObject         *object,
1796                             guint            prop_id,
1797                             const GValue    *value,
1798                             GParamSpec      *pspec)
1799 {
1800   GtkTreeView *tree_view;
1801
1802   tree_view = GTK_TREE_VIEW (object);
1803
1804   switch (prop_id)
1805     {
1806     case PROP_MODEL:
1807       gtk_tree_view_set_model (tree_view, g_value_get_object (value));
1808       break;
1809     case PROP_HADJUSTMENT:
1810       gtk_tree_view_do_set_hadjustment (tree_view, g_value_get_object (value));
1811       break;
1812     case PROP_VADJUSTMENT:
1813       gtk_tree_view_do_set_vadjustment (tree_view, g_value_get_object (value));
1814       break;
1815     case PROP_HSCROLL_POLICY:
1816       tree_view->priv->hscroll_policy = g_value_get_enum (value);
1817       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
1818       break;
1819     case PROP_VSCROLL_POLICY:
1820       tree_view->priv->vscroll_policy = g_value_get_enum (value);
1821       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
1822       break;
1823     case PROP_HEADERS_VISIBLE:
1824       gtk_tree_view_set_headers_visible (tree_view, g_value_get_boolean (value));
1825       break;
1826     case PROP_HEADERS_CLICKABLE:
1827       gtk_tree_view_set_headers_clickable (tree_view, g_value_get_boolean (value));
1828       break;
1829     case PROP_EXPANDER_COLUMN:
1830       gtk_tree_view_set_expander_column (tree_view, g_value_get_object (value));
1831       break;
1832     case PROP_REORDERABLE:
1833       gtk_tree_view_set_reorderable (tree_view, g_value_get_boolean (value));
1834       break;
1835     case PROP_RULES_HINT:
1836       gtk_tree_view_set_rules_hint (tree_view, g_value_get_boolean (value));
1837       break;
1838     case PROP_ENABLE_SEARCH:
1839       gtk_tree_view_set_enable_search (tree_view, g_value_get_boolean (value));
1840       break;
1841     case PROP_SEARCH_COLUMN:
1842       gtk_tree_view_set_search_column (tree_view, g_value_get_int (value));
1843       break;
1844     case PROP_FIXED_HEIGHT_MODE:
1845       gtk_tree_view_set_fixed_height_mode (tree_view, g_value_get_boolean (value));
1846       break;
1847     case PROP_HOVER_SELECTION:
1848       tree_view->priv->hover_selection = g_value_get_boolean (value);
1849       break;
1850     case PROP_HOVER_EXPAND:
1851       tree_view->priv->hover_expand = g_value_get_boolean (value);
1852       break;
1853     case PROP_SHOW_EXPANDERS:
1854       gtk_tree_view_set_show_expanders (tree_view, g_value_get_boolean (value));
1855       break;
1856     case PROP_LEVEL_INDENTATION:
1857       tree_view->priv->level_indentation = g_value_get_int (value);
1858       break;
1859     case PROP_RUBBER_BANDING:
1860       tree_view->priv->rubber_banding_enable = g_value_get_boolean (value);
1861       break;
1862     case PROP_ENABLE_GRID_LINES:
1863       gtk_tree_view_set_grid_lines (tree_view, g_value_get_enum (value));
1864       break;
1865     case PROP_ENABLE_TREE_LINES:
1866       gtk_tree_view_set_enable_tree_lines (tree_view, g_value_get_boolean (value));
1867       break;
1868     case PROP_TOOLTIP_COLUMN:
1869       gtk_tree_view_set_tooltip_column (tree_view, g_value_get_int (value));
1870       break;
1871     case PROP_ACTIVATE_ON_SINGLE_CLICK:
1872       gtk_tree_view_set_activate_on_single_click (tree_view, g_value_get_boolean (value));
1873       break;
1874     default:
1875       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1876       break;
1877     }
1878 }
1879
1880 static void
1881 gtk_tree_view_get_property (GObject    *object,
1882                             guint       prop_id,
1883                             GValue     *value,
1884                             GParamSpec *pspec)
1885 {
1886   GtkTreeView *tree_view;
1887
1888   tree_view = GTK_TREE_VIEW (object);
1889
1890   switch (prop_id)
1891     {
1892     case PROP_MODEL:
1893       g_value_set_object (value, tree_view->priv->model);
1894       break;
1895     case PROP_HADJUSTMENT:
1896       g_value_set_object (value, tree_view->priv->hadjustment);
1897       break;
1898     case PROP_VADJUSTMENT:
1899       g_value_set_object (value, tree_view->priv->vadjustment);
1900       break;
1901     case PROP_HSCROLL_POLICY:
1902       g_value_set_enum (value, tree_view->priv->hscroll_policy);
1903       break;
1904     case PROP_VSCROLL_POLICY:
1905       g_value_set_enum (value, tree_view->priv->vscroll_policy);
1906       break;
1907     case PROP_HEADERS_VISIBLE:
1908       g_value_set_boolean (value, gtk_tree_view_get_headers_visible (tree_view));
1909       break;
1910     case PROP_HEADERS_CLICKABLE:
1911       g_value_set_boolean (value, gtk_tree_view_get_headers_clickable (tree_view));
1912       break;
1913     case PROP_EXPANDER_COLUMN:
1914       g_value_set_object (value, tree_view->priv->expander_column);
1915       break;
1916     case PROP_REORDERABLE:
1917       g_value_set_boolean (value, tree_view->priv->reorderable);
1918       break;
1919     case PROP_RULES_HINT:
1920       g_value_set_boolean (value, tree_view->priv->has_rules);
1921       break;
1922     case PROP_ENABLE_SEARCH:
1923       g_value_set_boolean (value, tree_view->priv->enable_search);
1924       break;
1925     case PROP_SEARCH_COLUMN:
1926       g_value_set_int (value, tree_view->priv->search_column);
1927       break;
1928     case PROP_FIXED_HEIGHT_MODE:
1929       g_value_set_boolean (value, tree_view->priv->fixed_height_mode);
1930       break;
1931     case PROP_HOVER_SELECTION:
1932       g_value_set_boolean (value, tree_view->priv->hover_selection);
1933       break;
1934     case PROP_HOVER_EXPAND:
1935       g_value_set_boolean (value, tree_view->priv->hover_expand);
1936       break;
1937     case PROP_SHOW_EXPANDERS:
1938       g_value_set_boolean (value, tree_view->priv->show_expanders);
1939       break;
1940     case PROP_LEVEL_INDENTATION:
1941       g_value_set_int (value, tree_view->priv->level_indentation);
1942       break;
1943     case PROP_RUBBER_BANDING:
1944       g_value_set_boolean (value, tree_view->priv->rubber_banding_enable);
1945       break;
1946     case PROP_ENABLE_GRID_LINES:
1947       g_value_set_enum (value, tree_view->priv->grid_lines);
1948       break;
1949     case PROP_ENABLE_TREE_LINES:
1950       g_value_set_boolean (value, tree_view->priv->tree_lines_enabled);
1951       break;
1952     case PROP_TOOLTIP_COLUMN:
1953       g_value_set_int (value, tree_view->priv->tooltip_column);
1954       break;
1955     case PROP_ACTIVATE_ON_SINGLE_CLICK:
1956       g_value_set_boolean (value, tree_view->priv->activate_on_single_click);
1957       break;
1958     default:
1959       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1960       break;
1961     }
1962 }
1963
1964 static void
1965 gtk_tree_view_finalize (GObject *object)
1966 {
1967   G_OBJECT_CLASS (gtk_tree_view_parent_class)->finalize (object);
1968 }
1969
1970
1971 static GtkBuildableIface *parent_buildable_iface;
1972
1973 static void
1974 gtk_tree_view_buildable_init (GtkBuildableIface *iface)
1975 {
1976   parent_buildable_iface = g_type_interface_peek_parent (iface);
1977   iface->add_child = gtk_tree_view_buildable_add_child;
1978   iface->get_internal_child = gtk_tree_view_buildable_get_internal_child;
1979 }
1980
1981 static void
1982 gtk_tree_view_buildable_add_child (GtkBuildable *tree_view,
1983                                    GtkBuilder  *builder,
1984                                    GObject     *child,
1985                                    const gchar *type)
1986 {
1987   gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), GTK_TREE_VIEW_COLUMN (child));
1988 }
1989
1990 static GObject *
1991 gtk_tree_view_buildable_get_internal_child (GtkBuildable      *buildable,
1992                                             GtkBuilder        *builder,
1993                                             const gchar       *childname)
1994 {
1995     if (strcmp (childname, "selection") == 0)
1996       return G_OBJECT (GTK_TREE_VIEW (buildable)->priv->selection);
1997
1998     return parent_buildable_iface->get_internal_child (buildable,
1999                                                        builder,
2000                                                        childname);
2001 }
2002
2003 /* GtkWidget Methods
2004  */
2005
2006 static void
2007 gtk_tree_view_free_rbtree (GtkTreeView *tree_view)
2008 {
2009   _gtk_rbtree_free (tree_view->priv->tree);
2010
2011   tree_view->priv->tree = NULL;
2012   tree_view->priv->button_pressed_node = NULL;
2013   tree_view->priv->button_pressed_tree = NULL;
2014   tree_view->priv->prelight_tree = NULL;
2015   tree_view->priv->prelight_node = NULL;
2016   tree_view->priv->expanded_collapsed_node = NULL;
2017   tree_view->priv->expanded_collapsed_tree = NULL;
2018 }
2019
2020 static void
2021 gtk_tree_view_destroy (GtkWidget *widget)
2022 {
2023   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
2024   GList *list;
2025
2026   gtk_tree_view_stop_editing (tree_view, TRUE);
2027
2028   if (tree_view->priv->columns != NULL)
2029     {
2030       list = tree_view->priv->columns;
2031       while (list)
2032         {
2033           GtkTreeViewColumn *column;
2034           column = GTK_TREE_VIEW_COLUMN (list->data);
2035           list = list->next;
2036           gtk_tree_view_remove_column (tree_view, column);
2037         }
2038       tree_view->priv->columns = NULL;
2039     }
2040
2041   if (tree_view->priv->tree != NULL)
2042     {
2043       gtk_tree_view_unref_and_check_selection_tree (tree_view, tree_view->priv->tree);
2044
2045       gtk_tree_view_free_rbtree (tree_view);
2046     }
2047
2048   if (tree_view->priv->selection != NULL)
2049     {
2050       _gtk_tree_selection_set_tree_view (tree_view->priv->selection, NULL);
2051       g_object_unref (tree_view->priv->selection);
2052       tree_view->priv->selection = NULL;
2053     }
2054
2055   if (tree_view->priv->scroll_to_path != NULL)
2056     {
2057       gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
2058       tree_view->priv->scroll_to_path = NULL;
2059     }
2060
2061   if (tree_view->priv->drag_dest_row != NULL)
2062     {
2063       gtk_tree_row_reference_free (tree_view->priv->drag_dest_row);
2064       tree_view->priv->drag_dest_row = NULL;
2065     }
2066
2067   if (tree_view->priv->top_row != NULL)
2068     {
2069       gtk_tree_row_reference_free (tree_view->priv->top_row);
2070       tree_view->priv->top_row = NULL;
2071     }
2072
2073   if (tree_view->priv->column_drop_func_data &&
2074       tree_view->priv->column_drop_func_data_destroy)
2075     {
2076       tree_view->priv->column_drop_func_data_destroy (tree_view->priv->column_drop_func_data);
2077       tree_view->priv->column_drop_func_data = NULL;
2078     }
2079
2080   if (tree_view->priv->destroy_count_destroy &&
2081       tree_view->priv->destroy_count_data)
2082     {
2083       tree_view->priv->destroy_count_destroy (tree_view->priv->destroy_count_data);
2084       tree_view->priv->destroy_count_data = NULL;
2085     }
2086
2087   gtk_tree_row_reference_free (tree_view->priv->anchor);
2088   tree_view->priv->anchor = NULL;
2089
2090   /* destroy interactive search dialog */
2091   if (tree_view->priv->search_window)
2092     {
2093       gtk_widget_destroy (tree_view->priv->search_window);
2094       tree_view->priv->search_window = NULL;
2095       tree_view->priv->search_entry = NULL;
2096       if (tree_view->priv->typeselect_flush_timeout)
2097         {
2098           g_source_remove (tree_view->priv->typeselect_flush_timeout);
2099           tree_view->priv->typeselect_flush_timeout = 0;
2100         }
2101     }
2102
2103   if (tree_view->priv->search_destroy && tree_view->priv->search_user_data)
2104     {
2105       tree_view->priv->search_destroy (tree_view->priv->search_user_data);
2106       tree_view->priv->search_user_data = NULL;
2107     }
2108
2109   if (tree_view->priv->search_position_destroy && tree_view->priv->search_position_user_data)
2110     {
2111       tree_view->priv->search_position_destroy (tree_view->priv->search_position_user_data);
2112       tree_view->priv->search_position_user_data = NULL;
2113     }
2114
2115   if (tree_view->priv->row_separator_destroy && tree_view->priv->row_separator_data)
2116     {
2117       tree_view->priv->row_separator_destroy (tree_view->priv->row_separator_data);
2118       tree_view->priv->row_separator_data = NULL;
2119     }
2120
2121   gtk_tree_view_set_model (tree_view, NULL);
2122
2123   if (tree_view->priv->hadjustment)
2124     {
2125       g_object_unref (tree_view->priv->hadjustment);
2126       tree_view->priv->hadjustment = NULL;
2127     }
2128   if (tree_view->priv->vadjustment)
2129     {
2130       g_object_unref (tree_view->priv->vadjustment);
2131       tree_view->priv->vadjustment = NULL;
2132     }
2133
2134   GTK_WIDGET_CLASS (gtk_tree_view_parent_class)->destroy (widget);
2135 }
2136
2137 /* GtkWidget::map helper */
2138 static void
2139 gtk_tree_view_map_buttons (GtkTreeView *tree_view)
2140 {
2141   GList *list;
2142
2143   g_return_if_fail (gtk_widget_get_mapped (GTK_WIDGET (tree_view)));
2144
2145   if (tree_view->priv->headers_visible)
2146     {
2147       GtkTreeViewColumn *column;
2148       GtkWidget         *button;
2149       GdkWindow         *window;
2150
2151       for (list = tree_view->priv->columns; list; list = list->next)
2152         {
2153           column = list->data;
2154           button = gtk_tree_view_column_get_button (column);
2155
2156           if (gtk_tree_view_column_get_visible (column) && button)
2157             gtk_widget_show_now (button);
2158
2159           if (gtk_widget_get_visible (button) &&
2160               !gtk_widget_get_mapped (button))
2161             gtk_widget_map (button);
2162         }
2163       for (list = tree_view->priv->columns; list; list = list->next)
2164         {
2165           column = list->data;
2166           if (gtk_tree_view_column_get_visible (column) == FALSE)
2167             continue;
2168
2169           window = _gtk_tree_view_column_get_window (column);
2170           if (gtk_tree_view_column_get_resizable (column))
2171             {
2172               gdk_window_raise (window);
2173               gdk_window_show (window);
2174             }
2175           else
2176             gdk_window_hide (window);
2177         }
2178       gdk_window_show (tree_view->priv->header_window);
2179     }
2180 }
2181
2182 static void
2183 gtk_tree_view_map (GtkWidget *widget)
2184 {
2185   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
2186   GList *tmp_list;
2187
2188   gtk_widget_set_mapped (widget, TRUE);
2189
2190   tmp_list = tree_view->priv->children;
2191   while (tmp_list)
2192     {
2193       GtkTreeViewChild *child = tmp_list->data;
2194       tmp_list = tmp_list->next;
2195
2196       if (gtk_widget_get_visible (child->widget))
2197         {
2198           if (!gtk_widget_get_mapped (child->widget))
2199             gtk_widget_map (child->widget);
2200         }
2201     }
2202   gdk_window_show (tree_view->priv->bin_window);
2203
2204   gtk_tree_view_map_buttons (tree_view);
2205
2206   gdk_window_show (gtk_widget_get_window (widget));
2207 }
2208
2209 static void
2210 gtk_tree_view_ensure_background (GtkTreeView *tree_view)
2211 {
2212   GtkStyleContext *context;
2213
2214   context = gtk_widget_get_style_context (GTK_WIDGET (tree_view));
2215
2216   gtk_style_context_set_background (context, tree_view->priv->bin_window);
2217   gtk_style_context_set_background (context, gtk_widget_get_window (GTK_WIDGET (tree_view)));
2218   gtk_style_context_set_background (context, tree_view->priv->header_window);
2219 }
2220
2221 static void
2222 gtk_tree_view_realize (GtkWidget *widget)
2223 {
2224   GtkAllocation allocation;
2225   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
2226   GdkWindow *window;
2227   GdkWindowAttr attributes;
2228   GList *tmp_list;
2229   gint attributes_mask;
2230
2231   gtk_widget_set_realized (widget, TRUE);
2232
2233   gtk_widget_get_allocation (widget, &allocation);
2234
2235   /* Make the main, clipping window */
2236   attributes.window_type = GDK_WINDOW_CHILD;
2237   attributes.x = allocation.x;
2238   attributes.y = allocation.y;
2239   attributes.width = allocation.width;
2240   attributes.height = allocation.height;
2241   attributes.wclass = GDK_INPUT_OUTPUT;
2242   attributes.visual = gtk_widget_get_visual (widget);
2243   attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK;
2244
2245   attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
2246
2247   window = gdk_window_new (gtk_widget_get_parent_window (widget),
2248                            &attributes, attributes_mask);
2249   gtk_widget_set_window (widget, window);
2250   gtk_widget_register_window (widget, window);
2251
2252   gtk_widget_get_allocation (widget, &allocation);
2253
2254   /* Make the window for the tree */
2255   attributes.x = 0;
2256   attributes.y = gtk_tree_view_get_effective_header_height (tree_view);
2257   attributes.width = MAX (tree_view->priv->width, allocation.width);
2258   attributes.height = allocation.height;
2259   attributes.event_mask = (GDK_EXPOSURE_MASK |
2260                            GDK_SCROLL_MASK |
2261                            GDK_SMOOTH_SCROLL_MASK |
2262                            GDK_POINTER_MOTION_MASK |
2263                            GDK_ENTER_NOTIFY_MASK |
2264                            GDK_LEAVE_NOTIFY_MASK |
2265                            GDK_BUTTON_PRESS_MASK |
2266                            GDK_BUTTON_RELEASE_MASK |
2267                            gtk_widget_get_events (widget));
2268
2269   tree_view->priv->bin_window = gdk_window_new (window,
2270                                                 &attributes, attributes_mask);
2271   gtk_widget_register_window (widget, tree_view->priv->bin_window);
2272
2273   gtk_widget_get_allocation (widget, &allocation);
2274
2275   /* Make the column header window */
2276   attributes.x = 0;
2277   attributes.y = 0;
2278   attributes.width = MAX (tree_view->priv->width, allocation.width);
2279   attributes.height = tree_view->priv->header_height;
2280   attributes.event_mask = (GDK_EXPOSURE_MASK |
2281                            GDK_SCROLL_MASK |
2282                            GDK_ENTER_NOTIFY_MASK |
2283                            GDK_LEAVE_NOTIFY_MASK |
2284                            GDK_BUTTON_PRESS_MASK |
2285                            GDK_BUTTON_RELEASE_MASK |
2286                            GDK_KEY_PRESS_MASK |
2287                            GDK_KEY_RELEASE_MASK |
2288                            gtk_widget_get_events (widget));
2289
2290   tree_view->priv->header_window = gdk_window_new (window,
2291                                                    &attributes, attributes_mask);
2292   gtk_widget_register_window (widget, tree_view->priv->header_window);
2293
2294   gtk_tree_view_ensure_background (tree_view);
2295
2296   tmp_list = tree_view->priv->children;
2297   while (tmp_list)
2298     {
2299       GtkTreeViewChild *child = tmp_list->data;
2300       tmp_list = tmp_list->next;
2301
2302       gtk_widget_set_parent_window (child->widget, tree_view->priv->bin_window);
2303     }
2304
2305   for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list = tmp_list->next)
2306     _gtk_tree_view_column_realize_button (GTK_TREE_VIEW_COLUMN (tmp_list->data));
2307
2308   /* Need to call those here, since they create GCs */
2309   gtk_tree_view_set_grid_lines (tree_view, tree_view->priv->grid_lines);
2310   gtk_tree_view_set_enable_tree_lines (tree_view, tree_view->priv->tree_lines_enabled);
2311
2312   install_presize_handler (tree_view);
2313 }
2314
2315 static void
2316 gtk_tree_view_unrealize (GtkWidget *widget)
2317 {
2318   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
2319   GtkTreeViewPrivate *priv = tree_view->priv;
2320   GList *list;
2321
2322   if (priv->scroll_timeout != 0)
2323     {
2324       g_source_remove (priv->scroll_timeout);
2325       priv->scroll_timeout = 0;
2326     }
2327
2328   if (priv->auto_expand_timeout != 0)
2329     {
2330       g_source_remove (priv->auto_expand_timeout);
2331       priv->auto_expand_timeout = 0;
2332     }
2333
2334   if (priv->open_dest_timeout != 0)
2335     {
2336       g_source_remove (priv->open_dest_timeout);
2337       priv->open_dest_timeout = 0;
2338     }
2339
2340   if (priv->presize_handler_timer != 0)
2341     {
2342       g_source_remove (priv->presize_handler_timer);
2343       priv->presize_handler_timer = 0;
2344     }
2345
2346   if (priv->validate_rows_timer != 0)
2347     {
2348       g_source_remove (priv->validate_rows_timer);
2349       priv->validate_rows_timer = 0;
2350     }
2351
2352   if (priv->scroll_sync_timer != 0)
2353     {
2354       g_source_remove (priv->scroll_sync_timer);
2355       priv->scroll_sync_timer = 0;
2356     }
2357
2358   if (priv->typeselect_flush_timeout)
2359     {
2360       g_source_remove (priv->typeselect_flush_timeout);
2361       priv->typeselect_flush_timeout = 0;
2362     }
2363
2364   for (list = priv->columns; list; list = list->next)
2365     _gtk_tree_view_column_unrealize_button (GTK_TREE_VIEW_COLUMN (list->data));
2366
2367   gtk_widget_unregister_window (widget, priv->bin_window);
2368   gdk_window_destroy (priv->bin_window);
2369   priv->bin_window = NULL;
2370
2371   gtk_widget_unregister_window (widget, priv->header_window);
2372   gdk_window_destroy (priv->header_window);
2373   priv->header_window = NULL;
2374
2375   if (priv->drag_window)
2376     {
2377       gtk_widget_unregister_window (widget, priv->drag_window);
2378       gdk_window_destroy (priv->drag_window);
2379       priv->drag_window = NULL;
2380     }
2381
2382   if (priv->drag_highlight_window)
2383     {
2384       gtk_widget_unregister_window (widget, priv->drag_highlight_window);
2385       gdk_window_destroy (priv->drag_highlight_window);
2386       priv->drag_highlight_window = NULL;
2387     }
2388
2389   GTK_WIDGET_CLASS (gtk_tree_view_parent_class)->unrealize (widget);
2390 }
2391
2392 /* GtkWidget::get_preferred_height helper */
2393 static void
2394 gtk_tree_view_update_height (GtkTreeView *tree_view)
2395 {
2396   GList *list;
2397
2398   tree_view->priv->header_height = 0;
2399
2400   for (list = tree_view->priv->columns; list; list = list->next)
2401     {
2402       GtkRequisition     requisition;
2403       GtkTreeViewColumn *column = list->data;
2404       GtkWidget         *button = gtk_tree_view_column_get_button (column);
2405
2406       if (button == NULL)
2407         continue;
2408
2409       gtk_widget_get_preferred_size (button, &requisition, NULL);
2410       tree_view->priv->header_height = MAX (tree_view->priv->header_height, requisition.height);
2411     }
2412
2413   if (tree_view->priv->tree == NULL)
2414     tree_view->priv->height = 0;
2415   else
2416     tree_view->priv->height = tree_view->priv->tree->root->offset;
2417 }
2418
2419 static void
2420 gtk_tree_view_get_preferred_width (GtkWidget *widget,
2421                                    gint      *minimum,
2422                                    gint      *natural)
2423 {
2424   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
2425   GList *list;
2426   GtkTreeViewColumn *column;
2427   gint column_minimum, column_natural;
2428
2429   /* we validate some rows initially just to make sure we have some size.
2430    * In practice, with a lot of static lists, this should get a good width.
2431    */
2432   do_validate_rows (tree_view, FALSE);
2433
2434   tree_view->priv->minimum_width = 0;
2435   tree_view->priv->natural_width = 0;
2436   tree_view->priv->n_expand_columns = 0;
2437
2438   /* keep this in sync with size_allocate below */
2439   for (list = tree_view->priv->columns; list; list = list->next)
2440     {
2441       column = list->data;
2442       if (!gtk_tree_view_column_get_visible (column) || column == tree_view->priv->drag_column)
2443         continue;
2444
2445       _gtk_tree_view_column_request_width (column, &column_minimum, &column_natural);
2446       tree_view->priv->minimum_width += column_minimum;
2447       tree_view->priv->natural_width += column_natural;
2448
2449       if (gtk_tree_view_column_get_expand (column))
2450         tree_view->priv->n_expand_columns++;
2451     }
2452
2453   if (minimum != NULL)
2454     *minimum = tree_view->priv->minimum_width;
2455   if (natural != NULL)
2456     *natural = tree_view->priv->natural_width;
2457 }
2458
2459 static void
2460 gtk_tree_view_get_preferred_height (GtkWidget *widget,
2461                                     gint      *minimum,
2462                                     gint      *natural)
2463 {
2464   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
2465   gint height;
2466
2467   gtk_tree_view_update_height (tree_view);
2468
2469   height = tree_view->priv->height + gtk_tree_view_get_effective_header_height (tree_view);
2470
2471   if (minimum != NULL)
2472     *minimum = height;
2473   if (natural != NULL)
2474     *natural = height;
2475 }
2476
2477 static void
2478 gtk_tree_view_modify_column_width (GtkTreeView       *tree_view,
2479                                    GtkTreeViewColumn *column,
2480                                    gint               width)
2481 {
2482   gboolean is_expand;
2483   gint n_expand_others;
2484   gint minimum, natural, natural_others;
2485   gint expand;
2486
2487   is_expand = gtk_tree_view_column_get_expand (column);
2488   n_expand_others = tree_view->priv->n_expand_columns - (is_expand ? 1 : 0);
2489
2490   _gtk_tree_view_column_request_width (column, &minimum, &natural);
2491   natural_others = tree_view->priv->natural_width - natural;
2492
2493   if (natural_others + width < tree_view->priv->width)
2494     {
2495       /* There is extra space that needs to be taken up by letting some other
2496        * column(s) expand: by default, the last column. */
2497       if (!n_expand_others)
2498         {
2499           GList *last = g_list_last (tree_view->priv->columns);
2500           while (!gtk_tree_view_column_get_visible (last->data))
2501             last = last->prev;
2502
2503           if (column == last->data)
2504             return;
2505
2506           gtk_tree_view_column_set_expand (last->data, TRUE);
2507           n_expand_others++;
2508         }
2509
2510       /* Now try to make this column expandable also.  Solving the following
2511        * equations reveals what the natural width should be to achieve the
2512        * desired width after expanding:
2513        *
2514        *   1. natural + expand = desired_width
2515        *   2. natural + natural_others + expand * (n_expand_others + 1) = total_width
2516        *
2517        * Solution:
2518        *   expand = (total_width - natural_others - desired_width) / n_expand_others
2519        *
2520        * It is possible for the solved natural width to be less than the
2521        * minimum; in that case, we cannot let the column expand.
2522        */
2523       expand = (tree_view->priv->width - natural_others - width) / n_expand_others;
2524
2525       if (minimum + expand > width)
2526         {
2527           if (is_expand)
2528             gtk_tree_view_column_set_expand (column, FALSE);
2529         }
2530       else
2531         {
2532           if (!is_expand)
2533             gtk_tree_view_column_set_expand (column, TRUE);
2534
2535           width -= expand;
2536         }
2537     }
2538
2539   gtk_tree_view_column_set_fixed_width (column, width);
2540 }
2541
2542 static int
2543 gtk_tree_view_calculate_width_before_expander (GtkTreeView *tree_view)
2544 {
2545   int width = 0;
2546   GList *list;
2547   gboolean rtl;
2548
2549   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
2550   for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
2551        list->data != tree_view->priv->expander_column;
2552        list = (rtl ? list->prev : list->next))
2553     {
2554       GtkTreeViewColumn *column = list->data;
2555
2556       width += gtk_tree_view_column_get_width (column);
2557     }
2558
2559   return width;
2560 }
2561
2562 /* GtkWidget::size_allocate helper */
2563 static void
2564 gtk_tree_view_size_allocate_columns (GtkWidget *widget,
2565                                      gboolean  *width_changed)
2566 {
2567   GtkTreeView *tree_view;
2568   GList *list, *first_column, *last_column;
2569   GtkTreeViewColumn *column;
2570   GtkAllocation widget_allocation;
2571   gint minimum_width, natural_width, n_expand_columns, width;
2572   gint column_minimum, column_natural, column_width;
2573   gboolean rtl;
2574
2575   tree_view = GTK_TREE_VIEW (widget);
2576
2577   for (last_column = g_list_last (tree_view->priv->columns);
2578        last_column &&
2579        !(gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (last_column->data)));
2580        last_column = last_column->prev)
2581     ;
2582   if (last_column == NULL)
2583     return;
2584
2585   for (first_column = g_list_first (tree_view->priv->columns);
2586        first_column &&
2587        !(gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (first_column->data)));
2588        first_column = first_column->next)
2589     ;
2590
2591   rtl = (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL);
2592
2593   gtk_widget_get_allocation (widget, &widget_allocation);
2594
2595   minimum_width = tree_view->priv->minimum_width;
2596   natural_width = tree_view->priv->natural_width;
2597   n_expand_columns = tree_view->priv->n_expand_columns;
2598
2599   width = MAX (widget_allocation.width, minimum_width);
2600
2601   /* We change the width here.  The user might have been resizing columns,
2602    * which changes the total width of the tree view.  This is of
2603    * importance for getting the horizontal scroll bar right.
2604    */
2605   if (tree_view->priv->width != width)
2606     {
2607       tree_view->priv->width = width;
2608       if (width_changed)
2609         *width_changed = TRUE;
2610     }
2611
2612   /* iterate through columns in reverse order */
2613   for (list = (rtl ? first_column : last_column);
2614        list != (rtl ? last_column->next : first_column->prev);
2615        list = (rtl ? list->next : list->prev))
2616     {
2617       column = list->data;
2618
2619       if (!gtk_tree_view_column_get_visible (column) || column == tree_view->priv->drag_column)
2620         continue;
2621
2622       _gtk_tree_view_column_request_width (column, &column_minimum, &column_natural);
2623
2624       column_width = column_natural;
2625
2626       if (width > natural_width)
2627         {
2628           /* We need to expand some columns.  If there are none marked to
2629            * expand, give all the extra space to the last column. */
2630           if (n_expand_columns == 0)
2631             {
2632               column_width = column_natural + (width - natural_width);
2633             }
2634           else if (gtk_tree_view_column_get_expand (column))
2635             {
2636               column_width = column_natural + (width - natural_width) / n_expand_columns;
2637               n_expand_columns--;
2638             }
2639         }
2640       else if (width < natural_width)
2641         {
2642           /* We need to shrink some columns.  Starting with later columns,
2643            * shrink each one down to its minimum width as necessary. */
2644           column_width = MAX (column_natural + (width - natural_width), column_minimum);
2645         }
2646
2647       _gtk_tree_view_column_allocate (column, width - column_width, column_width);
2648
2649       minimum_width -= column_minimum;
2650       natural_width -= column_natural;
2651       width -= column_width;
2652     }
2653 }
2654
2655 /* GtkWidget::size_allocate helper */
2656 static void
2657 gtk_tree_view_size_allocate_drag_column (GtkWidget *widget)
2658 {
2659   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
2660   GtkAllocation drag_allocation;
2661   GtkWidget *button;
2662
2663   if (tree_view->priv->drag_column == NULL)
2664     return;
2665
2666   button = gtk_tree_view_column_get_button (tree_view->priv->drag_column);
2667
2668   drag_allocation.x = 0;
2669   drag_allocation.y = 0;
2670   drag_allocation.width = gdk_window_get_width (tree_view->priv->drag_window);
2671   drag_allocation.height = gdk_window_get_height (tree_view->priv->drag_window);
2672   gtk_widget_size_allocate (button, &drag_allocation);
2673 }
2674
2675 static void
2676 gtk_tree_view_size_allocate (GtkWidget     *widget,
2677                              GtkAllocation *allocation)
2678 {
2679   GtkAllocation widget_allocation;
2680   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
2681   GList *tmp_list;
2682   gboolean width_changed = FALSE;
2683   gint old_width;
2684
2685   gtk_widget_get_allocation (widget, &widget_allocation);
2686   old_width = widget_allocation.width;
2687   if (allocation->width != widget_allocation.width)
2688     width_changed = TRUE;
2689
2690   gtk_widget_set_allocation (widget, allocation);
2691
2692   tmp_list = tree_view->priv->children;
2693
2694   while (tmp_list)
2695     {
2696       GtkAllocation allocation;
2697
2698       GtkTreeViewChild *child = tmp_list->data;
2699       tmp_list = tmp_list->next;
2700
2701       /* totally ignore our child's requisition */
2702       allocation.x = child->x;
2703       allocation.y = child->y;
2704       allocation.width = child->width;
2705       allocation.height = child->height;
2706       gtk_widget_size_allocate (child->widget, &allocation);
2707     }
2708
2709   /* We size-allocate the columns first because the width of the
2710    * tree view (used in updating the adjustments below) might change.
2711    */
2712   gtk_tree_view_size_allocate_columns (widget, &width_changed);
2713   gtk_tree_view_size_allocate_drag_column (widget);
2714
2715   g_object_freeze_notify (G_OBJECT (tree_view->priv->hadjustment));
2716   gtk_adjustment_set_page_size (tree_view->priv->hadjustment,
2717                                 allocation->width);
2718   gtk_adjustment_set_page_increment (tree_view->priv->hadjustment,
2719                                      allocation->width * 0.9);
2720   gtk_adjustment_set_step_increment (tree_view->priv->hadjustment,
2721                                      allocation->width * 0.1);
2722   gtk_adjustment_set_lower (tree_view->priv->hadjustment, 0);
2723   gtk_adjustment_set_upper (tree_view->priv->hadjustment,
2724                             MAX (gtk_adjustment_get_page_size (tree_view->priv->hadjustment),
2725                                  tree_view->priv->width));
2726   g_object_thaw_notify (G_OBJECT (tree_view->priv->hadjustment));
2727
2728   if (gtk_widget_get_direction(widget) == GTK_TEXT_DIR_RTL)
2729     {
2730       if (allocation->width < tree_view->priv->width)
2731         {
2732           if (tree_view->priv->init_hadjust_value)
2733             {
2734               gtk_adjustment_set_value (tree_view->priv->hadjustment,
2735                                         MAX (tree_view->priv->width -
2736                                              allocation->width, 0));
2737               tree_view->priv->init_hadjust_value = FALSE;
2738             }
2739           else if (allocation->width != old_width)
2740             {
2741               gtk_adjustment_set_value (tree_view->priv->hadjustment,
2742                                         CLAMP (gtk_adjustment_get_value (tree_view->priv->hadjustment) - allocation->width + old_width,
2743                                                0,
2744                                                tree_view->priv->width - allocation->width));
2745             }
2746         }
2747       else
2748         {
2749           gtk_adjustment_set_value (tree_view->priv->hadjustment, 0);
2750           tree_view->priv->init_hadjust_value = TRUE;
2751         }
2752     }
2753   else
2754     if (gtk_adjustment_get_value (tree_view->priv->hadjustment) + allocation->width > tree_view->priv->width)
2755       gtk_adjustment_set_value (tree_view->priv->hadjustment,
2756                                 MAX (tree_view->priv->width -
2757                                      allocation->width, 0));
2758
2759   g_object_freeze_notify (G_OBJECT (tree_view->priv->vadjustment));
2760   gtk_adjustment_set_page_size (tree_view->priv->vadjustment,
2761                                 allocation->height -
2762                                 gtk_tree_view_get_effective_header_height (tree_view));
2763   gtk_adjustment_set_step_increment (tree_view->priv->vadjustment,
2764                                      gtk_adjustment_get_page_size (tree_view->priv->vadjustment) * 0.1);
2765   gtk_adjustment_set_page_increment (tree_view->priv->vadjustment,
2766                                      gtk_adjustment_get_page_size (tree_view->priv->vadjustment) * 0.9);
2767   gtk_adjustment_set_lower (tree_view->priv->vadjustment, 0);
2768   gtk_adjustment_set_upper (tree_view->priv->vadjustment,
2769                             MAX (gtk_adjustment_get_page_size (tree_view->priv->vadjustment),
2770                                  tree_view->priv->height));
2771   g_object_thaw_notify (G_OBJECT (tree_view->priv->vadjustment));
2772
2773   /* now the adjustments and window sizes are in sync, we can sync toprow/dy again */
2774   if (tree_view->priv->height <= gtk_adjustment_get_page_size (tree_view->priv->vadjustment))
2775     gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment), 0);
2776   else if (gtk_adjustment_get_value (tree_view->priv->vadjustment) + gtk_adjustment_get_page_size (tree_view->priv->vadjustment) > tree_view->priv->height)
2777     gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment),
2778                               tree_view->priv->height - gtk_adjustment_get_page_size (tree_view->priv->vadjustment));
2779   else if (gtk_tree_row_reference_valid (tree_view->priv->top_row))
2780     gtk_tree_view_top_row_to_dy (tree_view);
2781   else
2782     gtk_tree_view_dy_to_top_row (tree_view);
2783
2784   if (gtk_widget_get_realized (widget))
2785     {
2786       gdk_window_move_resize (gtk_widget_get_window (widget),
2787                               allocation->x, allocation->y,
2788                               allocation->width, allocation->height);
2789       gdk_window_move_resize (tree_view->priv->header_window,
2790                               - (gint) gtk_adjustment_get_value (tree_view->priv->hadjustment),
2791                               0,
2792                               MAX (tree_view->priv->width, allocation->width),
2793                               tree_view->priv->header_height);
2794       gdk_window_move_resize (tree_view->priv->bin_window,
2795                               - (gint) gtk_adjustment_get_value (tree_view->priv->hadjustment),
2796                               gtk_tree_view_get_effective_header_height (tree_view),
2797                               MAX (tree_view->priv->width, allocation->width),
2798                               allocation->height - gtk_tree_view_get_effective_header_height (tree_view));
2799
2800       if (tree_view->priv->tree == NULL)
2801         invalidate_empty_focus (tree_view);
2802
2803       if (width_changed && tree_view->priv->expander_column)
2804         {
2805           /* Might seem awkward, but is the best heuristic I could come up
2806            * with.  Only if the width of the columns before the expander
2807            * changes, we will update the prelight status.  It is this
2808            * width that makes the expander move vertically.  Always updating
2809            * prelight status causes trouble with hover selections.
2810            */
2811           gint width_before_expander;
2812
2813           width_before_expander = gtk_tree_view_calculate_width_before_expander (tree_view);
2814
2815           if (tree_view->priv->prev_width_before_expander
2816               != width_before_expander)
2817               update_prelight (tree_view,
2818                                tree_view->priv->event_last_x,
2819                                tree_view->priv->event_last_y);
2820
2821           tree_view->priv->prev_width_before_expander = width_before_expander;
2822         }
2823     }
2824 }
2825
2826 /* Grabs the focus and unsets the GTK_TREE_VIEW_DRAW_KEYFOCUS flag */
2827 static void
2828 grab_focus_and_unset_draw_keyfocus (GtkTreeView *tree_view)
2829 {
2830   GtkWidget *widget = GTK_WIDGET (tree_view);
2831
2832   if (gtk_widget_get_can_focus (widget) && !gtk_widget_has_focus (widget))
2833     gtk_widget_grab_focus (widget);
2834   tree_view->priv->draw_keyfocus = 0;
2835 }
2836
2837 static inline gboolean
2838 row_is_separator (GtkTreeView *tree_view,
2839                   GtkTreeIter *iter,
2840                   GtkTreePath *path)
2841 {
2842   gboolean is_separator = FALSE;
2843
2844   if (tree_view->priv->row_separator_func)
2845     {
2846       GtkTreeIter tmpiter;
2847
2848       if (iter)
2849         tmpiter = *iter;
2850       else
2851         {
2852           if (!gtk_tree_model_get_iter (tree_view->priv->model, &tmpiter, path))
2853             return FALSE;
2854         }
2855
2856       is_separator = tree_view->priv->row_separator_func (tree_view->priv->model,
2857                                                           &tmpiter,
2858                                                           tree_view->priv->row_separator_data);
2859     }
2860
2861   return is_separator;
2862 }
2863
2864 static int
2865 gtk_tree_view_get_expander_size (GtkTreeView *tree_view)
2866 {
2867   gint expander_size;
2868
2869   gtk_widget_style_get (GTK_WIDGET (tree_view),
2870                         "expander-size", &expander_size,
2871                         NULL);
2872   expander_size += EXPANDER_EXTRA_PADDING;
2873
2874   return expander_size;
2875 }
2876
2877 static gboolean
2878 gtk_tree_view_button_press (GtkWidget      *widget,
2879                             GdkEventButton *event)
2880 {
2881   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
2882   GList *list;
2883   GtkTreeViewColumn *column = NULL;
2884   gint i;
2885   GdkRectangle background_area;
2886   GdkRectangle cell_area;
2887   gint vertical_separator;
2888   gint horizontal_separator;
2889   gboolean path_is_selectable;
2890   gboolean rtl;
2891
2892   rtl = (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL);
2893   gtk_tree_view_stop_editing (tree_view, FALSE);
2894   gtk_widget_style_get (widget,
2895                         "vertical-separator", &vertical_separator,
2896                         "horizontal-separator", &horizontal_separator,
2897                         NULL);
2898
2899   /* Don't handle extra mouse buttons events, let them bubble up */
2900   if (event->button > 5)
2901     return FALSE;
2902
2903   /* Because grab_focus can cause reentrancy, we delay grab_focus until after
2904    * we're done handling the button press.
2905    */
2906
2907   if (event->window == tree_view->priv->bin_window)
2908     {
2909       GtkRBNode *node;
2910       GtkRBTree *tree;
2911       GtkTreePath *path;
2912       gint depth;
2913       gint new_y;
2914       gint y_offset;
2915       gint dval;
2916       gint pre_val, aft_val;
2917       GtkTreeViewColumn *column = NULL;
2918       gint column_handled_click = FALSE;
2919       gboolean row_double_click = FALSE;
2920       gboolean rtl;
2921       gboolean node_selected;
2922       GdkModifierType extend_mod_mask;
2923       GdkModifierType modify_mod_mask;
2924
2925       /* Empty tree? */
2926       if (tree_view->priv->tree == NULL)
2927         {
2928           grab_focus_and_unset_draw_keyfocus (tree_view);
2929           return TRUE;
2930         }
2931
2932       /* are we in an arrow? */
2933       if (tree_view->priv->prelight_node &&
2934           tree_view->priv->arrow_prelit &&
2935           gtk_tree_view_draw_expanders (tree_view))
2936         {
2937           if (event->button == GDK_BUTTON_PRIMARY)
2938             {
2939               gtk_grab_add (widget);
2940               tree_view->priv->button_pressed_node = tree_view->priv->prelight_node;
2941               tree_view->priv->button_pressed_tree = tree_view->priv->prelight_tree;
2942               gtk_tree_view_queue_draw_arrow (GTK_TREE_VIEW (widget),
2943                                               tree_view->priv->prelight_tree,
2944                                               tree_view->priv->prelight_node);
2945             }
2946
2947           grab_focus_and_unset_draw_keyfocus (tree_view);
2948           return TRUE;
2949         }
2950
2951       /* find the node that was clicked */
2952       new_y = TREE_WINDOW_Y_TO_RBTREE_Y(tree_view, event->y);
2953       if (new_y < 0)
2954         new_y = 0;
2955       y_offset = -_gtk_rbtree_find_offset (tree_view->priv->tree, new_y, &tree, &node);
2956
2957       if (node == NULL)
2958         {
2959           /* We clicked in dead space */
2960           grab_focus_and_unset_draw_keyfocus (tree_view);
2961           return TRUE;
2962         }
2963
2964       /* Get the path and the node */
2965       path = _gtk_tree_path_new_from_rbtree (tree, node);
2966       path_is_selectable = !row_is_separator (tree_view, NULL, path);
2967
2968       if (!path_is_selectable)
2969         {
2970           gtk_tree_path_free (path);
2971           grab_focus_and_unset_draw_keyfocus (tree_view);
2972           return TRUE;
2973         }
2974
2975       depth = gtk_tree_path_get_depth (path);
2976       background_area.y = y_offset + event->y;
2977       background_area.height = gtk_tree_view_get_row_height (tree_view, node);
2978       background_area.x = 0;
2979
2980
2981       /* Let the column have a chance at selecting it. */
2982       rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
2983       for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
2984            list; list = (rtl ? list->prev : list->next))
2985         {
2986           GtkTreeViewColumn *candidate = list->data;
2987
2988           if (!gtk_tree_view_column_get_visible (candidate))
2989             continue;
2990
2991           background_area.width = gtk_tree_view_column_get_width (candidate);
2992           if ((background_area.x > (gint) event->x) ||
2993               (background_area.x + background_area.width <= (gint) event->x))
2994             {
2995               background_area.x += background_area.width;
2996               continue;
2997             }
2998
2999           /* we found the focus column */
3000           column = candidate;
3001           cell_area = background_area;
3002           cell_area.width -= horizontal_separator;
3003           cell_area.height -= vertical_separator;
3004           cell_area.x += horizontal_separator/2;
3005           cell_area.y += vertical_separator/2;
3006           if (gtk_tree_view_is_expander_column (tree_view, column))
3007             {
3008               if (!rtl)
3009                 cell_area.x += (depth - 1) * tree_view->priv->level_indentation;
3010               cell_area.width -= (depth - 1) * tree_view->priv->level_indentation;
3011
3012               if (gtk_tree_view_draw_expanders (tree_view))
3013                 {
3014                   gint expander_size = gtk_tree_view_get_expander_size (tree_view);
3015                   if (!rtl)
3016                     cell_area.x += depth * expander_size;
3017                   cell_area.width -= depth * expander_size;
3018                 }
3019             }
3020           break;
3021         }
3022
3023       if (column == NULL)
3024         {
3025           gtk_tree_path_free (path);
3026           grab_focus_and_unset_draw_keyfocus (tree_view);
3027           return FALSE;
3028         }
3029
3030       _gtk_tree_view_set_focus_column (tree_view, column);
3031
3032       /* decide if we edit */
3033       if (event->type == GDK_BUTTON_PRESS && event->button == GDK_BUTTON_PRIMARY &&
3034           !(event->state & gtk_accelerator_get_default_mod_mask ()))
3035         {
3036           GtkTreePath *anchor;
3037           GtkTreeIter iter;
3038
3039           gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
3040           gtk_tree_view_column_cell_set_cell_data (column,
3041                                                    tree_view->priv->model,
3042                                                    &iter,
3043                                                    GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT),
3044                                                    node->children?TRUE:FALSE);
3045
3046           if (tree_view->priv->anchor)
3047             anchor = gtk_tree_row_reference_get_path (tree_view->priv->anchor);
3048           else
3049             anchor = NULL;
3050
3051           if ((anchor && !gtk_tree_path_compare (anchor, path))
3052               || !_gtk_tree_view_column_has_editable_cell (column))
3053             {
3054               GtkCellEditable *cell_editable = NULL;
3055
3056               /* FIXME: get the right flags */
3057               guint flags = 0;
3058
3059               if (_gtk_tree_view_column_cell_event (column,
3060                                                     (GdkEvent *)event,
3061                                                     &cell_area, flags))
3062                 {
3063                   GtkCellArea *area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (column));
3064                   cell_editable = gtk_cell_area_get_edit_widget (area);
3065
3066                   if (cell_editable != NULL)
3067                     {
3068                       gtk_tree_path_free (path);
3069                       gtk_tree_path_free (anchor);
3070                       return TRUE;
3071                     }
3072                   column_handled_click = TRUE;
3073                 }
3074             }
3075           if (anchor)
3076             gtk_tree_path_free (anchor);
3077         }
3078
3079       extend_mod_mask =
3080         gtk_widget_get_modifier_mask (widget, GDK_MODIFIER_INTENT_EXTEND_SELECTION);
3081
3082       modify_mod_mask =
3083         gtk_widget_get_modifier_mask (widget, GDK_MODIFIER_INTENT_MODIFY_SELECTION);
3084
3085       /* select */
3086       node_selected = GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED);
3087       pre_val = gtk_adjustment_get_value (tree_view->priv->vadjustment);
3088
3089       /* we only handle selection modifications on the first button press
3090        */
3091       if (event->type == GDK_BUTTON_PRESS)
3092         {
3093           GtkCellRenderer *focus_cell;
3094
3095           if ((event->state & modify_mod_mask) == modify_mod_mask)
3096             tree_view->priv->modify_selection_pressed = TRUE;
3097           if ((event->state & extend_mod_mask) == extend_mod_mask)
3098             tree_view->priv->extend_selection_pressed = TRUE;
3099
3100           /* We update the focus cell here, this is also needed if the
3101            * column does not contain an editable cell.  In this case,
3102            * GtkCellArea did not receive the event for processing (and
3103            * could not update the focus cell).
3104            */
3105           focus_cell = _gtk_tree_view_column_get_cell_at_pos (column,
3106                                                               &cell_area,
3107                                                               &background_area,
3108                                                               event->x,
3109                                                               event->y);
3110
3111           if (focus_cell)
3112             gtk_tree_view_column_focus_cell (column, focus_cell);
3113
3114           if (event->state & modify_mod_mask)
3115             {
3116               gtk_tree_view_real_set_cursor (tree_view, path, CLAMP_NODE);
3117               gtk_tree_view_real_toggle_cursor_row (tree_view);
3118             }
3119           else if (event->state & extend_mod_mask)
3120             {
3121               gtk_tree_view_real_set_cursor (tree_view, path, CLAMP_NODE);
3122               gtk_tree_view_real_select_cursor_row (tree_view, FALSE);
3123             }
3124           else
3125             {
3126               gtk_tree_view_real_set_cursor (tree_view, path, CLEAR_AND_SELECT | CLAMP_NODE);
3127             }
3128
3129           tree_view->priv->modify_selection_pressed = FALSE;
3130           tree_view->priv->extend_selection_pressed = FALSE;
3131         }
3132
3133       /* the treeview may have been scrolled because of _set_cursor,
3134        * correct here
3135        */
3136
3137       aft_val = gtk_adjustment_get_value (tree_view->priv->vadjustment);
3138       dval = pre_val - aft_val;
3139
3140       cell_area.y += dval;
3141       background_area.y += dval;
3142
3143       /* Save press to possibly begin a drag
3144        */
3145       if (!column_handled_click &&
3146           !tree_view->priv->in_grab &&
3147           tree_view->priv->pressed_button < 0)
3148         {
3149           tree_view->priv->pressed_button = event->button;
3150           tree_view->priv->press_start_x = event->x;
3151           tree_view->priv->press_start_y = event->y;
3152
3153           if (tree_view->priv->rubber_banding_enable
3154               && !node_selected
3155               && gtk_tree_selection_get_mode (tree_view->priv->selection) == GTK_SELECTION_MULTIPLE)
3156             {
3157               tree_view->priv->press_start_y += tree_view->priv->dy;
3158               tree_view->priv->rubber_band_x = event->x;
3159               tree_view->priv->rubber_band_y = event->y + tree_view->priv->dy;
3160               tree_view->priv->rubber_band_status = RUBBER_BAND_MAYBE_START;
3161
3162               if ((event->state & modify_mod_mask) == modify_mod_mask)
3163                 tree_view->priv->rubber_band_modify = TRUE;
3164               if ((event->state & extend_mod_mask) == extend_mod_mask)
3165                 tree_view->priv->rubber_band_extend = TRUE;
3166             }
3167         }
3168
3169       if (event->button == GDK_BUTTON_PRIMARY && event->type == GDK_BUTTON_PRESS)
3170         {
3171
3172           /* Test if a double click happened on the same row. */
3173           if (!tree_view->priv->activate_on_single_click)
3174             {
3175               int double_click_time, double_click_distance;
3176
3177               g_object_get (gtk_settings_get_default (),
3178                             "gtk-double-click-time", &double_click_time,
3179                             "gtk-double-click-distance", &double_click_distance,
3180                             NULL);
3181
3182               /* Same conditions as _gdk_event_button_generate */
3183               if (tree_view->priv->last_button_x != -1 &&
3184                   (event->time < tree_view->priv->last_button_time + double_click_time) &&
3185                   (ABS (event->x - tree_view->priv->last_button_x) <= double_click_distance) &&
3186                   (ABS (event->y - tree_view->priv->last_button_y) <= double_click_distance))
3187                 {
3188                   /* We do no longer compare paths of this row and the
3189                    * row clicked previously.  We use the double click
3190                    * distance to decide whether this is a valid click,
3191                    * allowing the mouse to slightly move over another row.
3192                    */
3193                   row_double_click = TRUE;
3194
3195                   tree_view->priv->last_button_time = 0;
3196                   tree_view->priv->last_button_x = -1;
3197                   tree_view->priv->last_button_y = -1;
3198                 }
3199               else
3200                 {
3201                   tree_view->priv->last_button_time = event->time;
3202                   tree_view->priv->last_button_x = event->x;
3203                   tree_view->priv->last_button_y = event->y;
3204                 }
3205             }
3206           else
3207             {
3208               tree_view->priv->button_pressed_node = tree_view->priv->prelight_node;
3209               tree_view->priv->button_pressed_tree = tree_view->priv->prelight_tree;
3210             }
3211         }
3212
3213       if (row_double_click)
3214         {
3215           gtk_grab_remove (widget);
3216           gtk_tree_view_row_activated (tree_view, path, column);
3217
3218           if (tree_view->priv->pressed_button == event->button)
3219             tree_view->priv->pressed_button = -1;
3220         }
3221
3222       gtk_tree_path_free (path);
3223
3224       /* If we activated the row through a double click we don't want to grab
3225        * focus back, as moving focus to another widget is pretty common.
3226        */
3227       if (!row_double_click)
3228         grab_focus_and_unset_draw_keyfocus (tree_view);
3229
3230       return TRUE;
3231     }
3232
3233   /* We didn't click in the window.  Let's check to see if we clicked on a column resize window.
3234    */
3235   for (i = 0, list = tree_view->priv->columns; list; list = list->next, i++)
3236     {
3237       column = list->data;
3238       if (event->window == _gtk_tree_view_column_get_window (column) &&
3239           gtk_tree_view_column_get_resizable (column) &&
3240           _gtk_tree_view_column_get_window (column))
3241         {
3242           gpointer drag_data;
3243           gint column_width, x;
3244
3245           if (event->type == GDK_2BUTTON_PRESS &&
3246               gtk_tree_view_column_get_sizing (column) != GTK_TREE_VIEW_COLUMN_AUTOSIZE)
3247             {
3248               gtk_tree_view_column_set_fixed_width (column, -1);
3249               gtk_tree_view_column_set_expand (column, FALSE);
3250               _gtk_tree_view_column_autosize (tree_view, column);
3251               return TRUE;
3252             }
3253
3254           if (gdk_device_grab (gdk_event_get_device ((GdkEvent*)event),
3255                                _gtk_tree_view_column_get_window (column),
3256                                GDK_OWNERSHIP_NONE,
3257                                FALSE,
3258                                GDK_POINTER_MOTION_HINT_MASK
3259                                 | GDK_BUTTON1_MOTION_MASK
3260                                 | GDK_BUTTON_RELEASE_MASK,
3261                                NULL,
3262                                event->time) != GDK_GRAB_SUCCESS)
3263             return FALSE;
3264
3265           gtk_grab_add (widget);
3266           tree_view->priv->in_column_resize = TRUE;
3267
3268           /* block attached dnd signal handler */
3269           drag_data = g_object_get_data (G_OBJECT (widget), "gtk-site-data");
3270           if (drag_data)
3271             g_signal_handlers_block_matched (widget,
3272                                              G_SIGNAL_MATCH_DATA,
3273                                              0, 0, NULL, NULL,
3274                                              drag_data);
3275
3276           column_width = gtk_tree_view_column_get_width (column);
3277           gdk_window_get_device_position (tree_view->priv->bin_window,
3278                                           gdk_event_get_device ((GdkEvent *) event),
3279                                           &x, NULL, NULL);
3280
3281           tree_view->priv->drag_pos = i;
3282           tree_view->priv->x_drag = x + (rtl ? column_width : -column_width);
3283
3284           if (!gtk_widget_has_focus (widget))
3285             gtk_widget_grab_focus (widget);
3286
3287           return TRUE;
3288         }
3289     }
3290   return FALSE;
3291 }
3292
3293 /* GtkWidget::button_release_event helper */
3294 static gboolean
3295 gtk_tree_view_button_release_drag_column (GtkWidget      *widget,
3296                                           GdkEventButton *event)
3297 {
3298   GtkTreeView *tree_view;
3299   GtkWidget *button;
3300   GList *l;
3301   gboolean rtl;
3302   GdkDevice *device, *other;
3303   GtkStyleContext *context;
3304
3305   tree_view = GTK_TREE_VIEW (widget);
3306
3307   rtl = (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL);
3308   device = gdk_event_get_device ((GdkEvent*)event);
3309   other = gdk_device_get_associated_device (device);
3310   gdk_device_ungrab (device, event->time);
3311   gdk_device_ungrab (other, event->time);
3312
3313   /* Move the button back */
3314   button = gtk_tree_view_column_get_button (tree_view->priv->drag_column);
3315
3316   context = gtk_widget_get_style_context (button);
3317   gtk_style_context_remove_class (context, GTK_STYLE_CLASS_DND);
3318
3319   g_object_ref (button);
3320   gtk_container_remove (GTK_CONTAINER (tree_view), button);
3321   gtk_widget_set_parent_window (button, tree_view->priv->header_window);
3322   gtk_widget_set_parent (button, GTK_WIDGET (tree_view));
3323   g_object_unref (button);
3324   gtk_widget_queue_resize (widget);
3325   if (gtk_tree_view_column_get_resizable (tree_view->priv->drag_column))
3326     {
3327       gdk_window_raise (_gtk_tree_view_column_get_window (tree_view->priv->drag_column));
3328       gdk_window_show (_gtk_tree_view_column_get_window (tree_view->priv->drag_column));
3329     }
3330   else
3331     gdk_window_hide (_gtk_tree_view_column_get_window (tree_view->priv->drag_column));
3332
3333   gtk_widget_grab_focus (button);
3334
3335   if (rtl)
3336     {
3337       if (tree_view->priv->cur_reorder &&
3338           tree_view->priv->cur_reorder->right_column != tree_view->priv->drag_column)
3339         gtk_tree_view_move_column_after (tree_view, tree_view->priv->drag_column,
3340                                          tree_view->priv->cur_reorder->right_column);
3341     }
3342   else
3343     {
3344       if (tree_view->priv->cur_reorder &&
3345           tree_view->priv->cur_reorder->left_column != tree_view->priv->drag_column)
3346         gtk_tree_view_move_column_after (tree_view, tree_view->priv->drag_column,
3347                                          tree_view->priv->cur_reorder->left_column);
3348     }
3349   tree_view->priv->drag_column = NULL;
3350   gdk_window_destroy (tree_view->priv->drag_window);
3351   tree_view->priv->drag_window = NULL;
3352
3353   for (l = tree_view->priv->column_drag_info; l != NULL; l = l->next)
3354     g_slice_free (GtkTreeViewColumnReorder, l->data);
3355   g_list_free (tree_view->priv->column_drag_info);
3356   tree_view->priv->column_drag_info = NULL;
3357   tree_view->priv->cur_reorder = NULL;
3358
3359   if (tree_view->priv->drag_highlight_window)
3360     gdk_window_hide (tree_view->priv->drag_highlight_window);
3361
3362   /* Reset our flags */
3363   tree_view->priv->drag_column_window_state = DRAG_COLUMN_WINDOW_STATE_UNSET;
3364   tree_view->priv->in_column_drag = FALSE;
3365
3366   return TRUE;
3367 }
3368
3369 /* GtkWidget::button_release_event helper */
3370 static gboolean
3371 gtk_tree_view_button_release_column_resize (GtkWidget      *widget,
3372                                             GdkEventButton *event)
3373 {
3374   GtkTreeView *tree_view;
3375   gpointer drag_data;
3376
3377   tree_view = GTK_TREE_VIEW (widget);
3378
3379   tree_view->priv->drag_pos = -1;
3380
3381   /* unblock attached dnd signal handler */
3382   drag_data = g_object_get_data (G_OBJECT (widget), "gtk-site-data");
3383   if (drag_data)
3384     g_signal_handlers_unblock_matched (widget,
3385                                        G_SIGNAL_MATCH_DATA,
3386                                        0, 0, NULL, NULL,
3387                                        drag_data);
3388
3389   tree_view->priv->in_column_resize = FALSE;
3390   gtk_grab_remove (widget);
3391   gdk_device_ungrab (gdk_event_get_device ((GdkEvent*)event), event->time);
3392   return TRUE;
3393 }
3394
3395 static gboolean
3396 button_event_modifies_selection (GdkEventButton *event)
3397 {
3398         return (event->state & (GDK_CONTROL_MASK | GDK_SHIFT_MASK)) != 0;
3399 }
3400
3401 static gboolean
3402 gtk_tree_view_button_release (GtkWidget      *widget,
3403                               GdkEventButton *event)
3404 {
3405   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
3406
3407   if (tree_view->priv->in_column_drag)
3408     return gtk_tree_view_button_release_drag_column (widget, event);
3409
3410   if (tree_view->priv->rubber_band_status)
3411     gtk_tree_view_stop_rubber_band (tree_view);
3412
3413   if (tree_view->priv->pressed_button == event->button)
3414     tree_view->priv->pressed_button = -1;
3415
3416   if (tree_view->priv->in_column_resize)
3417     return gtk_tree_view_button_release_column_resize (widget, event);
3418
3419   if (tree_view->priv->button_pressed_node == NULL)
3420     return FALSE;
3421
3422   if (event->button == GDK_BUTTON_PRIMARY
3423       && tree_view->priv->button_pressed_node == tree_view->priv->prelight_node)
3424     {
3425       if (tree_view->priv->arrow_prelit)
3426         {
3427           GtkTreePath *path = NULL;
3428
3429           path = _gtk_tree_path_new_from_rbtree (tree_view->priv->button_pressed_tree,
3430                                                  tree_view->priv->button_pressed_node);
3431           /* Actually activate the node */
3432           if (tree_view->priv->button_pressed_node->children == NULL)
3433             gtk_tree_view_real_expand_row (tree_view, path,
3434                                            tree_view->priv->button_pressed_tree,
3435                                            tree_view->priv->button_pressed_node,
3436                                            FALSE, TRUE);
3437           else
3438             gtk_tree_view_real_collapse_row (GTK_TREE_VIEW (widget), path,
3439                                              tree_view->priv->button_pressed_tree,
3440                                              tree_view->priv->button_pressed_node, TRUE);
3441           gtk_tree_path_free (path);
3442         }
3443       else if (tree_view->priv->activate_on_single_click
3444                && !button_event_modifies_selection (event))
3445         {
3446           GtkTreePath *path = NULL;
3447
3448           path = _gtk_tree_path_new_from_rbtree (tree_view->priv->button_pressed_tree,
3449                                                  tree_view->priv->button_pressed_node);
3450           gtk_tree_view_row_activated (tree_view, path, tree_view->priv->focus_column);
3451           gtk_tree_path_free (path);
3452         }
3453
3454       gtk_grab_remove (widget);
3455       tree_view->priv->button_pressed_tree = NULL;
3456       tree_view->priv->button_pressed_node = NULL;
3457     }
3458
3459   return TRUE;
3460 }
3461
3462 static gboolean
3463 gtk_tree_view_grab_broken (GtkWidget          *widget,
3464                            GdkEventGrabBroken *event)
3465 {
3466   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
3467
3468   if (tree_view->priv->in_column_drag)
3469     gtk_tree_view_button_release_drag_column (widget, (GdkEventButton *)event);
3470
3471   if (tree_view->priv->in_column_resize)
3472     gtk_tree_view_button_release_column_resize (widget, (GdkEventButton *)event);
3473
3474   return TRUE;
3475 }
3476
3477 #if 0
3478 static gboolean
3479 gtk_tree_view_configure (GtkWidget *widget,
3480                          GdkEventConfigure *event)
3481 {
3482   GtkTreeView *tree_view;
3483
3484   tree_view = GTK_TREE_VIEW (widget);
3485   tree_view->priv->search_position_func (tree_view, tree_view->priv->search_window);
3486
3487   return FALSE;
3488 }
3489 #endif
3490
3491 /* GtkWidget::motion_event function set.
3492  */
3493
3494 static gboolean
3495 coords_are_over_arrow (GtkTreeView *tree_view,
3496                        GtkRBTree   *tree,
3497                        GtkRBNode   *node,
3498                        /* these are in bin window coords */
3499                        gint         x,
3500                        gint         y)
3501 {
3502   GdkRectangle arrow;
3503   gint x2;
3504
3505   if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
3506     return FALSE;
3507
3508   if ((node->flags & GTK_RBNODE_IS_PARENT) == 0)
3509     return FALSE;
3510
3511   arrow.y = gtk_tree_view_get_row_y_offset (tree_view, tree, node);
3512   arrow.height = gtk_tree_view_get_row_height (tree_view, node);
3513
3514   gtk_tree_view_get_arrow_xrange (tree_view, tree, &arrow.x, &x2);
3515
3516   arrow.width = x2 - arrow.x;
3517
3518   return (x >= arrow.x &&
3519           x < (arrow.x + arrow.width) &&
3520           y >= arrow.y &&
3521           y < (arrow.y + arrow.height));
3522 }
3523
3524 static gboolean
3525 auto_expand_timeout (gpointer data)
3526 {
3527   GtkTreeView *tree_view = GTK_TREE_VIEW (data);
3528   GtkTreePath *path;
3529
3530   if (tree_view->priv->prelight_node)
3531     {
3532       path = _gtk_tree_path_new_from_rbtree (tree_view->priv->prelight_tree,
3533                                              tree_view->priv->prelight_node);
3534
3535       if (tree_view->priv->prelight_node->children)
3536         gtk_tree_view_collapse_row (tree_view, path);
3537       else
3538         gtk_tree_view_expand_row (tree_view, path, FALSE);
3539
3540       gtk_tree_path_free (path);
3541     }
3542
3543   tree_view->priv->auto_expand_timeout = 0;
3544
3545   return FALSE;
3546 }
3547
3548 static void
3549 remove_auto_expand_timeout (GtkTreeView *tree_view)
3550 {
3551   if (tree_view->priv->auto_expand_timeout != 0)
3552     {
3553       g_source_remove (tree_view->priv->auto_expand_timeout);
3554       tree_view->priv->auto_expand_timeout = 0;
3555     }
3556 }
3557
3558 static void
3559 do_prelight (GtkTreeView *tree_view,
3560              GtkRBTree   *tree,
3561              GtkRBNode   *node,
3562              /* these are in bin_window coords */
3563              gint         x,
3564              gint         y)
3565 {
3566   if (tree_view->priv->prelight_tree == tree &&
3567       tree_view->priv->prelight_node == node)
3568     {
3569       /*  We are still on the same node,
3570           but we might need to take care of the arrow  */
3571
3572       if (tree && node && gtk_tree_view_draw_expanders (tree_view))
3573         {
3574           gboolean over_arrow;
3575
3576           over_arrow = coords_are_over_arrow (tree_view, tree, node, x, y);
3577
3578           if (over_arrow != tree_view->priv->arrow_prelit)
3579             {
3580               if (over_arrow)
3581                 tree_view->priv->arrow_prelit = TRUE;
3582               else
3583                 tree_view->priv->arrow_prelit = FALSE;
3584
3585               gtk_tree_view_queue_draw_arrow (tree_view, tree, node);
3586             }
3587         }
3588
3589       return;
3590     }
3591
3592   if (tree_view->priv->prelight_tree && tree_view->priv->prelight_node)
3593     {
3594       /*  Unprelight the old node and arrow  */
3595
3596       GTK_RBNODE_UNSET_FLAG (tree_view->priv->prelight_node,
3597                              GTK_RBNODE_IS_PRELIT);
3598
3599       if (tree_view->priv->arrow_prelit
3600           && gtk_tree_view_draw_expanders (tree_view))
3601         {
3602           tree_view->priv->arrow_prelit = FALSE;
3603
3604           gtk_tree_view_queue_draw_arrow (tree_view,
3605                                           tree_view->priv->prelight_tree,
3606                                           tree_view->priv->prelight_node);
3607         }
3608
3609       _gtk_tree_view_queue_draw_node (tree_view,
3610                                       tree_view->priv->prelight_tree,
3611                                       tree_view->priv->prelight_node,
3612                                       NULL);
3613     }
3614
3615
3616   if (tree_view->priv->hover_expand)
3617     remove_auto_expand_timeout (tree_view);
3618
3619   /*  Set the new prelight values  */
3620   tree_view->priv->prelight_node = node;
3621   tree_view->priv->prelight_tree = tree;
3622
3623   if (!node || !tree)
3624     return;
3625
3626   /*  Prelight the new node and arrow  */
3627
3628   if (gtk_tree_view_draw_expanders (tree_view)
3629       && coords_are_over_arrow (tree_view, tree, node, x, y))
3630     {
3631       tree_view->priv->arrow_prelit = TRUE;
3632
3633       gtk_tree_view_queue_draw_arrow (tree_view, tree, node);
3634     }
3635
3636   GTK_RBNODE_SET_FLAG (node, GTK_RBNODE_IS_PRELIT);
3637
3638   _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
3639
3640   if (tree_view->priv->hover_expand)
3641     {
3642       tree_view->priv->auto_expand_timeout =
3643         gdk_threads_add_timeout (AUTO_EXPAND_TIMEOUT, auto_expand_timeout, tree_view);
3644     }
3645 }
3646
3647 static void
3648 prelight_or_select (GtkTreeView *tree_view,
3649                     GtkRBTree   *tree,
3650                     GtkRBNode   *node,
3651                     /* these are in bin_window coords */
3652                     gint         x,
3653                     gint         y)
3654 {
3655   GtkSelectionMode mode = gtk_tree_selection_get_mode (tree_view->priv->selection);
3656
3657   if (tree_view->priv->hover_selection &&
3658       (mode == GTK_SELECTION_SINGLE || mode == GTK_SELECTION_BROWSE) &&
3659       !(tree_view->priv->edited_column &&
3660         gtk_cell_area_get_edit_widget
3661         (gtk_cell_layout_get_area (GTK_CELL_LAYOUT (tree_view->priv->edited_column)))))
3662     {
3663       if (node)
3664         {
3665           if (!GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
3666             {
3667               GtkTreePath *path;
3668
3669               path = _gtk_tree_path_new_from_rbtree (tree, node);
3670               gtk_tree_selection_select_path (tree_view->priv->selection, path);
3671               if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
3672                 {
3673                   tree_view->priv->draw_keyfocus = FALSE;
3674                   gtk_tree_view_real_set_cursor (tree_view, path, 0);
3675                 }
3676               gtk_tree_path_free (path);
3677             }
3678         }
3679
3680       else if (mode == GTK_SELECTION_SINGLE)
3681         gtk_tree_selection_unselect_all (tree_view->priv->selection);
3682     }
3683
3684     do_prelight (tree_view, tree, node, x, y);
3685 }
3686
3687 static void
3688 ensure_unprelighted (GtkTreeView *tree_view)
3689 {
3690   do_prelight (tree_view,
3691                NULL, NULL,
3692                -1000, -1000); /* coords not possibly over an arrow */
3693
3694   g_assert (tree_view->priv->prelight_node == NULL);
3695 }
3696
3697 static void
3698 update_prelight (GtkTreeView *tree_view,
3699                  gint         x,
3700                  gint         y)
3701 {
3702   int new_y;
3703   GtkRBTree *tree;
3704   GtkRBNode *node;
3705
3706   if (tree_view->priv->tree == NULL)
3707     return;
3708
3709   if (x == -10000)
3710     {
3711       ensure_unprelighted (tree_view);
3712       return;
3713     }
3714
3715   new_y = TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, y);
3716   if (new_y < 0)
3717     new_y = 0;
3718
3719   _gtk_rbtree_find_offset (tree_view->priv->tree,
3720                            new_y, &tree, &node);
3721
3722   if (node)
3723     prelight_or_select (tree_view, tree, node, x, y);
3724 }
3725
3726
3727
3728
3729 /* Our motion arrow is either a box (in the case of the original spot)
3730  * or an arrow.  It is expander_size wide.
3731  */
3732 /*
3733  * 11111111111111
3734  * 01111111111110
3735  * 00111111111100
3736  * 00011111111000
3737  * 00001111110000
3738  * 00000111100000
3739  * 00000111100000
3740  * 00000111100000
3741  * ~ ~ ~ ~ ~ ~ ~
3742  * 00000111100000
3743  * 00000111100000
3744  * 00000111100000
3745  * 00001111110000
3746  * 00011111111000
3747  * 00111111111100
3748  * 01111111111110
3749  * 11111111111111
3750  */
3751
3752 static void
3753 gtk_tree_view_motion_draw_column_motion_arrow (GtkTreeView *tree_view)
3754 {
3755   GtkTreeViewColumnReorder *reorder = tree_view->priv->cur_reorder;
3756   GtkWidget *widget = GTK_WIDGET (tree_view);
3757   cairo_surface_t *mask_image;
3758   cairo_region_t *mask_region;
3759   gint x;
3760   gint y;
3761   gint width;
3762   gint height;
3763   gint arrow_type = DRAG_COLUMN_WINDOW_STATE_UNSET;
3764   GdkWindowAttr attributes;
3765   guint attributes_mask;
3766   cairo_t *cr;
3767
3768   if (!reorder ||
3769       reorder->left_column == tree_view->priv->drag_column ||
3770       reorder->right_column == tree_view->priv->drag_column)
3771     arrow_type = DRAG_COLUMN_WINDOW_STATE_ORIGINAL;
3772   else if (reorder->left_column || reorder->right_column)
3773     {
3774       GtkAllocation left_allocation, right_allocation;
3775       GdkRectangle visible_rect;
3776       GtkWidget *button;
3777
3778       gtk_tree_view_get_visible_rect (tree_view, &visible_rect);
3779       if (reorder->left_column)
3780         {
3781           button = gtk_tree_view_column_get_button (reorder->left_column);
3782           gtk_widget_get_allocation (button, &left_allocation);
3783           x = left_allocation.x + left_allocation.width;
3784         }
3785       else
3786         {
3787           button = gtk_tree_view_column_get_button (reorder->right_column);
3788           gtk_widget_get_allocation (button, &right_allocation);
3789           x = right_allocation.x;
3790         }
3791
3792       if (x < visible_rect.x)
3793         arrow_type = DRAG_COLUMN_WINDOW_STATE_ARROW_LEFT;
3794       else if (x > visible_rect.x + visible_rect.width)
3795         arrow_type = DRAG_COLUMN_WINDOW_STATE_ARROW_RIGHT;
3796       else
3797         arrow_type = DRAG_COLUMN_WINDOW_STATE_ARROW;
3798     }
3799
3800   /* We want to draw the rectangle over the initial location. */
3801   if (arrow_type == DRAG_COLUMN_WINDOW_STATE_ORIGINAL)
3802     {
3803       if (tree_view->priv->drag_column_window_state != DRAG_COLUMN_WINDOW_STATE_ORIGINAL)
3804         {
3805           GtkAllocation drag_allocation;
3806           GtkWidget    *button;
3807
3808           if (tree_view->priv->drag_highlight_window)
3809             {
3810               gtk_widget_unregister_window (GTK_WIDGET (tree_view), tree_view->priv->drag_highlight_window);
3811               gdk_window_destroy (tree_view->priv->drag_highlight_window);
3812             }
3813
3814           button = gtk_tree_view_column_get_button (tree_view->priv->drag_column);
3815           attributes.window_type = GDK_WINDOW_CHILD;
3816           attributes.wclass = GDK_INPUT_OUTPUT;
3817           attributes.x = tree_view->priv->drag_column_x;
3818           attributes.y = 0;
3819           gtk_widget_get_allocation (button, &drag_allocation);
3820           width = attributes.width = drag_allocation.width;
3821           height = attributes.height = drag_allocation.height;
3822           attributes.visual = gtk_widget_get_visual (GTK_WIDGET (tree_view));
3823           attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK;
3824           attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
3825           tree_view->priv->drag_highlight_window = gdk_window_new (tree_view->priv->header_window, &attributes, attributes_mask);
3826           gtk_widget_register_window (GTK_WIDGET (tree_view), tree_view->priv->drag_highlight_window);
3827
3828           mask_image = cairo_image_surface_create (CAIRO_FORMAT_A1, width, height);
3829           cr = cairo_create (mask_image);
3830
3831           cairo_rectangle (cr, 1, 1, width - 2, height - 2);
3832           cairo_stroke (cr);
3833           cairo_destroy (cr);
3834
3835           mask_region = gdk_cairo_region_create_from_surface (mask_image);
3836           gdk_window_shape_combine_region (tree_view->priv->drag_highlight_window,
3837                                            mask_region, 0, 0);
3838
3839           cairo_region_destroy (mask_region);
3840           cairo_surface_destroy (mask_image);
3841
3842           tree_view->priv->drag_column_window_state = DRAG_COLUMN_WINDOW_STATE_ORIGINAL;
3843         }
3844     }
3845   else if (arrow_type == DRAG_COLUMN_WINDOW_STATE_ARROW)
3846     {
3847       GtkAllocation button_allocation;
3848       GtkWidget    *button;
3849
3850       width = gtk_tree_view_get_expander_size (tree_view);
3851
3852       /* Get x, y, width, height of arrow */
3853       gdk_window_get_origin (tree_view->priv->header_window, &x, &y);
3854       if (reorder->left_column)
3855         {
3856           button = gtk_tree_view_column_get_button (reorder->left_column);
3857           gtk_widget_get_allocation (button, &button_allocation);
3858           x += button_allocation.x + button_allocation.width - width/2;
3859           height = button_allocation.height;
3860         }
3861       else
3862         {
3863           button = gtk_tree_view_column_get_button (reorder->right_column);
3864           gtk_widget_get_allocation (button, &button_allocation);
3865           x += button_allocation.x - width/2;
3866           height = button_allocation.height;
3867         }
3868       y -= width/2; /* The arrow takes up only half the space */
3869       height += width;
3870
3871       /* Create the new window */
3872       if (tree_view->priv->drag_column_window_state != DRAG_COLUMN_WINDOW_STATE_ARROW)
3873         {
3874           if (tree_view->priv->drag_highlight_window)
3875             {
3876               gtk_widget_unregister_window (GTK_WIDGET (tree_view), tree_view->priv->drag_highlight_window);
3877               gdk_window_destroy (tree_view->priv->drag_highlight_window);
3878             }
3879
3880           attributes.window_type = GDK_WINDOW_TEMP;
3881           attributes.wclass = GDK_INPUT_OUTPUT;
3882           attributes.visual = gtk_widget_get_visual (GTK_WIDGET (tree_view));
3883           attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK;
3884           attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
3885           attributes.x = x;
3886           attributes.y = y;
3887           attributes.width = width;
3888           attributes.height = height;
3889           tree_view->priv->drag_highlight_window = gdk_window_new (gtk_widget_get_root_window (widget),
3890                                                                    &attributes, attributes_mask);
3891           gtk_widget_register_window (GTK_WIDGET (tree_view), tree_view->priv->drag_highlight_window);
3892
3893           mask_image = cairo_image_surface_create (CAIRO_FORMAT_A1, width, height);
3894
3895           cr = cairo_create (mask_image);
3896           cairo_move_to (cr, 0, 0);
3897           cairo_line_to (cr, width, 0);
3898           cairo_line_to (cr, width / 2., width / 2);
3899           cairo_move_to (cr, 0, height);
3900           cairo_line_to (cr, width, height);
3901           cairo_line_to (cr, width / 2., height - width / 2.);
3902           cairo_fill (cr);
3903           cairo_destroy (cr);
3904
3905           mask_region = gdk_cairo_region_create_from_surface (mask_image);
3906           gdk_window_shape_combine_region (tree_view->priv->drag_highlight_window,
3907                                            mask_region, 0, 0);
3908
3909           cairo_region_destroy (mask_region);
3910           cairo_surface_destroy (mask_image);
3911         }
3912
3913       tree_view->priv->drag_column_window_state = DRAG_COLUMN_WINDOW_STATE_ARROW;
3914       gdk_window_move (tree_view->priv->drag_highlight_window, x, y);
3915     }
3916   else if (arrow_type == DRAG_COLUMN_WINDOW_STATE_ARROW_LEFT ||
3917            arrow_type == DRAG_COLUMN_WINDOW_STATE_ARROW_RIGHT)
3918     {
3919       GtkAllocation allocation;
3920       GtkWidget    *button;
3921       gint          expander_size;
3922
3923       expander_size = gtk_tree_view_get_expander_size (tree_view);
3924
3925       /* Get x, y, width, height of arrow */
3926       width = expander_size/2; /* remember, the arrow only takes half the available width */
3927       gdk_window_get_origin (gtk_widget_get_window (widget),
3928                              &x, &y);
3929       if (arrow_type == DRAG_COLUMN_WINDOW_STATE_ARROW_RIGHT)
3930         {
3931           gtk_widget_get_allocation (widget, &allocation);
3932           x += allocation.width - width;
3933         }
3934
3935       if (reorder->left_column)
3936         {
3937           button = gtk_tree_view_column_get_button (reorder->left_column);
3938           gtk_widget_get_allocation (button, &allocation);
3939           height = allocation.height;
3940         }
3941       else
3942         {
3943           button = gtk_tree_view_column_get_button (reorder->right_column);
3944           gtk_widget_get_allocation (button, &allocation);
3945           height = allocation.height;
3946         }
3947
3948       y -= expander_size;
3949       height += 2 * expander_size;
3950
3951       /* Create the new window */
3952       if (tree_view->priv->drag_column_window_state != DRAG_COLUMN_WINDOW_STATE_ARROW_LEFT &&
3953           tree_view->priv->drag_column_window_state != DRAG_COLUMN_WINDOW_STATE_ARROW_RIGHT)
3954         {
3955           if (tree_view->priv->drag_highlight_window)
3956             {
3957               gtk_widget_unregister_window (GTK_WIDGET (tree_view), tree_view->priv->drag_highlight_window);
3958               gdk_window_destroy (tree_view->priv->drag_highlight_window);
3959             }
3960
3961           attributes.window_type = GDK_WINDOW_TEMP;
3962           attributes.wclass = GDK_INPUT_OUTPUT;
3963           attributes.visual = gtk_widget_get_visual (GTK_WIDGET (tree_view));
3964           attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK;
3965           attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
3966           attributes.x = x;
3967           attributes.y = y;
3968           attributes.width = width;
3969           attributes.height = height;
3970           tree_view->priv->drag_highlight_window = gdk_window_new (gtk_widget_get_root_window (widget), &attributes, attributes_mask);
3971           gtk_widget_register_window (GTK_WIDGET (tree_view), tree_view->priv->drag_highlight_window);
3972
3973           mask_image = cairo_image_surface_create (CAIRO_FORMAT_A1, width, height);
3974
3975           cr = cairo_create (mask_image);
3976           /* mirror if we're on the left */
3977           if (arrow_type == DRAG_COLUMN_WINDOW_STATE_ARROW_LEFT)
3978             {
3979               cairo_translate (cr, width, 0);
3980               cairo_scale (cr, -1, 1);
3981             }
3982           cairo_move_to (cr, 0, 0);
3983           cairo_line_to (cr, width, width);
3984           cairo_line_to (cr, 0, expander_size);
3985           cairo_move_to (cr, 0, height);
3986           cairo_line_to (cr, width, height - width);
3987           cairo_line_to (cr, 0, height - expander_size);
3988           cairo_fill (cr);
3989           cairo_destroy (cr);
3990
3991           mask_region = gdk_cairo_region_create_from_surface (mask_image);
3992           gdk_window_shape_combine_region (tree_view->priv->drag_highlight_window,
3993                                            mask_region, 0, 0);
3994
3995           cairo_region_destroy (mask_region);
3996           cairo_surface_destroy (mask_image);
3997         }
3998
3999       tree_view->priv->drag_column_window_state = arrow_type;
4000       gdk_window_move (tree_view->priv->drag_highlight_window, x, y);
4001    }
4002   else
4003     {
4004       g_warning (G_STRLOC"Invalid GtkTreeViewColumnReorder struct");
4005       gdk_window_hide (tree_view->priv->drag_highlight_window);
4006       return;
4007     }
4008
4009   gdk_window_show (tree_view->priv->drag_highlight_window);
4010   gdk_window_raise (tree_view->priv->drag_highlight_window);
4011 }
4012
4013 static gboolean
4014 gtk_tree_view_motion_resize_column (GtkWidget      *widget,
4015                                     GdkEventMotion *event)
4016 {
4017   gint x;
4018   gint new_width;
4019   GtkTreeViewColumn *column;
4020   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
4021
4022   column = gtk_tree_view_get_column (tree_view, tree_view->priv->drag_pos);
4023
4024   gdk_window_get_device_position (tree_view->priv->bin_window,
4025                                   gdk_event_get_device ((GdkEvent *) event),
4026                                   &x, NULL, NULL);
4027
4028   if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL)
4029     new_width = MAX (tree_view->priv->x_drag - x, 0);
4030   else
4031     new_width = MAX (x - tree_view->priv->x_drag, 0);
4032
4033   if (new_width != gtk_tree_view_column_get_width (column))
4034     gtk_tree_view_modify_column_width (tree_view, column, new_width);
4035
4036   return FALSE;
4037 }
4038
4039
4040 static void
4041 gtk_tree_view_update_current_reorder (GtkTreeView *tree_view,
4042                                       GdkEvent    *event)
4043 {
4044   GtkTreeViewColumnReorder *reorder = NULL;
4045   GList *list;
4046   gint mouse_x;
4047
4048   gdk_window_get_device_position (tree_view->priv->header_window,
4049                                   gdk_event_get_device (event),
4050                                   &mouse_x, NULL, NULL);
4051   for (list = tree_view->priv->column_drag_info; list; list = list->next)
4052     {
4053       reorder = (GtkTreeViewColumnReorder *) list->data;
4054       if (mouse_x >= reorder->left_align && mouse_x < reorder->right_align)
4055         break;
4056       reorder = NULL;
4057     }
4058
4059   /*  if (reorder && reorder == tree_view->priv->cur_reorder)
4060       return;*/
4061
4062   tree_view->priv->cur_reorder = reorder;
4063   gtk_tree_view_motion_draw_column_motion_arrow (tree_view);
4064 }
4065
4066 static void
4067 gtk_tree_view_vertical_autoscroll (GtkTreeView *tree_view)
4068 {
4069   GdkRectangle visible_rect;
4070   gint y;
4071   gint offset;
4072
4073   gdk_window_get_device_position (tree_view->priv->bin_window,
4074                                   gdk_device_manager_get_client_pointer (
4075                                     gdk_display_get_device_manager (
4076                                       gtk_widget_get_display (GTK_WIDGET (tree_view)))),
4077                                   NULL, &y, NULL);
4078   y += tree_view->priv->dy;
4079
4080   gtk_tree_view_get_visible_rect (tree_view, &visible_rect);
4081
4082   /* see if we are near the edge. */
4083   offset = y - (visible_rect.y + 2 * SCROLL_EDGE_SIZE);
4084   if (offset > 0)
4085     {
4086       offset = y - (visible_rect.y + visible_rect.height - 2 * SCROLL_EDGE_SIZE);
4087       if (offset < 0)
4088         return;
4089     }
4090
4091   gtk_adjustment_set_value (tree_view->priv->vadjustment,
4092                             MAX (gtk_adjustment_get_value (tree_view->priv->vadjustment) + offset, 0.0));
4093 }
4094
4095 static gboolean
4096 gtk_tree_view_horizontal_autoscroll (GtkTreeView *tree_view,
4097                                      GdkEvent    *event)
4098 {
4099   GdkRectangle visible_rect;
4100   gint x;
4101   gint offset;
4102
4103   gdk_window_get_device_position (tree_view->priv->bin_window,
4104                                   gdk_event_get_device (event),
4105                                   &x, NULL, NULL);
4106
4107   gtk_tree_view_get_visible_rect (tree_view, &visible_rect);
4108
4109   /* See if we are near the edge. */
4110   offset = x - (visible_rect.x + SCROLL_EDGE_SIZE);
4111   if (offset > 0)
4112     {
4113       offset = x - (visible_rect.x + visible_rect.width - SCROLL_EDGE_SIZE);
4114       if (offset < 0)
4115         return TRUE;
4116     }
4117   offset = offset/3;
4118
4119   gtk_adjustment_set_value (tree_view->priv->hadjustment,
4120                             MAX (gtk_adjustment_get_value (tree_view->priv->hadjustment) + offset, 0.0));
4121
4122   return TRUE;
4123
4124 }
4125
4126 static gboolean
4127 gtk_tree_view_motion_drag_column (GtkWidget      *widget,
4128                                   GdkEventMotion *event)
4129 {
4130   GtkAllocation allocation, button_allocation;
4131   GtkTreeView *tree_view = (GtkTreeView *) widget;
4132   GtkTreeViewColumn *column = tree_view->priv->drag_column;
4133   GtkWidget *button;
4134   gint x, y;
4135
4136   /* Sanity Check */
4137   if ((column == NULL) ||
4138       (event->window != tree_view->priv->drag_window))
4139     return FALSE;
4140
4141   button = gtk_tree_view_column_get_button (column);
4142
4143   /* Handle moving the header */
4144   gdk_window_get_position (tree_view->priv->drag_window, &x, &y);
4145   gtk_widget_get_allocation (widget, &allocation);
4146   gtk_widget_get_allocation (button, &button_allocation);
4147   x = CLAMP (x + (gint)event->x - _gtk_tree_view_column_get_drag_x (column), 0,
4148              MAX (tree_view->priv->width, allocation.width) - button_allocation.width);
4149   gdk_window_move (tree_view->priv->drag_window, x, y);
4150
4151   /* autoscroll, if needed */
4152   gtk_tree_view_horizontal_autoscroll (tree_view, (GdkEvent *) event);
4153   /* Update the current reorder position and arrow; */
4154   gtk_tree_view_update_current_reorder (tree_view, (GdkEvent *) event);
4155
4156   return TRUE;
4157 }
4158
4159 static void
4160 gtk_tree_view_stop_rubber_band (GtkTreeView *tree_view)
4161 {
4162   remove_scroll_timeout (tree_view);
4163   gtk_grab_remove (GTK_WIDGET (tree_view));
4164
4165   if (tree_view->priv->rubber_band_status == RUBBER_BAND_ACTIVE)
4166     {
4167       GtkTreePath *tmp_path;
4168
4169       gtk_widget_queue_draw (GTK_WIDGET (tree_view));
4170
4171       /* The anchor path should be set to the start path */
4172       tmp_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->rubber_band_start_tree,
4173                                                  tree_view->priv->rubber_band_start_node);
4174
4175       if (tree_view->priv->anchor)
4176         gtk_tree_row_reference_free (tree_view->priv->anchor);
4177
4178       tree_view->priv->anchor =
4179         gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view),
4180                                           tree_view->priv->model,
4181                                           tmp_path);
4182
4183       gtk_tree_path_free (tmp_path);
4184
4185       /* ... and the cursor to the end path */
4186       tmp_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->rubber_band_end_tree,
4187                                                  tree_view->priv->rubber_band_end_node);
4188       gtk_tree_view_real_set_cursor (GTK_TREE_VIEW (tree_view), tmp_path, 0);
4189       gtk_tree_path_free (tmp_path);
4190
4191       _gtk_tree_selection_emit_changed (tree_view->priv->selection);
4192     }
4193
4194   /* Clear status variables */
4195   tree_view->priv->rubber_band_status = RUBBER_BAND_OFF;
4196   tree_view->priv->rubber_band_extend = FALSE;
4197   tree_view->priv->rubber_band_modify = FALSE;
4198
4199   tree_view->priv->rubber_band_start_node = NULL;
4200   tree_view->priv->rubber_band_start_tree = NULL;
4201   tree_view->priv->rubber_band_end_node = NULL;
4202   tree_view->priv->rubber_band_end_tree = NULL;
4203 }
4204
4205 static void
4206 gtk_tree_view_update_rubber_band_selection_range (GtkTreeView *tree_view,
4207                                                  GtkRBTree   *start_tree,
4208                                                  GtkRBNode   *start_node,
4209                                                  GtkRBTree   *end_tree,
4210                                                  GtkRBNode   *end_node,
4211                                                  gboolean     select,
4212                                                  gboolean     skip_start,
4213                                                  gboolean     skip_end)
4214 {
4215   if (start_node == end_node)
4216     return;
4217
4218   /* We skip the first node and jump inside the loop */
4219   if (skip_start)
4220     goto skip_first;
4221
4222   do
4223     {
4224       /* Small optimization by assuming insensitive nodes are never
4225        * selected.
4226        */
4227       if (!GTK_RBNODE_FLAG_SET (start_node, GTK_RBNODE_IS_SELECTED))
4228         {
4229           GtkTreePath *path;
4230           gboolean selectable;
4231
4232           path = _gtk_tree_path_new_from_rbtree (start_tree, start_node);
4233           selectable = _gtk_tree_selection_row_is_selectable (tree_view->priv->selection, start_node, path);
4234           gtk_tree_path_free (path);
4235
4236           if (!selectable)
4237             goto node_not_selectable;
4238         }
4239
4240       if (select)
4241         {
4242           if (tree_view->priv->rubber_band_extend)
4243             GTK_RBNODE_SET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
4244           else if (tree_view->priv->rubber_band_modify)
4245             {
4246               /* Toggle the selection state */
4247               if (GTK_RBNODE_FLAG_SET (start_node, GTK_RBNODE_IS_SELECTED))
4248                 GTK_RBNODE_UNSET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
4249               else
4250                 GTK_RBNODE_SET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
4251             }
4252           else
4253             GTK_RBNODE_SET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
4254         }
4255       else
4256         {
4257           /* Mirror the above */
4258           if (tree_view->priv->rubber_band_extend)
4259             GTK_RBNODE_UNSET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
4260           else if (tree_view->priv->rubber_band_modify)
4261             {
4262               /* Toggle the selection state */
4263               if (GTK_RBNODE_FLAG_SET (start_node, GTK_RBNODE_IS_SELECTED))
4264                 GTK_RBNODE_UNSET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
4265               else
4266                 GTK_RBNODE_SET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
4267             }
4268           else
4269             GTK_RBNODE_UNSET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
4270         }
4271
4272       _gtk_tree_view_queue_draw_node (tree_view, start_tree, start_node, NULL);
4273
4274 node_not_selectable:
4275       if (start_node == end_node)
4276         break;
4277
4278 skip_first:
4279
4280       if (start_node->children)
4281         {
4282           start_tree = start_node->children;
4283           start_node = _gtk_rbtree_first (start_tree);
4284         }
4285       else
4286         {
4287           _gtk_rbtree_next_full (start_tree, start_node, &start_tree, &start_node);
4288
4289           if (!start_tree)
4290             /* Ran out of tree */
4291             break;
4292         }
4293
4294       if (skip_end && start_node == end_node)
4295         break;
4296     }
4297   while (TRUE);
4298 }
4299
4300 static void
4301 gtk_tree_view_update_rubber_band_selection (GtkTreeView *tree_view)
4302 {
4303   GtkRBTree *start_tree, *end_tree;
4304   GtkRBNode *start_node, *end_node;
4305
4306   _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);
4307   _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);
4308
4309   /* Handle the start area first */
4310   if (!tree_view->priv->rubber_band_start_node)
4311     {
4312       gtk_tree_view_update_rubber_band_selection_range (tree_view,
4313                                                        start_tree,
4314                                                        start_node,
4315                                                        end_tree,
4316                                                        end_node,
4317                                                        TRUE,
4318                                                        FALSE,
4319                                                        FALSE);
4320     }
4321   else if (_gtk_rbtree_node_find_offset (start_tree, start_node) <
4322            _gtk_rbtree_node_find_offset (tree_view->priv->rubber_band_start_tree, tree_view->priv->rubber_band_start_node))
4323     {
4324       /* New node is above the old one; selection became bigger */
4325       gtk_tree_view_update_rubber_band_selection_range (tree_view,
4326                                                        start_tree,
4327                                                        start_node,
4328                                                        tree_view->priv->rubber_band_start_tree,
4329                                                        tree_view->priv->rubber_band_start_node,
4330                                                        TRUE,
4331                                                        FALSE,
4332                                                        TRUE);
4333     }
4334   else if (_gtk_rbtree_node_find_offset (start_tree, start_node) >
4335            _gtk_rbtree_node_find_offset (tree_view->priv->rubber_band_start_tree, tree_view->priv->rubber_band_start_node))
4336     {
4337       /* New node is below the old one; selection became smaller */
4338       gtk_tree_view_update_rubber_band_selection_range (tree_view,
4339                                                        tree_view->priv->rubber_band_start_tree,
4340                                                        tree_view->priv->rubber_band_start_node,
4341                                                        start_tree,
4342                                                        start_node,
4343                                                        FALSE,
4344                                                        FALSE,
4345                                                        TRUE);
4346     }
4347
4348   tree_view->priv->rubber_band_start_tree = start_tree;
4349   tree_view->priv->rubber_band_start_node = start_node;
4350
4351   /* Next, handle the end area */
4352   if (!tree_view->priv->rubber_band_end_node)
4353     {
4354       /* In the event this happens, start_node was also NULL; this case is
4355        * handled above.
4356        */
4357     }
4358   else if (!end_node)
4359     {
4360       /* Find the last node in the tree */
4361       _gtk_rbtree_find_offset (tree_view->priv->tree, tree_view->priv->height - 1,
4362                                &end_tree, &end_node);
4363
4364       /* Selection reached end of the tree */
4365       gtk_tree_view_update_rubber_band_selection_range (tree_view,
4366                                                        tree_view->priv->rubber_band_end_tree,
4367                                                        tree_view->priv->rubber_band_end_node,
4368                                                        end_tree,
4369                                                        end_node,
4370                                                        TRUE,
4371                                                        TRUE,
4372                                                        FALSE);
4373     }
4374   else if (_gtk_rbtree_node_find_offset (end_tree, end_node) >
4375            _gtk_rbtree_node_find_offset (tree_view->priv->rubber_band_end_tree, tree_view->priv->rubber_band_end_node))
4376     {
4377       /* New node is below the old one; selection became bigger */
4378       gtk_tree_view_update_rubber_band_selection_range (tree_view,
4379                                                        tree_view->priv->rubber_band_end_tree,
4380                                                        tree_view->priv->rubber_band_end_node,
4381                                                        end_tree,
4382                                                        end_node,
4383                                                        TRUE,
4384                                                        TRUE,
4385                                                        FALSE);
4386     }
4387   else if (_gtk_rbtree_node_find_offset (end_tree, end_node) <
4388            _gtk_rbtree_node_find_offset (tree_view->priv->rubber_band_end_tree, tree_view->priv->rubber_band_end_node))
4389     {
4390       /* New node is above the old one; selection became smaller */
4391       gtk_tree_view_update_rubber_band_selection_range (tree_view,
4392                                                        end_tree,
4393                                                        end_node,
4394                                                        tree_view->priv->rubber_band_end_tree,
4395                                                        tree_view->priv->rubber_band_end_node,
4396                                                        FALSE,
4397                                                        TRUE,
4398                                                        FALSE);
4399     }
4400
4401   tree_view->priv->rubber_band_end_tree = end_tree;
4402   tree_view->priv->rubber_band_end_node = end_node;
4403 }
4404
4405 static void
4406 gtk_tree_view_update_rubber_band (GtkTreeView *tree_view)
4407 {
4408   gint x, y;
4409   GdkRectangle old_area;
4410   GdkRectangle new_area;
4411   GdkRectangle common;
4412   cairo_region_t *invalid_region;
4413
4414   old_area.x = MIN (tree_view->priv->press_start_x, tree_view->priv->rubber_band_x);
4415   old_area.y = MIN (tree_view->priv->press_start_y, tree_view->priv->rubber_band_y) - tree_view->priv->dy;
4416   old_area.width = ABS (tree_view->priv->rubber_band_x - tree_view->priv->press_start_x) + 1;
4417   old_area.height = ABS (tree_view->priv->rubber_band_y - tree_view->priv->press_start_y) + 1;
4418
4419   gdk_window_get_device_position (tree_view->priv->bin_window,
4420                                   gdk_device_manager_get_client_pointer (
4421                                     gdk_display_get_device_manager (
4422                                       gtk_widget_get_display (GTK_WIDGET (tree_view)))),
4423                                   &x, &y, NULL);
4424
4425   x = MAX (x, 0);
4426   y = MAX (y, 0) + tree_view->priv->dy;
4427
4428   new_area.x = MIN (tree_view->priv->press_start_x, x);
4429   new_area.y = MIN (tree_view->priv->press_start_y, y) - tree_view->priv->dy;
4430   new_area.width = ABS (x - tree_view->priv->press_start_x) + 1;
4431   new_area.height = ABS (y - tree_view->priv->press_start_y) + 1;
4432
4433   invalid_region = cairo_region_create_rectangle (&old_area);
4434   cairo_region_union_rectangle (invalid_region, &new_area);
4435
4436   gdk_rectangle_intersect (&old_area, &new_area, &common);
4437   if (common.width > 2 && common.height > 2)
4438     {
4439       cairo_region_t *common_region;
4440
4441       /* make sure the border is invalidated */
4442       common.x += 1;
4443       common.y += 1;
4444       common.width -= 2;
4445       common.height -= 2;
4446
4447       common_region = cairo_region_create_rectangle (&common);
4448
4449       cairo_region_subtract (invalid_region, common_region);
4450       cairo_region_destroy (common_region);
4451     }
4452
4453   gdk_window_invalidate_region (tree_view->priv->bin_window, invalid_region, TRUE);
4454
4455   cairo_region_destroy (invalid_region);
4456
4457   tree_view->priv->rubber_band_x = x;
4458   tree_view->priv->rubber_band_y = y;
4459
4460   gtk_tree_view_update_rubber_band_selection (tree_view);
4461 }
4462
4463 static void
4464 gtk_tree_view_paint_rubber_band (GtkTreeView  *tree_view,
4465                                  cairo_t      *cr)
4466 {
4467   GdkRectangle rect;
4468   GtkStyleContext *context;
4469
4470   cairo_save (cr);
4471
4472   context = gtk_widget_get_style_context (GTK_WIDGET (tree_view));
4473
4474   gtk_style_context_save (context);
4475   gtk_style_context_add_class (context, GTK_STYLE_CLASS_RUBBERBAND);
4476
4477   rect.x = MIN (tree_view->priv->press_start_x, tree_view->priv->rubber_band_x);
4478   rect.y = MIN (tree_view->priv->press_start_y, tree_view->priv->rubber_band_y) - tree_view->priv->dy;
4479   rect.width = ABS (tree_view->priv->press_start_x - tree_view->priv->rubber_band_x) + 1;
4480   rect.height = ABS (tree_view->priv->press_start_y - tree_view->priv->rubber_band_y) + 1;
4481
4482   gdk_cairo_rectangle (cr, &rect);
4483   cairo_clip (cr);
4484
4485   gtk_render_background (context, cr,
4486                          rect.x, rect.y,
4487                          rect.width, rect.height);
4488   gtk_render_frame (context, cr,
4489                     rect.x, rect.y,
4490                     rect.width, rect.height);
4491
4492   gtk_style_context_restore (context);
4493   cairo_restore (cr);
4494 }
4495
4496 static gboolean
4497 gtk_tree_view_motion_bin_window (GtkWidget      *widget,
4498                                  GdkEventMotion *event)
4499 {
4500   GtkTreeView *tree_view;
4501   GtkRBTree *tree;
4502   GtkRBNode *node;
4503   gint new_y;
4504
4505   tree_view = (GtkTreeView *) widget;
4506
4507   if (tree_view->priv->tree == NULL)
4508     return FALSE;
4509
4510   if (tree_view->priv->rubber_band_status == RUBBER_BAND_MAYBE_START)
4511     {
4512       gtk_grab_add (GTK_WIDGET (tree_view));
4513       gtk_tree_view_update_rubber_band (tree_view);
4514
4515       tree_view->priv->rubber_band_status = RUBBER_BAND_ACTIVE;
4516     }
4517   else if (tree_view->priv->rubber_band_status == RUBBER_BAND_ACTIVE)
4518     {
4519       gtk_tree_view_update_rubber_band (tree_view);
4520
4521       add_scroll_timeout (tree_view);
4522     }
4523
4524   /* only check for an initiated drag when a button is pressed */
4525   if (tree_view->priv->pressed_button >= 0
4526       && !tree_view->priv->rubber_band_status)
4527     gtk_tree_view_maybe_begin_dragging_row (tree_view, event);
4528
4529   new_y = TREE_WINDOW_Y_TO_RBTREE_Y(tree_view, event->y);
4530   if (new_y < 0)
4531     new_y = 0;
4532
4533   _gtk_rbtree_find_offset (tree_view->priv->tree, new_y, &tree, &node);
4534
4535   /* If we are currently pressing down a button, we don't want to prelight anything else. */
4536   if ((tree_view->priv->button_pressed_node != NULL) &&
4537       (tree_view->priv->button_pressed_node != node))
4538     node = NULL;
4539
4540   tree_view->priv->event_last_x = event->x;
4541   tree_view->priv->event_last_y = event->y;
4542
4543   prelight_or_select (tree_view, tree, node, event->x, event->y);
4544
4545   return TRUE;
4546 }
4547
4548 static gboolean
4549 gtk_tree_view_motion (GtkWidget      *widget,
4550                       GdkEventMotion *event)
4551 {
4552   GtkTreeView *tree_view;
4553
4554   tree_view = (GtkTreeView *) widget;
4555
4556   /* Resizing a column */
4557   if (tree_view->priv->in_column_resize)
4558     return gtk_tree_view_motion_resize_column (widget, event);
4559
4560   /* Drag column */
4561   if (tree_view->priv->in_column_drag)
4562     return gtk_tree_view_motion_drag_column (widget, event);
4563
4564   /* Sanity check it */
4565   if (event->window == tree_view->priv->bin_window)
4566     return gtk_tree_view_motion_bin_window (widget, event);
4567
4568   return FALSE;
4569 }
4570
4571 /* Invalidate the focus rectangle near the edge of the bin_window; used when
4572  * the tree is empty.
4573  */
4574 static void
4575 invalidate_empty_focus (GtkTreeView *tree_view)
4576 {
4577   GdkRectangle area;
4578
4579   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
4580     return;
4581
4582   area.x = 0;
4583   area.y = 0;
4584   area.width = gdk_window_get_width (tree_view->priv->bin_window);
4585   area.height = gdk_window_get_height (tree_view->priv->bin_window);
4586   gdk_window_invalidate_rect (tree_view->priv->bin_window, &area, FALSE);
4587 }
4588
4589 /* Draws a focus rectangle near the edge of the bin_window; used when the tree
4590  * is empty.
4591  */
4592 static void
4593 draw_empty_focus (GtkTreeView *tree_view, cairo_t *cr)
4594 {
4595   GtkWidget *widget = GTK_WIDGET (tree_view);
4596   gint w, h;
4597
4598   if (!gtk_widget_has_visible_focus (widget))
4599     return;
4600
4601   w = gdk_window_get_width (tree_view->priv->bin_window) - 2;
4602   h = gdk_window_get_height (tree_view->priv->bin_window) - 2;
4603
4604   if (w > 0 && h > 0)
4605     {
4606       GtkStyleContext *context;
4607
4608       context = gtk_widget_get_style_context (widget);
4609
4610       gtk_render_focus (context, cr, 1, 1, w, h);
4611     }
4612 }
4613
4614 typedef enum {
4615   GTK_TREE_VIEW_GRID_LINE,
4616   GTK_TREE_VIEW_TREE_LINE,
4617   GTK_TREE_VIEW_FOREGROUND_LINE
4618 } GtkTreeViewLineType;
4619
4620 static void
4621 gtk_tree_view_draw_line (GtkTreeView         *tree_view,
4622                          cairo_t             *cr,
4623                          GtkTreeViewLineType  type,
4624                          int                  x1,
4625                          int                  y1,
4626                          int                  x2,
4627                          int                  y2)
4628 {
4629   cairo_save (cr);
4630
4631   switch (type)
4632     {
4633     case GTK_TREE_VIEW_TREE_LINE:
4634       cairo_set_source_rgb (cr, 0, 0, 0);
4635       cairo_set_line_width (cr, tree_view->priv->tree_line_width);
4636       if (tree_view->priv->tree_line_dashes[0])
4637         cairo_set_dash (cr,
4638                         tree_view->priv->tree_line_dashes,
4639                         2, 0.5);
4640       break;
4641     case GTK_TREE_VIEW_GRID_LINE:
4642       cairo_set_source_rgb (cr, 0, 0, 0);
4643       cairo_set_line_width (cr, tree_view->priv->grid_line_width);
4644       if (tree_view->priv->grid_line_dashes[0])
4645         cairo_set_dash (cr,
4646                         tree_view->priv->grid_line_dashes,
4647                         2, 0.5);
4648       break;
4649     default:
4650       g_assert_not_reached ();
4651       /* fall through */
4652     case GTK_TREE_VIEW_FOREGROUND_LINE:
4653       {
4654         GtkStyleContext *context;
4655         GtkStateFlags state;
4656         GdkRGBA color;
4657
4658         context = gtk_widget_get_style_context (GTK_WIDGET (tree_view));
4659         state = gtk_widget_get_state_flags (GTK_WIDGET (tree_view));
4660
4661         cairo_set_line_width (cr, 1.0);
4662         gtk_style_context_get_color (context, state, &color);
4663         gdk_cairo_set_source_rgba (cr, &color);
4664       }
4665
4666       break;
4667     }
4668
4669   cairo_move_to (cr, x1 + 0.5, y1 + 0.5);
4670   cairo_line_to (cr, x2 + 0.5, y2 + 0.5);
4671   cairo_stroke (cr);
4672
4673   cairo_restore (cr);
4674 }
4675
4676 static void
4677 gtk_tree_view_draw_grid_lines (GtkTreeView    *tree_view,
4678                                cairo_t        *cr,
4679                                gint            n_visible_columns)
4680 {
4681   GList *list = tree_view->priv->columns;
4682   gint i = 0;
4683   gint current_x = 0;
4684
4685   if (tree_view->priv->grid_lines != GTK_TREE_VIEW_GRID_LINES_VERTICAL
4686       && tree_view->priv->grid_lines != GTK_TREE_VIEW_GRID_LINES_BOTH)
4687     return;
4688
4689   /* Only draw the lines for visible rows and columns */
4690   for (list = tree_view->priv->columns; list; list = list->next, i++)
4691     {
4692       GtkTreeViewColumn *column = list->data;
4693
4694       /* We don't want a line for the last column */
4695       if (i == n_visible_columns - 1)
4696         break;
4697
4698       if (!gtk_tree_view_column_get_visible (column))
4699         continue;
4700
4701       current_x += gtk_tree_view_column_get_width (column);
4702
4703       gtk_tree_view_draw_line (tree_view, cr,
4704                                GTK_TREE_VIEW_GRID_LINE,
4705                                current_x - 1, 0,
4706                                current_x - 1, tree_view->priv->height);
4707     }
4708 }
4709
4710 /* Warning: Very scary function.
4711  * Modify at your own risk
4712  *
4713  * KEEP IN SYNC WITH gtk_tree_view_create_row_drag_icon()!
4714  * FIXME: It's not...
4715  */
4716 static gboolean
4717 gtk_tree_view_bin_draw (GtkWidget      *widget,
4718                         cairo_t        *cr)
4719 {
4720   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
4721   GtkTreePath *path;
4722   GtkRBTree *tree;
4723   GList *list;
4724   GtkRBNode *node;
4725   GtkRBNode *drag_highlight = NULL;
4726   GtkRBTree *drag_highlight_tree = NULL;
4727   GtkTreeIter iter;
4728   gint new_y;
4729   gint y_offset, cell_offset;
4730   gint max_height;
4731   gint depth;
4732   GdkRectangle background_area;
4733   GdkRectangle cell_area;
4734   GdkRectangle clip;
4735   guint flags;
4736   gint highlight_x;
4737   gint expander_cell_width;
4738   gint bin_window_width;
4739   gint bin_window_height;
4740   GtkTreePath *drag_dest_path;
4741   GList *first_column, *last_column;
4742   gint vertical_separator;
4743   gint horizontal_separator;
4744   gboolean allow_rules;
4745   gboolean has_can_focus_cell;
4746   gboolean rtl;
4747   gint n_visible_columns;
4748   gint grid_line_width;
4749   gint expander_size;
4750   gboolean draw_vgrid_lines, draw_hgrid_lines;
4751   GtkStyleContext *context;
4752   gboolean parity;
4753
4754   rtl = (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL);
4755   context = gtk_widget_get_style_context (widget);
4756
4757   gtk_widget_style_get (widget,
4758                         "horizontal-separator", &horizontal_separator,
4759                         "vertical-separator", &vertical_separator,
4760                         "allow-rules", &allow_rules,
4761                         NULL);
4762
4763   if (tree_view->priv->tree == NULL)
4764     {
4765       draw_empty_focus (tree_view, cr);
4766       return TRUE;
4767     }
4768
4769   bin_window_width = gdk_window_get_width (tree_view->priv->bin_window);
4770   bin_window_height = gdk_window_get_height (tree_view->priv->bin_window);
4771   cairo_rectangle (cr, 0, 0, bin_window_width, bin_window_height);
4772   cairo_clip (cr);
4773   if (!gdk_cairo_get_clip_rectangle (cr, &clip))
4774     return TRUE;
4775
4776   new_y = TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, clip.y);
4777
4778   if (new_y < 0)
4779     new_y = 0;
4780   y_offset = -_gtk_rbtree_find_offset (tree_view->priv->tree, new_y, &tree, &node);
4781
4782   if (tree_view->priv->height < bin_window_height)
4783     {
4784       gtk_style_context_save (context);
4785       gtk_style_context_add_class (context, GTK_STYLE_CLASS_CELL);
4786
4787       gtk_render_background (context, cr,
4788                              0, tree_view->priv->height,
4789                              bin_window_width,
4790                              bin_window_height - tree_view->priv->height);
4791
4792       gtk_style_context_restore (context);
4793     }
4794
4795   if (node == NULL)
4796     return TRUE;
4797
4798   /* find the path for the node */
4799   path = _gtk_tree_path_new_from_rbtree (tree, node);
4800   gtk_tree_model_get_iter (tree_view->priv->model,
4801                            &iter,
4802                            path);
4803   depth = gtk_tree_path_get_depth (path);
4804   gtk_tree_path_free (path);
4805
4806   drag_dest_path = NULL;
4807
4808   if (tree_view->priv->drag_dest_row)
4809     drag_dest_path = gtk_tree_row_reference_get_path (tree_view->priv->drag_dest_row);
4810
4811   if (drag_dest_path)
4812     _gtk_tree_view_find_node (tree_view, drag_dest_path,
4813                               &drag_highlight_tree, &drag_highlight);
4814
4815   draw_vgrid_lines =
4816     tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_VERTICAL
4817     || tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_BOTH;
4818   draw_hgrid_lines =
4819     tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_HORIZONTAL
4820     || tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_BOTH;
4821   expander_size = gtk_tree_view_get_expander_size (tree_view);
4822
4823   if (draw_vgrid_lines || draw_hgrid_lines)
4824     gtk_widget_style_get (widget, "grid-line-width", &grid_line_width, NULL);
4825
4826   n_visible_columns = 0;
4827   for (list = tree_view->priv->columns; list; list = list->next)
4828     {
4829       if (!gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (list->data)))
4830         continue;
4831       n_visible_columns ++;
4832     }
4833
4834   /* Find the last column */
4835   for (last_column = g_list_last (tree_view->priv->columns);
4836        last_column &&
4837        !(gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (last_column->data)));
4838        last_column = last_column->prev)
4839     ;
4840
4841   /* and the first */
4842   for (first_column = g_list_first (tree_view->priv->columns);
4843        first_column &&
4844        !(gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (first_column->data)));
4845        first_column = first_column->next)
4846     ;
4847
4848   /* Actually process the expose event.  To do this, we want to
4849    * start at the first node of the event, and walk the tree in
4850    * order, drawing each successive node.
4851    */
4852
4853   parity = !(_gtk_rbtree_node_get_index (tree, node) % 2);
4854
4855   do
4856     {
4857       gboolean is_separator = FALSE;
4858       gboolean is_first = FALSE;
4859       gboolean is_last = FALSE;
4860       gint n_col = 0;
4861
4862       parity = !parity;
4863       is_separator = row_is_separator (tree_view, &iter, NULL);
4864
4865       max_height = gtk_tree_view_get_row_height (tree_view, node);
4866
4867       cell_offset = 0;
4868       highlight_x = 0; /* should match x coord of first cell */
4869       expander_cell_width = 0;
4870
4871       background_area.y = y_offset + clip.y;
4872       background_area.height = max_height;
4873
4874       flags = 0;
4875
4876       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PRELIT))
4877         flags |= GTK_CELL_RENDERER_PRELIT;
4878
4879       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
4880         flags |= GTK_CELL_RENDERER_SELECTED;
4881
4882       /* we *need* to set cell data on all cells before the call
4883        * to _has_can_focus_cell, else _has_can_focus_cell() does not
4884        * return a correct value.
4885        */
4886       for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
4887            list;
4888            list = (rtl ? list->prev : list->next))
4889         {
4890           GtkTreeViewColumn *column = list->data;
4891           gtk_tree_view_column_cell_set_cell_data (column,
4892                                                    tree_view->priv->model,
4893                                                    &iter,
4894                                                    GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT),
4895                                                    node->children?TRUE:FALSE);
4896         }
4897
4898       has_can_focus_cell = gtk_tree_view_has_can_focus_cell (tree_view);
4899
4900       for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
4901            list;
4902            list = (rtl ? list->prev : list->next))
4903         {
4904           GtkTreeViewColumn *column = list->data;
4905           GtkRegionFlags row_flags = 0, column_flags = 0;
4906           GtkStateFlags state = 0;
4907           gint width;
4908           gboolean draw_focus;
4909
4910           if (!gtk_tree_view_column_get_visible (column))
4911             continue;
4912
4913           n_col++;
4914           width = gtk_tree_view_column_get_width (column);
4915
4916           if (cell_offset > clip.x + clip.width ||
4917               cell_offset + width < clip.x)
4918             {
4919               cell_offset += width;
4920               continue;
4921             }
4922
4923           if (gtk_tree_view_column_get_sort_indicator (column))
4924             flags |= GTK_CELL_RENDERER_SORTED;
4925           else
4926             flags &= ~GTK_CELL_RENDERER_SORTED;
4927
4928           if (tree_view->priv->cursor_node == node)
4929             flags |= GTK_CELL_RENDERER_FOCUSED;
4930           else
4931             flags &= ~GTK_CELL_RENDERER_FOCUSED;
4932
4933           if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT))
4934             flags |= GTK_CELL_RENDERER_EXPANDABLE;
4935           else
4936             flags &= ~GTK_CELL_RENDERER_EXPANDABLE;
4937
4938           if (node->children)
4939             flags |= GTK_CELL_RENDERER_EXPANDED;
4940           else
4941             flags &= ~GTK_CELL_RENDERER_EXPANDED;
4942
4943           background_area.x = cell_offset;
4944           background_area.width = width;
4945
4946           cell_area = background_area;
4947           cell_area.y += vertical_separator / 2;
4948           cell_area.x += horizontal_separator / 2;
4949           cell_area.height -= vertical_separator;
4950           cell_area.width -= horizontal_separator;
4951
4952           if (draw_vgrid_lines)
4953             {
4954               if (list == first_column)
4955                 {
4956                   cell_area.width -= grid_line_width / 2;
4957                 }
4958               else if (list == last_column)
4959                 {
4960                   cell_area.x += grid_line_width / 2;
4961                   cell_area.width -= grid_line_width / 2;
4962                 }
4963               else
4964                 {
4965                   cell_area.x += grid_line_width / 2;
4966                   cell_area.width -= grid_line_width;
4967                 }
4968             }
4969
4970           if (draw_hgrid_lines)
4971             {
4972               cell_area.y += grid_line_width / 2;
4973               cell_area.height -= grid_line_width;
4974             }
4975
4976           if (!gdk_rectangle_intersect (&clip, &background_area, NULL))
4977             {
4978               cell_offset += gtk_tree_view_column_get_width (column);
4979               continue;
4980             }
4981
4982           gtk_tree_view_column_cell_set_cell_data (column,
4983                                                    tree_view->priv->model,
4984                                                    &iter,
4985                                                    GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT),
4986                                                    node->children?TRUE:FALSE);
4987
4988           /* Select the detail for drawing the cell.  relevant
4989            * factors are parity, sortedness, and whether to
4990            * display rules.
4991            */
4992           if (allow_rules && tree_view->priv->has_rules)
4993             {
4994               if (parity)
4995                 row_flags |= GTK_REGION_ODD;
4996               else
4997                 row_flags |= GTK_REGION_EVEN;
4998             }
4999
5000           if ((flags & GTK_CELL_RENDERER_SORTED) &&
5001               n_visible_columns >= 3)
5002             column_flags |= GTK_REGION_SORTED;
5003
5004           is_first = (rtl ? !list->next : !list->prev);
5005           is_last = (rtl ? !list->prev : !list->next);
5006
5007           if (is_first)
5008             column_flags |= GTK_REGION_FIRST;
5009
5010           if (is_last)
5011             column_flags |= GTK_REGION_LAST;
5012
5013           if ((n_col % 2) == 0)
5014             column_flags |= GTK_REGION_EVEN;
5015           else
5016             column_flags |= GTK_REGION_ODD;
5017
5018           gtk_style_context_save (context);
5019
5020           state = gtk_cell_renderer_get_state (NULL, widget, flags);
5021           gtk_style_context_set_state (context, state);
5022
5023           gtk_style_context_add_class (context, GTK_STYLE_CLASS_CELL);
5024           gtk_style_context_add_region (context, GTK_STYLE_REGION_ROW, row_flags);
5025           gtk_style_context_add_region (context, GTK_STYLE_REGION_COLUMN, column_flags);
5026
5027           if (node == tree_view->priv->cursor_node && has_can_focus_cell
5028               && ((column == tree_view->priv->focus_column
5029                    && tree_view->priv->draw_keyfocus &&
5030                    gtk_widget_has_visible_focus (widget))
5031                   || (column == tree_view->priv->edited_column)))
5032             draw_focus = TRUE;
5033           else
5034             draw_focus = FALSE;
5035
5036           /* Draw background */
5037           gtk_render_background (context, cr,
5038                                  background_area.x,
5039                                  background_area.y,
5040                                  background_area.width,
5041                                  background_area.height);
5042
5043           /* Draw frame */
5044           gtk_render_frame (context, cr,
5045                             background_area.x,
5046                             background_area.y,
5047                             background_area.width,
5048                             background_area.height);
5049
5050           if (gtk_tree_view_is_expander_column (tree_view, column))
5051             {
5052               if (!rtl)
5053                 cell_area.x += (depth - 1) * tree_view->priv->level_indentation;
5054               cell_area.width -= (depth - 1) * tree_view->priv->level_indentation;
5055
5056               if (gtk_tree_view_draw_expanders (tree_view))
5057                 {
5058                   int expander_size = gtk_tree_view_get_expander_size (tree_view);
5059                   if (!rtl)
5060                     cell_area.x += depth * expander_size;
5061                   cell_area.width -= depth * expander_size;
5062                 }
5063
5064               /* If we have an expander column, the highlight underline
5065                * starts with that column, so that it indicates which
5066                * level of the tree we're dropping at.
5067                */
5068               highlight_x = cell_area.x;
5069               expander_cell_width = cell_area.width;
5070
5071               if (is_separator)
5072                 {
5073                   gtk_style_context_save (context);
5074                   gtk_style_context_add_class (context, GTK_STYLE_CLASS_SEPARATOR);
5075
5076                   gtk_render_line (context, cr,
5077                                    cell_area.x,
5078                                    cell_area.y + cell_area.height / 2,
5079                                    cell_area.x + cell_area.width,
5080                                    cell_area.y + cell_area.height / 2);
5081
5082                   gtk_style_context_restore (context);
5083                 }
5084               else
5085                 {
5086                   _gtk_tree_view_column_cell_render (column,
5087                                                      cr,
5088                                                      &background_area,
5089                                                      &cell_area,
5090                                                      flags,
5091                                                      draw_focus);
5092                 }
5093
5094               if (gtk_tree_view_draw_expanders (tree_view)
5095                   && (node->flags & GTK_RBNODE_IS_PARENT) == GTK_RBNODE_IS_PARENT)
5096                 {
5097                   gtk_tree_view_draw_arrow (GTK_TREE_VIEW (widget),
5098                                             cr,
5099                                             tree,
5100                                             node);
5101                 }
5102             }
5103           else
5104             {
5105               if (is_separator)
5106                 {
5107                   gtk_style_context_save (context);
5108                   gtk_style_context_add_class (context, GTK_STYLE_CLASS_SEPARATOR);
5109
5110                   gtk_render_line (context, cr,
5111                                    cell_area.x,
5112                                    cell_area.y + cell_area.height / 2,
5113                                    cell_area.x + cell_area.width,
5114                                    cell_area.y + cell_area.height / 2);
5115
5116                   gtk_style_context_restore (context);
5117                 }
5118               else
5119                 _gtk_tree_view_column_cell_render (column,
5120                                                    cr,
5121                                                    &background_area,
5122                                                    &cell_area,
5123                                                    flags,
5124                                                    draw_focus);
5125             }
5126
5127           if (draw_hgrid_lines)
5128             {
5129               if (background_area.y > 0)
5130                 gtk_tree_view_draw_line (tree_view, cr,
5131                                          GTK_TREE_VIEW_GRID_LINE,
5132                                          background_area.x, background_area.y,
5133                                          background_area.x + background_area.width,
5134                                          background_area.y);
5135
5136               if (y_offset + max_height >= clip.height)
5137                 gtk_tree_view_draw_line (tree_view, cr,
5138                                          GTK_TREE_VIEW_GRID_LINE,
5139                                          background_area.x, background_area.y + max_height,
5140                                          background_area.x + background_area.width,
5141                                          background_area.y + max_height);
5142             }
5143
5144           if (gtk_tree_view_is_expander_column (tree_view, column) &&
5145               tree_view->priv->tree_lines_enabled)
5146             {
5147               gint x = background_area.x;
5148               gint mult = rtl ? -1 : 1;
5149               gint y0 = background_area.y;
5150               gint y1 = background_area.y + background_area.height/2;
5151               gint y2 = background_area.y + background_area.height;
5152
5153               if (rtl)
5154                 x += background_area.width - 1;
5155
5156               if ((node->flags & GTK_RBNODE_IS_PARENT) == GTK_RBNODE_IS_PARENT
5157                   && depth > 1)
5158                 {
5159                   gtk_tree_view_draw_line (tree_view, cr,
5160                                            GTK_TREE_VIEW_TREE_LINE,
5161                                            x + expander_size * (depth - 1.5) * mult,
5162                                            y1,
5163                                            x + expander_size * (depth - 1.1) * mult,
5164                                            y1);
5165                 }
5166               else if (depth > 1)
5167                 {
5168                   gtk_tree_view_draw_line (tree_view, cr,
5169                                            GTK_TREE_VIEW_TREE_LINE,
5170                                            x + expander_size * (depth - 1.5) * mult,
5171                                            y1,
5172                                            x + expander_size * (depth - 0.5) * mult,
5173                                            y1);
5174                 }
5175
5176               if (depth > 1)
5177                 {
5178                   gint i;
5179                   GtkRBNode *tmp_node;
5180                   GtkRBTree *tmp_tree;
5181
5182                   if (!_gtk_rbtree_next (tree, node))
5183                     gtk_tree_view_draw_line (tree_view, cr,
5184                                              GTK_TREE_VIEW_TREE_LINE,
5185                                              x + expander_size * (depth - 1.5) * mult,
5186                                              y0,
5187                                              x + expander_size * (depth - 1.5) * mult,
5188                                              y1);
5189                   else
5190                     gtk_tree_view_draw_line (tree_view, cr,
5191                                              GTK_TREE_VIEW_TREE_LINE,
5192                                              x + expander_size * (depth - 1.5) * mult,
5193                                              y0,
5194                                              x + expander_size * (depth - 1.5) * mult,
5195                                              y2);
5196
5197                   tmp_node = tree->parent_node;
5198                   tmp_tree = tree->parent_tree;
5199
5200                   for (i = depth - 2; i > 0; i--)
5201                     {
5202                       if (_gtk_rbtree_next (tmp_tree, tmp_node))
5203                         gtk_tree_view_draw_line (tree_view, cr,
5204                                                  GTK_TREE_VIEW_TREE_LINE,
5205                                                  x + expander_size * (i - 0.5) * mult,
5206                                                  y0,
5207                                                  x + expander_size * (i - 0.5) * mult,
5208                                                  y2);
5209
5210                       tmp_node = tmp_tree->parent_node;
5211                       tmp_tree = tmp_tree->parent_tree;
5212                     }
5213                 }
5214             }
5215
5216           gtk_style_context_restore (context);
5217           cell_offset += gtk_tree_view_column_get_width (column);
5218         }
5219
5220       if (node == drag_highlight)
5221         {
5222           /* Draw indicator for the drop
5223            */
5224           gint highlight_y = -1;
5225           GtkRBTree *tree = NULL;
5226           GtkRBNode *node = NULL;
5227
5228           gtk_style_context_save (context);
5229           gtk_style_context_add_class (context, GTK_STYLE_CLASS_DND);
5230
5231           switch (tree_view->priv->drag_dest_pos)
5232             {
5233             case GTK_TREE_VIEW_DROP_BEFORE:
5234               highlight_y = background_area.y - 1;
5235               if (highlight_y < 0)
5236                       highlight_y = 0;
5237               break;
5238
5239             case GTK_TREE_VIEW_DROP_AFTER:
5240               highlight_y = background_area.y + background_area.height - 1;
5241               break;
5242
5243             case GTK_TREE_VIEW_DROP_INTO_OR_BEFORE:
5244             case GTK_TREE_VIEW_DROP_INTO_OR_AFTER:
5245               _gtk_tree_view_find_node (tree_view, drag_dest_path, &tree, &node);
5246
5247               if (tree == NULL)
5248                 break;
5249
5250               gtk_render_frame (context, cr,
5251                                 0, gtk_tree_view_get_row_y_offset (tree_view, tree, node),
5252                                 gdk_window_get_width (tree_view->priv->bin_window),
5253                                 gtk_tree_view_get_row_height (tree_view, node));
5254               break;
5255             }
5256
5257           if (highlight_y >= 0)
5258             {
5259               gtk_tree_view_draw_line (tree_view, cr,
5260                                        GTK_TREE_VIEW_FOREGROUND_LINE,
5261                                        rtl ? highlight_x + expander_cell_width : highlight_x,
5262                                        highlight_y,
5263                                        rtl ? 0 : bin_window_width,
5264                                        highlight_y);
5265             }
5266
5267           gtk_style_context_restore (context);
5268         }
5269
5270       /* draw the big row-spanning focus rectangle, if needed */
5271       if (!has_can_focus_cell && node == tree_view->priv->cursor_node &&
5272           tree_view->priv->draw_keyfocus &&
5273           gtk_widget_has_visible_focus (widget))
5274         {
5275           gint tmp_y, tmp_height;
5276           GtkStateFlags focus_rect_state = 0;
5277
5278           gtk_style_context_save (context);
5279
5280           focus_rect_state = gtk_cell_renderer_get_state (NULL, widget, flags);
5281           gtk_style_context_set_state (context, focus_rect_state);
5282
5283           if (draw_hgrid_lines)
5284             {
5285               tmp_y = gtk_tree_view_get_row_y_offset (tree_view, tree, node) + grid_line_width / 2;
5286               tmp_height = gtk_tree_view_get_row_height (tree_view, node) - grid_line_width;
5287             }
5288           else
5289             {
5290               tmp_y = gtk_tree_view_get_row_y_offset (tree_view, tree, node);
5291               tmp_height = gtk_tree_view_get_row_height (tree_view, node);
5292             }
5293
5294           gtk_render_focus (context, cr,
5295                             0, tmp_y,
5296                             gdk_window_get_width (tree_view->priv->bin_window),
5297                             tmp_height);
5298
5299           gtk_style_context_restore (context);
5300         }
5301
5302       y_offset += max_height;
5303       if (node->children)
5304         {
5305           GtkTreeIter parent = iter;
5306           gboolean has_child;
5307
5308           tree = node->children;
5309           node = _gtk_rbtree_first (tree);
5310
5311           has_child = gtk_tree_model_iter_children (tree_view->priv->model,
5312                                                     &iter,
5313                                                     &parent);
5314           depth++;
5315
5316           /* Sanity Check! */
5317           TREE_VIEW_INTERNAL_ASSERT (has_child, FALSE);
5318         }
5319       else
5320         {
5321           gboolean done = FALSE;
5322
5323           do
5324             {
5325               node = _gtk_rbtree_next (tree, node);
5326               if (node != NULL)
5327                 {
5328                   gboolean has_next = gtk_tree_model_iter_next (tree_view->priv->model, &iter);
5329                   done = TRUE;
5330
5331                   /* Sanity Check! */
5332                   TREE_VIEW_INTERNAL_ASSERT (has_next, FALSE);
5333                 }
5334               else
5335                 {
5336                   GtkTreeIter parent_iter = iter;
5337                   gboolean has_parent;
5338
5339                   node = tree->parent_node;
5340                   tree = tree->parent_tree;
5341                   if (tree == NULL)
5342                     /* we should go to done to free some memory */
5343                     goto done;
5344                   has_parent = gtk_tree_model_iter_parent (tree_view->priv->model,
5345                                                            &iter,
5346                                                            &parent_iter);
5347                   depth--;
5348
5349                   /* Sanity check */
5350                   TREE_VIEW_INTERNAL_ASSERT (has_parent, FALSE);
5351                 }
5352             }
5353           while (!done);
5354         }
5355     }
5356   while (y_offset < clip.height);
5357
5358 done:
5359   gtk_tree_view_draw_grid_lines (tree_view, cr, n_visible_columns);
5360
5361   if (tree_view->priv->rubber_band_status == RUBBER_BAND_ACTIVE)
5362     gtk_tree_view_paint_rubber_band (tree_view, cr);
5363
5364   if (drag_dest_path)
5365     gtk_tree_path_free (drag_dest_path);
5366
5367   return FALSE;
5368 }
5369
5370 static gboolean
5371 gtk_tree_view_draw (GtkWidget *widget,
5372                     cairo_t   *cr)
5373 {
5374   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
5375   GtkWidget   *button;
5376   GtkStyleContext *context;
5377
5378   context = gtk_widget_get_style_context (widget);
5379   gtk_render_background (context, cr,
5380                          0, 0,
5381                          gtk_widget_get_allocated_width (widget),
5382                          gtk_widget_get_allocated_height (widget));
5383
5384   if (gtk_cairo_should_draw_window (cr, tree_view->priv->bin_window))
5385     {
5386       GList *tmp_list;
5387
5388       cairo_save (cr);
5389
5390       gtk_cairo_transform_to_window (cr, widget, tree_view->priv->bin_window);
5391       gtk_tree_view_bin_draw (widget, cr);
5392
5393       cairo_restore (cr);
5394
5395       /* We can't just chain up to Container::draw as it will try to send the
5396        * event to the headers, so we handle propagating it to our children
5397        * (eg. widgets being edited) ourselves.
5398        */
5399       tmp_list = tree_view->priv->children;
5400       while (tmp_list)
5401         {
5402           GtkTreeViewChild *child = tmp_list->data;
5403           tmp_list = tmp_list->next;
5404
5405           gtk_container_propagate_draw (GTK_CONTAINER (tree_view), child->widget, cr);
5406         }
5407     }
5408
5409   gtk_style_context_save (context);
5410   gtk_style_context_remove_class (context, GTK_STYLE_CLASS_VIEW);
5411
5412   if (gtk_cairo_should_draw_window (cr, tree_view->priv->header_window))
5413     {
5414       GList *list;
5415
5416       for (list = tree_view->priv->columns; list != NULL; list = list->next)
5417         {
5418           GtkTreeViewColumn *column = list->data;
5419
5420           if (column == tree_view->priv->drag_column)
5421             continue;
5422
5423           if (gtk_tree_view_column_get_visible (column))
5424             {
5425               button = gtk_tree_view_column_get_button (column);
5426               gtk_container_propagate_draw (GTK_CONTAINER (tree_view),
5427                                             button, cr);
5428             }
5429         }
5430     }
5431
5432   if (tree_view->priv->drag_window &&
5433       gtk_cairo_should_draw_window (cr, tree_view->priv->drag_window))
5434     {
5435       button = gtk_tree_view_column_get_button (tree_view->priv->drag_column);
5436       gtk_container_propagate_draw (GTK_CONTAINER (tree_view),
5437                                     button, cr);
5438     }
5439
5440   gtk_style_context_restore (context);
5441
5442   return FALSE;
5443 }
5444
5445 enum
5446 {
5447   DROP_HOME,
5448   DROP_RIGHT,
5449   DROP_LEFT,
5450   DROP_END
5451 };
5452
5453 /* returns 0x1 when no column has been found -- yes it's hackish */
5454 static GtkTreeViewColumn *
5455 gtk_tree_view_get_drop_column (GtkTreeView       *tree_view,
5456                                GtkTreeViewColumn *column,
5457                                gint               drop_position)
5458 {
5459   GtkTreeViewColumn *left_column = NULL;
5460   GtkTreeViewColumn *cur_column = NULL;
5461   GList *tmp_list;
5462
5463   if (!gtk_tree_view_column_get_reorderable (column))
5464     return (GtkTreeViewColumn *)0x1;
5465
5466   switch (drop_position)
5467     {
5468       case DROP_HOME:
5469         /* find first column where we can drop */
5470         tmp_list = tree_view->priv->columns;
5471         if (column == GTK_TREE_VIEW_COLUMN (tmp_list->data))
5472           return (GtkTreeViewColumn *)0x1;
5473
5474         while (tmp_list)
5475           {
5476             g_assert (tmp_list);
5477
5478             cur_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
5479             tmp_list = tmp_list->next;
5480
5481             if (left_column &&
5482                 gtk_tree_view_column_get_visible (left_column) == FALSE)
5483               continue;
5484
5485             if (!tree_view->priv->column_drop_func)
5486               return left_column;
5487
5488             if (!tree_view->priv->column_drop_func (tree_view, column, left_column, cur_column, tree_view->priv->column_drop_func_data))
5489               {
5490                 left_column = cur_column;
5491                 continue;
5492               }
5493
5494             return left_column;
5495           }
5496
5497         if (!tree_view->priv->column_drop_func)
5498           return left_column;
5499
5500         if (tree_view->priv->column_drop_func (tree_view, column, left_column, NULL, tree_view->priv->column_drop_func_data))
5501           return left_column;
5502         else
5503           return (GtkTreeViewColumn *)0x1;
5504         break;
5505
5506       case DROP_RIGHT:
5507         /* find first column after column where we can drop */
5508         tmp_list = tree_view->priv->columns;
5509
5510         for (; tmp_list; tmp_list = tmp_list->next)
5511           if (GTK_TREE_VIEW_COLUMN (tmp_list->data) == column)
5512             break;
5513
5514         if (!tmp_list || !tmp_list->next)
5515           return (GtkTreeViewColumn *)0x1;
5516
5517         tmp_list = tmp_list->next;
5518         left_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
5519         tmp_list = tmp_list->next;
5520
5521         while (tmp_list)
5522           {
5523             g_assert (tmp_list);
5524
5525             cur_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
5526             tmp_list = tmp_list->next;
5527
5528             if (left_column &&
5529                 gtk_tree_view_column_get_visible (left_column) == FALSE)
5530               {
5531                 left_column = cur_column;
5532                 if (tmp_list)
5533                   tmp_list = tmp_list->next;
5534                 continue;
5535               }
5536
5537             if (!tree_view->priv->column_drop_func)
5538               return left_column;
5539
5540             if (!tree_view->priv->column_drop_func (tree_view, column, left_column, cur_column, tree_view->priv->column_drop_func_data))
5541               {
5542                 left_column = cur_column;
5543                 continue;
5544               }
5545
5546             return left_column;
5547           }
5548
5549         if (!tree_view->priv->column_drop_func)
5550           return left_column;
5551
5552         if (tree_view->priv->column_drop_func (tree_view, column, left_column, NULL, tree_view->priv->column_drop_func_data))
5553           return left_column;
5554         else
5555           return (GtkTreeViewColumn *)0x1;
5556         break;
5557
5558       case DROP_LEFT:
5559         /* find first column before column where we can drop */
5560         tmp_list = tree_view->priv->columns;
5561
5562         for (; tmp_list; tmp_list = tmp_list->next)
5563           if (GTK_TREE_VIEW_COLUMN (tmp_list->data) == column)
5564             break;
5565
5566         if (!tmp_list || !tmp_list->prev)
5567           return (GtkTreeViewColumn *)0x1;
5568
5569         tmp_list = tmp_list->prev;
5570         cur_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
5571         tmp_list = tmp_list->prev;
5572
5573         while (tmp_list)
5574           {
5575             g_assert (tmp_list);
5576
5577             left_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
5578
5579             if (left_column &&
5580                 gtk_tree_view_column_get_visible (left_column) == FALSE)
5581               {
5582                 /*if (!tmp_list->prev)
5583                   return (GtkTreeViewColumn *)0x1;
5584                   */
5585 /*
5586                 cur_column = GTK_TREE_VIEW_COLUMN (tmp_list->prev->data);
5587                 tmp_list = tmp_list->prev->prev;
5588                 continue;*/
5589
5590                 cur_column = left_column;
5591                 if (tmp_list)
5592                   tmp_list = tmp_list->prev;
5593                 continue;
5594               }
5595
5596             if (!tree_view->priv->column_drop_func)
5597               return left_column;
5598
5599             if (tree_view->priv->column_drop_func (tree_view, column, left_column, cur_column, tree_view->priv->column_drop_func_data))
5600               return left_column;
5601
5602             cur_column = left_column;
5603             tmp_list = tmp_list->prev;
5604           }
5605
5606         if (!tree_view->priv->column_drop_func)
5607           return NULL;
5608
5609         if (tree_view->priv->column_drop_func (tree_view, column, NULL, cur_column, tree_view->priv->column_drop_func_data))
5610           return NULL;
5611         else
5612           return (GtkTreeViewColumn *)0x1;
5613         break;
5614
5615       case DROP_END:
5616         /* same as DROP_HOME case, but doing it backwards */
5617         tmp_list = g_list_last (tree_view->priv->columns);
5618         cur_column = NULL;
5619
5620         if (column == GTK_TREE_VIEW_COLUMN (tmp_list->data))
5621           return (GtkTreeViewColumn *)0x1;
5622
5623         while (tmp_list)
5624           {
5625             g_assert (tmp_list);
5626
5627             left_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
5628
5629             if (left_column &&
5630                 gtk_tree_view_column_get_visible (left_column) == FALSE)
5631               {
5632                 cur_column = left_column;
5633                 tmp_list = tmp_list->prev;
5634               }
5635
5636             if (!tree_view->priv->column_drop_func)
5637               return left_column;
5638
5639             if (tree_view->priv->column_drop_func (tree_view, column, left_column, cur_column, tree_view->priv->column_drop_func_data))
5640               return left_column;
5641
5642             cur_column = left_column;
5643             tmp_list = tmp_list->prev;
5644           }
5645
5646         if (!tree_view->priv->column_drop_func)
5647           return NULL;
5648
5649         if (tree_view->priv->column_drop_func (tree_view, column, NULL, cur_column, tree_view->priv->column_drop_func_data))
5650           return NULL;
5651         else
5652           return (GtkTreeViewColumn *)0x1;
5653         break;
5654     }
5655
5656   return (GtkTreeViewColumn *)0x1;
5657 }
5658
5659 static gboolean
5660 gtk_tree_view_key_press (GtkWidget   *widget,
5661                          GdkEventKey *event)
5662 {
5663   GtkTreeView *tree_view = (GtkTreeView *) widget;
5664   GtkWidget   *button;
5665
5666   if (tree_view->priv->rubber_band_status)
5667     {
5668       if (event->keyval == GDK_KEY_Escape)
5669         gtk_tree_view_stop_rubber_band (tree_view);
5670
5671       return TRUE;
5672     }
5673
5674   if (tree_view->priv->in_column_drag)
5675     {
5676       if (event->keyval == GDK_KEY_Escape)
5677         {
5678           tree_view->priv->cur_reorder = NULL;
5679           gtk_tree_view_button_release_drag_column (widget, NULL);
5680         }
5681       return TRUE;
5682     }
5683
5684   if (tree_view->priv->headers_visible)
5685     {
5686       GList *focus_column;
5687       gboolean rtl;
5688
5689       rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
5690
5691       for (focus_column = tree_view->priv->columns;
5692            focus_column;
5693            focus_column = focus_column->next)
5694         {
5695           GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN (focus_column->data);
5696
5697           button = gtk_tree_view_column_get_button (column);
5698           if (gtk_widget_has_focus (button))
5699             break;
5700         }
5701
5702       if (focus_column &&
5703           (event->state & GDK_SHIFT_MASK) && (event->state & GDK_MOD1_MASK) &&
5704           (event->keyval == GDK_KEY_Left || event->keyval == GDK_KEY_KP_Left
5705            || event->keyval == GDK_KEY_Right || event->keyval == GDK_KEY_KP_Right))
5706         {
5707           GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN (focus_column->data);
5708           gint column_width;
5709
5710           if (!gtk_tree_view_column_get_resizable (column))
5711             {
5712               gtk_widget_error_bell (widget);
5713               return TRUE;
5714             }
5715
5716           column_width = gtk_tree_view_column_get_width (column);
5717
5718           if (event->keyval == (rtl ? GDK_KEY_Right : GDK_KEY_Left)
5719               || event->keyval == (rtl ? GDK_KEY_KP_Right : GDK_KEY_KP_Left))
5720             {
5721               column_width = MAX (column_width - 2, 0);
5722             }
5723           else if (event->keyval == (rtl ? GDK_KEY_Left : GDK_KEY_Right)
5724                    || event->keyval == (rtl ? GDK_KEY_KP_Left : GDK_KEY_KP_Right))
5725             {
5726               column_width = column_width + 2;
5727             }
5728
5729           gtk_tree_view_modify_column_width (tree_view, column, column_width);
5730           return TRUE;
5731         }
5732
5733       if (focus_column &&
5734           (event->state & GDK_MOD1_MASK) &&
5735           (event->keyval == GDK_KEY_Left || event->keyval == GDK_KEY_KP_Left
5736            || event->keyval == GDK_KEY_Right || event->keyval == GDK_KEY_KP_Right
5737            || event->keyval == GDK_KEY_Home || event->keyval == GDK_KEY_KP_Home
5738            || event->keyval == GDK_KEY_End || event->keyval == GDK_KEY_KP_End))
5739         {
5740           GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN (focus_column->data);
5741
5742           if (event->keyval == (rtl ? GDK_KEY_Right : GDK_KEY_Left)
5743               || event->keyval == (rtl ? GDK_KEY_KP_Right : GDK_KEY_KP_Left))
5744             {
5745               GtkTreeViewColumn *col;
5746               col = gtk_tree_view_get_drop_column (tree_view, column, DROP_LEFT);
5747               if (col != (GtkTreeViewColumn *)0x1)
5748                 gtk_tree_view_move_column_after (tree_view, column, col);
5749               else
5750                 gtk_widget_error_bell (widget);
5751             }
5752           else if (event->keyval == (rtl ? GDK_KEY_Left : GDK_KEY_Right)
5753                    || event->keyval == (rtl ? GDK_KEY_KP_Left : GDK_KEY_KP_Right))
5754             {
5755               GtkTreeViewColumn *col;
5756               col = gtk_tree_view_get_drop_column (tree_view, column, DROP_RIGHT);
5757               if (col != (GtkTreeViewColumn *)0x1)
5758                 gtk_tree_view_move_column_after (tree_view, column, col);
5759               else
5760                 gtk_widget_error_bell (widget);
5761             }
5762           else if (event->keyval == GDK_KEY_Home || event->keyval == GDK_KEY_KP_Home)
5763             {
5764               GtkTreeViewColumn *col;
5765               col = gtk_tree_view_get_drop_column (tree_view, column, DROP_HOME);
5766               if (col != (GtkTreeViewColumn *)0x1)
5767                 gtk_tree_view_move_column_after (tree_view, column, col);
5768               else
5769                 gtk_widget_error_bell (widget);
5770             }
5771           else if (event->keyval == GDK_KEY_End || event->keyval == GDK_KEY_KP_End)
5772             {
5773               GtkTreeViewColumn *col;
5774               col = gtk_tree_view_get_drop_column (tree_view, column, DROP_END);
5775               if (col != (GtkTreeViewColumn *)0x1)
5776                 gtk_tree_view_move_column_after (tree_view, column, col);
5777               else
5778                 gtk_widget_error_bell (widget);
5779             }
5780
5781           return TRUE;
5782         }
5783     }
5784
5785   /* Chain up to the parent class.  It handles the keybindings. */
5786   if (GTK_WIDGET_CLASS (gtk_tree_view_parent_class)->key_press_event (widget, event))
5787     return TRUE;
5788
5789   if (tree_view->priv->search_entry_avoid_unhandled_binding)
5790     {
5791       tree_view->priv->search_entry_avoid_unhandled_binding = FALSE;
5792       return FALSE;
5793     }
5794
5795   /* We pass the event to the search_entry.  If its text changes, then we start
5796    * the typeahead find capabilities. */
5797   if (gtk_widget_has_focus (GTK_WIDGET (tree_view))
5798       && tree_view->priv->enable_search
5799       && !tree_view->priv->search_custom_entry_set)
5800     {
5801       GdkEvent *new_event;
5802       char *old_text;
5803       const char *new_text;
5804       gboolean retval;
5805       GdkScreen *screen;
5806       gboolean text_modified;
5807       gulong popup_menu_id;
5808
5809       gtk_tree_view_ensure_interactive_directory (tree_view);
5810
5811       /* Make a copy of the current text */
5812       old_text = g_strdup (gtk_entry_get_text (GTK_ENTRY (tree_view->priv->search_entry)));
5813       new_event = gdk_event_copy ((GdkEvent *) event);
5814       g_object_unref (((GdkEventKey *) new_event)->window);
5815       ((GdkEventKey *) new_event)->window = g_object_ref (gtk_widget_get_window (tree_view->priv->search_window));
5816       gtk_widget_realize (tree_view->priv->search_window);
5817
5818       popup_menu_id = g_signal_connect (tree_view->priv->search_entry,
5819                                         "popup-menu", G_CALLBACK (gtk_true),
5820                                         NULL);
5821
5822       /* Move the entry off screen */
5823       screen = gtk_widget_get_screen (GTK_WIDGET (tree_view));
5824       gtk_window_move (GTK_WINDOW (tree_view->priv->search_window),
5825                        gdk_screen_get_width (screen) + 1,
5826                        gdk_screen_get_height (screen) + 1);
5827       gtk_widget_show (tree_view->priv->search_window);
5828
5829       /* Send the event to the window.  If the preedit_changed signal is emitted
5830        * during this event, we will set priv->imcontext_changed  */
5831       tree_view->priv->imcontext_changed = FALSE;
5832       retval = gtk_widget_event (tree_view->priv->search_window, new_event);
5833       gdk_event_free (new_event);
5834       gtk_widget_hide (tree_view->priv->search_window);
5835
5836       g_signal_handler_disconnect (tree_view->priv->search_entry,
5837                                    popup_menu_id);
5838
5839       /* We check to make sure that the entry tried to handle the text, and that
5840        * the text has changed.
5841        */
5842       new_text = gtk_entry_get_text (GTK_ENTRY (tree_view->priv->search_entry));
5843       text_modified = strcmp (old_text, new_text) != 0;
5844       g_free (old_text);
5845       if (tree_view->priv->imcontext_changed ||    /* we're in a preedit */
5846           (retval && text_modified))               /* ...or the text was modified */
5847         {
5848           if (gtk_tree_view_real_start_interactive_search (tree_view,
5849                                                            gdk_event_get_device ((GdkEvent *) event),
5850                                                            FALSE))
5851             {
5852               gtk_widget_grab_focus (GTK_WIDGET (tree_view));
5853               return TRUE;
5854             }
5855           else
5856             {
5857               gtk_entry_set_text (GTK_ENTRY (tree_view->priv->search_entry), "");
5858               return FALSE;
5859             }
5860         }
5861     }
5862
5863   return FALSE;
5864 }
5865
5866 static gboolean
5867 gtk_tree_view_key_release (GtkWidget   *widget,
5868                            GdkEventKey *event)
5869 {
5870   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
5871
5872   if (tree_view->priv->rubber_band_status)
5873     return TRUE;
5874
5875   return GTK_WIDGET_CLASS (gtk_tree_view_parent_class)->key_release_event (widget, event);
5876 }
5877
5878 /* FIXME Is this function necessary? Can I get an enter_notify event
5879  * w/o either an expose event or a mouse motion event?
5880  */
5881 static gboolean
5882 gtk_tree_view_enter_notify (GtkWidget        *widget,
5883                             GdkEventCrossing *event)
5884 {
5885   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
5886   GtkRBTree *tree;
5887   GtkRBNode *node;
5888   gint new_y;
5889
5890   /* Sanity check it */
5891   if (event->window != tree_view->priv->bin_window)
5892     return FALSE;
5893
5894   if (tree_view->priv->tree == NULL)
5895     return FALSE;
5896
5897   if (event->mode == GDK_CROSSING_GRAB ||
5898       event->mode == GDK_CROSSING_GTK_GRAB ||
5899       event->mode == GDK_CROSSING_GTK_UNGRAB ||
5900       event->mode == GDK_CROSSING_STATE_CHANGED)
5901     return TRUE;
5902
5903   /* find the node internally */
5904   new_y = TREE_WINDOW_Y_TO_RBTREE_Y(tree_view, event->y);
5905   if (new_y < 0)
5906     new_y = 0;
5907   _gtk_rbtree_find_offset (tree_view->priv->tree, new_y, &tree, &node);
5908
5909   tree_view->priv->event_last_x = event->x;
5910   tree_view->priv->event_last_y = event->y;
5911
5912   if ((tree_view->priv->button_pressed_node == NULL) ||
5913       (tree_view->priv->button_pressed_node == node))
5914     prelight_or_select (tree_view, tree, node, event->x, event->y);
5915
5916   return TRUE;
5917 }
5918
5919 static gboolean
5920 gtk_tree_view_leave_notify (GtkWidget        *widget,
5921                             GdkEventCrossing *event)
5922 {
5923   GtkTreeView *tree_view;
5924
5925   if (event->mode == GDK_CROSSING_GRAB ||
5926       event->mode == GDK_CROSSING_GTK_GRAB ||
5927       event->mode == GDK_CROSSING_GTK_UNGRAB)
5928     return TRUE;
5929
5930   tree_view = GTK_TREE_VIEW (widget);
5931
5932   if (tree_view->priv->prelight_node)
5933     _gtk_tree_view_queue_draw_node (tree_view,
5934                                    tree_view->priv->prelight_tree,
5935                                    tree_view->priv->prelight_node,
5936                                    NULL);
5937
5938   tree_view->priv->event_last_x = -10000;
5939   tree_view->priv->event_last_y = -10000;
5940
5941   prelight_or_select (tree_view,
5942                       NULL, NULL,
5943                       -1000, -1000); /* coords not possibly over an arrow */
5944
5945   return TRUE;
5946 }
5947
5948
5949 static gint
5950 gtk_tree_view_focus_out (GtkWidget     *widget,
5951                          GdkEventFocus *event)
5952 {
5953   GtkTreeView *tree_view;
5954
5955   tree_view = GTK_TREE_VIEW (widget);
5956
5957   gtk_widget_queue_draw (widget);
5958
5959   /* destroy interactive search dialog */
5960   if (tree_view->priv->search_window)
5961     gtk_tree_view_search_dialog_hide (tree_view->priv->search_window, tree_view,
5962                                       gdk_event_get_device ((GdkEvent *) event));
5963
5964   return FALSE;
5965 }
5966
5967
5968 /* Incremental Reflow
5969  */
5970
5971 static void
5972 gtk_tree_view_node_queue_redraw (GtkTreeView *tree_view,
5973                                  GtkRBTree   *tree,
5974                                  GtkRBNode   *node)
5975 {
5976   GtkAllocation allocation;
5977   gint y;
5978
5979   y = _gtk_rbtree_node_find_offset (tree, node)
5980     - gtk_adjustment_get_value (tree_view->priv->vadjustment)
5981     + gtk_tree_view_get_effective_header_height (tree_view);
5982
5983   gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
5984   gtk_widget_queue_draw_area (GTK_WIDGET (tree_view),
5985                               0, y,
5986                               allocation.width,
5987                               GTK_RBNODE_GET_HEIGHT (node));
5988 }
5989
5990 static gboolean
5991 node_is_visible (GtkTreeView *tree_view,
5992                  GtkRBTree   *tree,
5993                  GtkRBNode   *node)
5994 {
5995   int y;
5996   int height;
5997
5998   y = _gtk_rbtree_node_find_offset (tree, node);
5999   height = gtk_tree_view_get_row_height (tree_view, node);
6000
6001   if (y >= gtk_adjustment_get_value (tree_view->priv->vadjustment) &&
6002       y + height <= (gtk_adjustment_get_value (tree_view->priv->vadjustment)
6003                      + gtk_adjustment_get_page_size (tree_view->priv->vadjustment)))
6004     return TRUE;
6005
6006   return FALSE;
6007 }
6008
6009 /* Returns TRUE if it updated the size
6010  */
6011 static gboolean
6012 validate_row (GtkTreeView *tree_view,
6013               GtkRBTree   *tree,
6014               GtkRBNode   *node,
6015               GtkTreeIter *iter,
6016               GtkTreePath *path)
6017 {
6018   GtkTreeViewColumn *column;
6019   GList *list, *first_column, *last_column;
6020   gint height = 0;
6021   gint horizontal_separator;
6022   gint vertical_separator;
6023   gint depth = gtk_tree_path_get_depth (path);
6024   gboolean retval = FALSE;
6025   gboolean is_separator = FALSE;
6026   gboolean draw_vgrid_lines, draw_hgrid_lines;
6027   gint focus_pad;
6028   gint grid_line_width;
6029   gboolean wide_separators;
6030   gint separator_height;
6031   gint expander_size;
6032
6033   /* double check the row needs validating */
6034   if (! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) &&
6035       ! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
6036     return FALSE;
6037
6038   is_separator = row_is_separator (tree_view, iter, NULL);
6039
6040   gtk_widget_style_get (GTK_WIDGET (tree_view),
6041                         "focus-padding", &focus_pad,
6042                         "horizontal-separator", &horizontal_separator,
6043                         "vertical-separator", &vertical_separator,
6044                         "grid-line-width", &grid_line_width,
6045                         "wide-separators",  &wide_separators,
6046                         "separator-height", &separator_height,
6047                         NULL);
6048
6049   draw_vgrid_lines =
6050     tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_VERTICAL
6051     || tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_BOTH;
6052   draw_hgrid_lines =
6053     tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_HORIZONTAL
6054     || tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_BOTH;
6055   expander_size = gtk_tree_view_get_expander_size (tree_view);
6056
6057   for (last_column = g_list_last (tree_view->priv->columns);
6058        last_column &&
6059        !(gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (last_column->data)));
6060        last_column = last_column->prev)
6061     ;
6062
6063   for (first_column = g_list_first (tree_view->priv->columns);
6064        first_column &&
6065        !(gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (first_column->data)));
6066        first_column = first_column->next)
6067     ;
6068
6069   for (list = tree_view->priv->columns; list; list = list->next)
6070     {
6071       gint padding = 0;
6072       gint original_width;
6073       gint new_width;
6074       gint row_height;
6075
6076       column = list->data;
6077
6078       if (!gtk_tree_view_column_get_visible (column))
6079         continue;
6080
6081       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID) &&
6082           !_gtk_tree_view_column_cell_get_dirty (column))
6083         continue;
6084
6085       original_width = _gtk_tree_view_column_get_requested_width (column);
6086
6087       gtk_tree_view_column_cell_set_cell_data (column, tree_view->priv->model, iter,
6088                                                GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT),
6089                                                node->children?TRUE:FALSE);
6090       gtk_tree_view_column_cell_get_size (column,
6091                                           NULL, NULL, NULL,
6092                                           NULL, &row_height);
6093
6094       if (!is_separator)
6095         {
6096           row_height += vertical_separator;
6097           height = MAX (height, row_height);
6098           height = MAX (height, expander_size);
6099         }
6100       else
6101         {
6102           if (wide_separators)
6103             height = separator_height + 2 * focus_pad;
6104           else
6105             height = 2 + 2 * focus_pad;
6106         }
6107
6108       if (gtk_tree_view_is_expander_column (tree_view, column))
6109         {
6110           padding += horizontal_separator + (depth - 1) * tree_view->priv->level_indentation;
6111
6112           if (gtk_tree_view_draw_expanders (tree_view))
6113             padding += depth * expander_size;
6114         }
6115       else
6116         padding += horizontal_separator;
6117
6118       if (draw_vgrid_lines)
6119         {
6120           if (list->data == first_column || list->data == last_column)
6121             padding += grid_line_width / 2.0;
6122           else
6123             padding += grid_line_width;
6124         }
6125
6126       /* Update the padding for the column */
6127       _gtk_tree_view_column_push_padding (column, padding);
6128       new_width = _gtk_tree_view_column_get_requested_width (column);
6129
6130       if (new_width > original_width)
6131         retval = TRUE;
6132     }
6133
6134   if (draw_hgrid_lines)
6135     height += grid_line_width;
6136
6137   if (height != GTK_RBNODE_GET_HEIGHT (node))
6138     {
6139       retval = TRUE;
6140       _gtk_rbtree_node_set_height (tree, node, height);
6141     }
6142   _gtk_rbtree_node_mark_valid (tree, node);
6143
6144   return retval;
6145 }
6146
6147
6148 static void
6149 validate_visible_area (GtkTreeView *tree_view)
6150 {
6151   GtkAllocation allocation;
6152   GtkTreePath *path = NULL;
6153   GtkTreePath *above_path = NULL;
6154   GtkTreeIter iter;
6155   GtkRBTree *tree = NULL;
6156   GtkRBNode *node = NULL;
6157   gboolean need_redraw = FALSE;
6158   gboolean size_changed = FALSE;
6159   gint total_height;
6160   gint area_above = 0;
6161   gint area_below = 0;
6162
6163   if (tree_view->priv->tree == NULL)
6164     return;
6165
6166   if (! GTK_RBNODE_FLAG_SET (tree_view->priv->tree->root, GTK_RBNODE_DESCENDANTS_INVALID) &&
6167       tree_view->priv->scroll_to_path == NULL)
6168     return;
6169
6170   gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
6171   total_height = allocation.height - gtk_tree_view_get_effective_header_height (tree_view);
6172
6173   if (total_height == 0)
6174     return;
6175
6176   /* First, we check to see if we need to scroll anywhere
6177    */
6178   if (tree_view->priv->scroll_to_path)
6179     {
6180       path = gtk_tree_row_reference_get_path (tree_view->priv->scroll_to_path);
6181       if (path && !_gtk_tree_view_find_node (tree_view, path, &tree, &node))
6182         {
6183           /* we are going to scroll, and will update dy */
6184           gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
6185           if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) ||
6186               GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
6187             {
6188               _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
6189               if (validate_row (tree_view, tree, node, &iter, path))
6190                 size_changed = TRUE;
6191             }
6192
6193           if (tree_view->priv->scroll_to_use_align)
6194             {
6195               gint height = gtk_tree_view_get_row_height (tree_view, node);
6196               area_above = (total_height - height) *
6197                 tree_view->priv->scroll_to_row_align;
6198               area_below = total_height - area_above - height;
6199               area_above = MAX (area_above, 0);
6200               area_below = MAX (area_below, 0);
6201             }
6202           else
6203             {
6204               /* two cases:
6205                * 1) row not visible
6206                * 2) row visible
6207                */
6208               gint dy;
6209               gint height = gtk_tree_view_get_row_height (tree_view, node);
6210
6211               dy = _gtk_rbtree_node_find_offset (tree, node);
6212
6213               if (dy >= gtk_adjustment_get_value (tree_view->priv->vadjustment) &&
6214                   dy + height <= (gtk_adjustment_get_value (tree_view->priv->vadjustment)
6215                                   + gtk_adjustment_get_page_size (tree_view->priv->vadjustment)))
6216                 {
6217                   /* row visible: keep the row at the same position */
6218                   area_above = dy - gtk_adjustment_get_value (tree_view->priv->vadjustment);
6219                   area_below = (gtk_adjustment_get_value (tree_view->priv->vadjustment) +
6220                                 gtk_adjustment_get_page_size (tree_view->priv->vadjustment))
6221                                - dy - height;
6222                 }
6223               else
6224                 {
6225                   /* row not visible */
6226                   if (dy >= 0
6227                       && dy + height <= gtk_adjustment_get_page_size (tree_view->priv->vadjustment))
6228                     {
6229                       /* row at the beginning -- fixed */
6230                       area_above = dy;
6231                       area_below = gtk_adjustment_get_page_size (tree_view->priv->vadjustment)
6232                                    - area_above - height;
6233                     }
6234                   else if (dy >= (gtk_adjustment_get_upper (tree_view->priv->vadjustment) -
6235                                   gtk_adjustment_get_page_size (tree_view->priv->vadjustment)))
6236                     {
6237                       /* row at the end -- fixed */
6238                       area_above = dy - (gtk_adjustment_get_upper (tree_view->priv->vadjustment) -
6239                                    gtk_adjustment_get_page_size (tree_view->priv->vadjustment));
6240                       area_below = gtk_adjustment_get_page_size (tree_view->priv->vadjustment) -
6241                                    area_above - height;
6242
6243                       if (area_below < 0)
6244                         {
6245                           area_above = gtk_adjustment_get_page_size (tree_view->priv->vadjustment) - height;
6246                           area_below = 0;
6247                         }
6248                     }
6249                   else
6250                     {
6251                       /* row somewhere in the middle, bring it to the top
6252                        * of the view
6253                        */
6254                       area_above = 0;
6255                       area_below = total_height - height;
6256                     }
6257                 }
6258             }
6259         }
6260       else
6261         /* the scroll to isn't valid; ignore it.
6262          */
6263         {
6264           if (tree_view->priv->scroll_to_path && !path)
6265             {
6266               gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
6267               tree_view->priv->scroll_to_path = NULL;
6268             }
6269           if (path)
6270             gtk_tree_path_free (path);
6271           path = NULL;
6272         }
6273     }
6274
6275   /* We didn't have a scroll_to set, so we just handle things normally
6276    */
6277   if (path == NULL)
6278     {
6279       gint offset;
6280
6281       offset = _gtk_rbtree_find_offset (tree_view->priv->tree,
6282                                         TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, 0),
6283                                         &tree, &node);
6284       if (node == NULL)
6285         {
6286           /* In this case, nothing has been validated */
6287           path = gtk_tree_path_new_first ();
6288           _gtk_tree_view_find_node (tree_view, path, &tree, &node);
6289         }
6290       else
6291         {
6292           path = _gtk_tree_path_new_from_rbtree (tree, node);
6293           total_height += offset;
6294         }
6295
6296       gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
6297
6298       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) ||
6299           GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
6300         {
6301           _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
6302           if (validate_row (tree_view, tree, node, &iter, path))
6303             size_changed = TRUE;
6304         }
6305       area_above = 0;
6306       area_below = total_height - gtk_tree_view_get_row_height (tree_view, node);
6307     }
6308
6309   above_path = gtk_tree_path_copy (path);
6310
6311   /* if we do not validate any row above the new top_row, we will make sure
6312    * that the row immediately above top_row has been validated. (if we do not
6313    * do this, _gtk_rbtree_find_offset will find the row above top_row, because
6314    * when invalidated that row's height will be zero. and this will mess up
6315    * scrolling).
6316    */
6317   if (area_above == 0)
6318     {
6319       GtkRBTree *tmptree;
6320       GtkRBNode *tmpnode;
6321
6322       _gtk_tree_view_find_node (tree_view, above_path, &tmptree, &tmpnode);
6323       _gtk_rbtree_prev_full (tmptree, tmpnode, &tmptree, &tmpnode);
6324
6325       if (tmpnode)
6326         {
6327           GtkTreePath *tmppath;
6328           GtkTreeIter tmpiter;
6329
6330           tmppath = _gtk_tree_path_new_from_rbtree (tmptree, tmpnode);
6331           gtk_tree_model_get_iter (tree_view->priv->model, &tmpiter, tmppath);
6332
6333           if (GTK_RBNODE_FLAG_SET (tmpnode, GTK_RBNODE_INVALID) ||
6334               GTK_RBNODE_FLAG_SET (tmpnode, GTK_RBNODE_COLUMN_INVALID))
6335             {
6336               _gtk_tree_view_queue_draw_node (tree_view, tmptree, tmpnode, NULL);
6337               if (validate_row (tree_view, tmptree, tmpnode, &tmpiter, tmppath))
6338                 size_changed = TRUE;
6339             }
6340
6341           gtk_tree_path_free (tmppath);
6342         }
6343     }
6344
6345   /* Now, we walk forwards and backwards, measuring rows. Unfortunately,
6346    * backwards is much slower then forward, as there is no iter_prev function.
6347    * We go forwards first in case we run out of tree.  Then we go backwards to
6348    * fill out the top.
6349    */
6350   while (node && area_below > 0)
6351     {
6352       if (node->children)
6353         {
6354           GtkTreeIter parent = iter;
6355           gboolean has_child;
6356
6357           tree = node->children;
6358           node = _gtk_rbtree_first (tree);
6359
6360           has_child = gtk_tree_model_iter_children (tree_view->priv->model,
6361                                                     &iter,
6362                                                     &parent);
6363           TREE_VIEW_INTERNAL_ASSERT_VOID (has_child);
6364           gtk_tree_path_down (path);
6365         }
6366       else
6367         {
6368           gboolean done = FALSE;
6369           do
6370             {
6371               node = _gtk_rbtree_next (tree, node);
6372               if (node != NULL)
6373                 {
6374                   gboolean has_next = gtk_tree_model_iter_next (tree_view->priv->model, &iter);
6375                   done = TRUE;
6376                   gtk_tree_path_next (path);
6377
6378                   /* Sanity Check! */
6379                   TREE_VIEW_INTERNAL_ASSERT_VOID (has_next);
6380                 }
6381               else
6382                 {
6383                   GtkTreeIter parent_iter = iter;
6384                   gboolean has_parent;
6385
6386                   node = tree->parent_node;
6387                   tree = tree->parent_tree;
6388                   if (tree == NULL)
6389                     break;
6390                   has_parent = gtk_tree_model_iter_parent (tree_view->priv->model,
6391                                                            &iter,
6392                                                            &parent_iter);
6393                   gtk_tree_path_up (path);
6394
6395                   /* Sanity check */
6396                   TREE_VIEW_INTERNAL_ASSERT_VOID (has_parent);
6397                 }
6398             }
6399           while (!done);
6400         }
6401
6402       if (!node)
6403         break;
6404
6405       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) ||
6406           GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
6407         {
6408           _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
6409           if (validate_row (tree_view, tree, node, &iter, path))
6410               size_changed = TRUE;
6411         }
6412
6413       area_below -= gtk_tree_view_get_row_height (tree_view, node);
6414     }
6415   gtk_tree_path_free (path);
6416
6417   /* If we ran out of tree, and have extra area_below left, we need to add it
6418    * to area_above */
6419   if (area_below > 0)
6420     area_above += area_below;
6421
6422   _gtk_tree_view_find_node (tree_view, above_path, &tree, &node);
6423
6424   /* We walk backwards */
6425   while (area_above > 0)
6426     {
6427       _gtk_rbtree_prev_full (tree, node, &tree, &node);
6428
6429       /* Always find the new path in the tree.  We cannot just assume
6430        * a gtk_tree_path_prev() is enough here, as there might be children
6431        * in between this node and the previous sibling node.  If this
6432        * appears to be a performance hotspot in profiles, we can look into
6433        * intrigate logic for keeping path, node and iter in sync like
6434        * we do for forward walks.  (Which will be hard because of the lacking
6435        * iter_prev).
6436        */
6437
6438       if (node == NULL)
6439         break;
6440
6441       gtk_tree_path_free (above_path);
6442       above_path = _gtk_tree_path_new_from_rbtree (tree, node);
6443
6444       gtk_tree_model_get_iter (tree_view->priv->model, &iter, above_path);
6445
6446       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) ||
6447           GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
6448         {
6449           _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
6450           if (validate_row (tree_view, tree, node, &iter, above_path))
6451             size_changed = TRUE;
6452         }
6453       area_above -= gtk_tree_view_get_row_height (tree_view, node);
6454     }
6455
6456   /* if we scrolled to a path, we need to set the dy here,
6457    * and sync the top row accordingly
6458    */
6459   if (tree_view->priv->scroll_to_path)
6460     {
6461       gtk_tree_view_set_top_row (tree_view, above_path, -area_above);
6462       gtk_tree_view_top_row_to_dy (tree_view);
6463
6464       need_redraw = TRUE;
6465     }
6466   else if (tree_view->priv->height <= gtk_adjustment_get_page_size (tree_view->priv->vadjustment))
6467     {
6468       /* when we are not scrolling, we should never set dy to something
6469        * else than zero. we update top_row to be in sync with dy = 0.
6470        */
6471       gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment), 0);
6472       gtk_tree_view_dy_to_top_row (tree_view);
6473     }
6474   else if (gtk_adjustment_get_value (tree_view->priv->vadjustment) + gtk_adjustment_get_page_size (tree_view->priv->vadjustment) > tree_view->priv->height)
6475     {
6476       gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment), tree_view->priv->height - gtk_adjustment_get_page_size (tree_view->priv->vadjustment));
6477       gtk_tree_view_dy_to_top_row (tree_view);
6478     }
6479   else
6480     gtk_tree_view_top_row_to_dy (tree_view);
6481
6482   /* update width/height and queue a resize */
6483   if (size_changed)
6484     {
6485       GtkRequisition requisition;
6486
6487       /* We temporarily guess a size, under the assumption that it will be the
6488        * same when we get our next size_allocate.  If we don't do this, we'll be
6489        * in an inconsistent state if we call top_row_to_dy. */
6490
6491       gtk_widget_get_preferred_size (GTK_WIDGET (tree_view),
6492                                      &requisition, NULL);
6493       gtk_adjustment_set_upper (tree_view->priv->hadjustment,
6494                                 MAX (gtk_adjustment_get_upper (tree_view->priv->hadjustment), requisition.width));
6495       gtk_adjustment_set_upper (tree_view->priv->vadjustment,
6496                                 MAX (gtk_adjustment_get_upper (tree_view->priv->vadjustment), requisition.height));
6497       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
6498     }
6499
6500   if (tree_view->priv->scroll_to_path)
6501     {
6502       gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
6503       tree_view->priv->scroll_to_path = NULL;
6504     }
6505
6506   if (above_path)
6507     gtk_tree_path_free (above_path);
6508
6509   if (tree_view->priv->scroll_to_column)
6510     {
6511       tree_view->priv->scroll_to_column = NULL;
6512     }
6513   if (need_redraw)
6514     gtk_widget_queue_draw (GTK_WIDGET (tree_view));
6515 }
6516
6517 static void
6518 initialize_fixed_height_mode (GtkTreeView *tree_view)
6519 {
6520   if (!tree_view->priv->tree)
6521     return;
6522
6523   if (tree_view->priv->fixed_height < 0)
6524     {
6525       GtkTreeIter iter;
6526       GtkTreePath *path;
6527
6528       GtkRBTree *tree = NULL;
6529       GtkRBNode *node = NULL;
6530
6531       tree = tree_view->priv->tree;
6532       node = tree->root;
6533
6534       path = _gtk_tree_path_new_from_rbtree (tree, node);
6535       gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
6536
6537       validate_row (tree_view, tree, node, &iter, path);
6538
6539       gtk_tree_path_free (path);
6540
6541       tree_view->priv->fixed_height = gtk_tree_view_get_row_height (tree_view, node);
6542     }
6543
6544    _gtk_rbtree_set_fixed_height (tree_view->priv->tree,
6545                                  tree_view->priv->fixed_height, TRUE);
6546 }
6547
6548 /* Our strategy for finding nodes to validate is a little convoluted.  We find
6549  * the left-most uninvalidated node.  We then try walking right, validating
6550  * nodes.  Once we find a valid node, we repeat the previous process of finding
6551  * the first invalid node.
6552  */
6553
6554 static gboolean
6555 do_validate_rows (GtkTreeView *tree_view, gboolean queue_resize)
6556 {
6557   static gboolean prevent_recursion_hack = FALSE;
6558
6559   GtkRBTree *tree = NULL;
6560   GtkRBNode *node = NULL;
6561   gboolean validated_area = FALSE;
6562   gint retval = TRUE;
6563   GtkTreePath *path = NULL;
6564   GtkTreeIter iter;
6565   GTimer *timer;
6566   gint i = 0;
6567
6568   gint y = -1;
6569   gint prev_height = -1;
6570   gboolean fixed_height = TRUE;
6571
6572   g_assert (tree_view);
6573
6574   /* prevent infinite recursion via get_preferred_width() */
6575   if (prevent_recursion_hack)
6576     return FALSE;
6577
6578   if (tree_view->priv->tree == NULL)
6579       return FALSE;
6580
6581   if (tree_view->priv->fixed_height_mode)
6582     {
6583       if (tree_view->priv->fixed_height < 0)
6584         initialize_fixed_height_mode (tree_view);
6585
6586       return FALSE;
6587     }
6588
6589   timer = g_timer_new ();
6590   g_timer_start (timer);
6591
6592   do
6593     {
6594       gboolean changed = FALSE;
6595
6596       if (! GTK_RBNODE_FLAG_SET (tree_view->priv->tree->root, GTK_RBNODE_DESCENDANTS_INVALID))
6597         {
6598           retval = FALSE;
6599           goto done;
6600         }
6601
6602       if (path != NULL)
6603         {
6604           node = _gtk_rbtree_next (tree, node);
6605           if (node != NULL)
6606             {
6607               TREE_VIEW_INTERNAL_ASSERT (gtk_tree_model_iter_next (tree_view->priv->model, &iter), FALSE);
6608               gtk_tree_path_next (path);
6609             }
6610           else
6611             {
6612               gtk_tree_path_free (path);
6613               path = NULL;
6614             }
6615         }
6616
6617       if (path == NULL)
6618         {
6619           tree = tree_view->priv->tree;
6620           node = tree_view->priv->tree->root;
6621
6622           g_assert (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_DESCENDANTS_INVALID));
6623
6624           do
6625             {
6626               if (!_gtk_rbtree_is_nil (node->left) &&
6627                   GTK_RBNODE_FLAG_SET (node->left, GTK_RBNODE_DESCENDANTS_INVALID))
6628                 {
6629                   node = node->left;
6630                 }
6631               else if (!_gtk_rbtree_is_nil (node->right) &&
6632                        GTK_RBNODE_FLAG_SET (node->right, GTK_RBNODE_DESCENDANTS_INVALID))
6633                 {
6634                   node = node->right;
6635                 }
6636               else if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) ||
6637                        GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
6638                 {
6639                   break;
6640                 }
6641               else if (node->children != NULL)
6642                 {
6643                   tree = node->children;
6644                   node = tree->root;
6645                 }
6646               else
6647                 /* RBTree corruption!  All bad */
6648                 g_assert_not_reached ();
6649             }
6650           while (TRUE);
6651           path = _gtk_tree_path_new_from_rbtree (tree, node);
6652           gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
6653         }
6654
6655       changed = validate_row (tree_view, tree, node, &iter, path);
6656       validated_area = changed || validated_area;
6657
6658       if (changed)
6659         {
6660           gint offset = gtk_tree_view_get_row_y_offset (tree_view, tree, node);
6661
6662           if (y == -1 || y > offset)
6663             y = offset;
6664         }
6665
6666       if (!tree_view->priv->fixed_height_check)
6667         {
6668           gint height;
6669
6670           height = gtk_tree_view_get_row_height (tree_view, node);
6671           if (prev_height < 0)
6672             prev_height = height;
6673           else if (prev_height != height)
6674             fixed_height = FALSE;
6675         }
6676
6677       i++;
6678     }
6679   while (g_timer_elapsed (timer, NULL) < GTK_TREE_VIEW_TIME_MS_PER_IDLE / 1000.);
6680
6681   if (!tree_view->priv->fixed_height_check)
6682    {
6683      if (fixed_height)
6684        _gtk_rbtree_set_fixed_height (tree_view->priv->tree, prev_height, FALSE);
6685
6686      tree_view->priv->fixed_height_check = 1;
6687    }
6688
6689  done:
6690   if (validated_area)
6691     {
6692       GtkRequisition requisition;
6693
6694       /* We temporarily guess a size, under the assumption that it will be the
6695        * same when we get our next size_allocate.  If we don't do this, we'll be
6696        * in an inconsistent state when we call top_row_to_dy. */
6697
6698       /* FIXME: This is called from size_request, for some reason it is not infinitely
6699        * recursing, we cannot call gtk_widget_get_preferred_size() here because that's
6700        * not allowed (from inside ->get_preferred_width/height() implementations, one
6701        * should call the vfuncs directly). However what is desired here is the full
6702        * size including any margins and limited by any alignment (i.e. after
6703        * GtkWidget:adjust_size_request() is called).
6704        *
6705        * Currently bypassing this but the real solution is to not update the scroll adjustments
6706        * untill we've recieved an allocation (never update scroll adjustments from size-requests).
6707        */
6708       prevent_recursion_hack = TRUE;
6709       gtk_tree_view_get_preferred_width (GTK_WIDGET (tree_view), &requisition.width, NULL);
6710       gtk_tree_view_get_preferred_height (GTK_WIDGET (tree_view), &requisition.height, NULL);
6711       prevent_recursion_hack = FALSE;
6712
6713       /* If rows above the current position have changed height, this has
6714        * affected the current view and thus needs a redraw.
6715        */
6716       if (y != -1 && y < gtk_adjustment_get_value (tree_view->priv->vadjustment))
6717         gtk_widget_queue_draw (GTK_WIDGET (tree_view));
6718
6719       gtk_adjustment_set_upper (tree_view->priv->hadjustment,
6720                                 MAX (gtk_adjustment_get_upper (tree_view->priv->hadjustment), requisition.width));
6721       gtk_adjustment_set_upper (tree_view->priv->vadjustment,
6722                                 MAX (gtk_adjustment_get_upper (tree_view->priv->vadjustment), requisition.height));
6723
6724       if (queue_resize)
6725         gtk_widget_queue_resize_no_redraw (GTK_WIDGET (tree_view));
6726     }
6727
6728   if (path) gtk_tree_path_free (path);
6729   g_timer_destroy (timer);
6730
6731   return retval;
6732 }
6733
6734 static gboolean
6735 validate_rows (GtkTreeView *tree_view)
6736 {
6737   gboolean retval;
6738
6739   retval = do_validate_rows (tree_view, TRUE);
6740
6741   if (! retval && tree_view->priv->validate_rows_timer)
6742     {
6743       g_source_remove (tree_view->priv->validate_rows_timer);
6744       tree_view->priv->validate_rows_timer = 0;
6745     }
6746
6747   return retval;
6748 }
6749
6750 static gboolean
6751 validate_rows_handler (GtkTreeView *tree_view)
6752 {
6753   gboolean retval;
6754
6755   retval = do_validate_rows (tree_view, TRUE);
6756   if (! retval && tree_view->priv->validate_rows_timer)
6757     {
6758       g_source_remove (tree_view->priv->validate_rows_timer);
6759       tree_view->priv->validate_rows_timer = 0;
6760     }
6761
6762   return retval;
6763 }
6764
6765 static gboolean
6766 do_presize_handler (GtkTreeView *tree_view)
6767 {
6768   if (tree_view->priv->mark_rows_col_dirty)
6769     {
6770       if (tree_view->priv->tree)
6771         _gtk_rbtree_column_invalid (tree_view->priv->tree);
6772       tree_view->priv->mark_rows_col_dirty = FALSE;
6773     }
6774   validate_visible_area (tree_view);
6775   tree_view->priv->presize_handler_timer = 0;
6776
6777   if (tree_view->priv->fixed_height_mode)
6778     {
6779       GtkRequisition requisition;
6780
6781       gtk_widget_get_preferred_size (GTK_WIDGET (tree_view),
6782                                      &requisition, NULL);
6783
6784       gtk_adjustment_set_upper (tree_view->priv->hadjustment,
6785                                 MAX (gtk_adjustment_get_upper (tree_view->priv->hadjustment), requisition.width));
6786       gtk_adjustment_set_upper (tree_view->priv->vadjustment,
6787                                 MAX (gtk_adjustment_get_upper (tree_view->priv->vadjustment), requisition.height));
6788       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
6789     }
6790
6791   return FALSE;
6792 }
6793
6794 static gboolean
6795 presize_handler_callback (gpointer data)
6796 {
6797   do_presize_handler (GTK_TREE_VIEW (data));
6798
6799   return FALSE;
6800 }
6801
6802 static void
6803 install_presize_handler (GtkTreeView *tree_view)
6804 {
6805   if (! gtk_widget_get_realized (GTK_WIDGET (tree_view)))
6806     return;
6807
6808   if (! tree_view->priv->presize_handler_timer)
6809     {
6810       tree_view->priv->presize_handler_timer =
6811         gdk_threads_add_idle_full (GTK_PRIORITY_RESIZE - 2, presize_handler_callback, tree_view, NULL);
6812     }
6813   if (! tree_view->priv->validate_rows_timer)
6814     {
6815       tree_view->priv->validate_rows_timer =
6816         gdk_threads_add_idle_full (GTK_TREE_VIEW_PRIORITY_VALIDATE, (GSourceFunc) validate_rows_handler, tree_view, NULL);
6817     }
6818 }
6819
6820 static gboolean
6821 scroll_sync_handler (GtkTreeView *tree_view)
6822 {
6823   if (tree_view->priv->height <= gtk_adjustment_get_page_size (tree_view->priv->vadjustment))
6824     gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment), 0);
6825   else if (gtk_tree_row_reference_valid (tree_view->priv->top_row))
6826     gtk_tree_view_top_row_to_dy (tree_view);
6827   else
6828     gtk_tree_view_dy_to_top_row (tree_view);
6829
6830   tree_view->priv->scroll_sync_timer = 0;
6831
6832   return FALSE;
6833 }
6834
6835 static void
6836 install_scroll_sync_handler (GtkTreeView *tree_view)
6837 {
6838   if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
6839     return;
6840
6841   if (!tree_view->priv->scroll_sync_timer)
6842     {
6843       tree_view->priv->scroll_sync_timer =
6844         gdk_threads_add_idle_full (GTK_TREE_VIEW_PRIORITY_SCROLL_SYNC, (GSourceFunc) scroll_sync_handler, tree_view, NULL);
6845     }
6846 }
6847
6848 static void
6849 gtk_tree_view_set_top_row (GtkTreeView *tree_view,
6850                            GtkTreePath *path,
6851                            gint         offset)
6852 {
6853   gtk_tree_row_reference_free (tree_view->priv->top_row);
6854
6855   if (!path)
6856     {
6857       tree_view->priv->top_row = NULL;
6858       tree_view->priv->top_row_dy = 0;
6859     }
6860   else
6861     {
6862       tree_view->priv->top_row = gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view), tree_view->priv->model, path);
6863       tree_view->priv->top_row_dy = offset;
6864     }
6865 }
6866
6867 /* Always call this iff dy is in the visible range.  If the tree is empty, then
6868  * it's set to be NULL, and top_row_dy is 0;
6869  */
6870 static void
6871 gtk_tree_view_dy_to_top_row (GtkTreeView *tree_view)
6872 {
6873   gint offset;
6874   GtkTreePath *path;
6875   GtkRBTree *tree;
6876   GtkRBNode *node;
6877
6878   if (tree_view->priv->tree == NULL)
6879     {
6880       gtk_tree_view_set_top_row (tree_view, NULL, 0);
6881     }
6882   else
6883     {
6884       offset = _gtk_rbtree_find_offset (tree_view->priv->tree,
6885                                         tree_view->priv->dy,
6886                                         &tree, &node);
6887
6888       if (tree == NULL)
6889         {
6890           gtk_tree_view_set_top_row (tree_view, NULL, 0);
6891         }
6892       else
6893         {
6894           path = _gtk_tree_path_new_from_rbtree (tree, node);
6895           gtk_tree_view_set_top_row (tree_view, path, offset);
6896           gtk_tree_path_free (path);
6897         }
6898     }
6899 }
6900
6901 static void
6902 gtk_tree_view_top_row_to_dy (GtkTreeView *tree_view)
6903 {
6904   GtkTreePath *path;
6905   GtkRBTree *tree;
6906   GtkRBNode *node;
6907   int new_dy;
6908
6909   /* Avoid recursive calls */
6910   if (tree_view->priv->in_top_row_to_dy)
6911     return;
6912
6913   if (tree_view->priv->top_row)
6914     path = gtk_tree_row_reference_get_path (tree_view->priv->top_row);
6915   else
6916     path = NULL;
6917
6918   if (!path)
6919     tree = NULL;
6920   else
6921     _gtk_tree_view_find_node (tree_view, path, &tree, &node);
6922
6923   if (path)
6924     gtk_tree_path_free (path);
6925
6926   if (tree == NULL)
6927     {
6928       /* keep dy and set new toprow */
6929       gtk_tree_row_reference_free (tree_view->priv->top_row);
6930       tree_view->priv->top_row = NULL;
6931       tree_view->priv->top_row_dy = 0;
6932       /* DO NOT install the idle handler */
6933       gtk_tree_view_dy_to_top_row (tree_view);
6934       return;
6935     }
6936
6937   if (gtk_tree_view_get_row_height (tree_view, node)
6938       < tree_view->priv->top_row_dy)
6939     {
6940       /* new top row -- do NOT install the idle handler */
6941       gtk_tree_view_dy_to_top_row (tree_view);
6942       return;
6943     }
6944
6945   new_dy = _gtk_rbtree_node_find_offset (tree, node);
6946   new_dy += tree_view->priv->top_row_dy;
6947
6948   if (new_dy + gtk_adjustment_get_page_size (tree_view->priv->vadjustment) > tree_view->priv->height)
6949     new_dy = tree_view->priv->height - gtk_adjustment_get_page_size (tree_view->priv->vadjustment);
6950
6951   new_dy = MAX (0, new_dy);
6952
6953   tree_view->priv->in_top_row_to_dy = TRUE;
6954   gtk_adjustment_set_value (tree_view->priv->vadjustment, (gdouble)new_dy);
6955   tree_view->priv->in_top_row_to_dy = FALSE;
6956 }
6957
6958
6959 void
6960 _gtk_tree_view_install_mark_rows_col_dirty (GtkTreeView *tree_view,
6961                                             gboolean     install_handler)
6962 {
6963   tree_view->priv->mark_rows_col_dirty = TRUE;
6964
6965   if (install_handler)
6966     install_presize_handler (tree_view);
6967 }
6968
6969 /*
6970  * This function works synchronously (due to the while (validate_rows...)
6971  * loop).
6972  *
6973  * There was a check for column_type != GTK_TREE_VIEW_COLUMN_AUTOSIZE
6974  * here. You now need to check that yourself.
6975  */
6976 void
6977 _gtk_tree_view_column_autosize (GtkTreeView *tree_view,
6978                                 GtkTreeViewColumn *column)
6979 {
6980   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
6981   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (column));
6982
6983   _gtk_tree_view_column_cell_set_dirty (column, FALSE);
6984
6985   do_presize_handler (tree_view);
6986   while (validate_rows (tree_view));
6987
6988   gtk_widget_queue_resize (GTK_WIDGET (tree_view));
6989 }
6990
6991 /* Drag-and-drop */
6992
6993 static void
6994 set_source_row (GdkDragContext *context,
6995                 GtkTreeModel   *model,
6996                 GtkTreePath    *source_row)
6997 {
6998   g_object_set_data_full (G_OBJECT (context),
6999                           I_("gtk-tree-view-source-row"),
7000                           source_row ? gtk_tree_row_reference_new (model, source_row) : NULL,
7001                           (GDestroyNotify) (source_row ? gtk_tree_row_reference_free : NULL));
7002 }
7003
7004 static GtkTreePath*
7005 get_source_row (GdkDragContext *context)
7006 {
7007   GtkTreeRowReference *ref =
7008     g_object_get_data (G_OBJECT (context), "gtk-tree-view-source-row");
7009
7010   if (ref)
7011     return gtk_tree_row_reference_get_path (ref);
7012   else
7013     return NULL;
7014 }
7015
7016 typedef struct
7017 {
7018   GtkTreeRowReference *dest_row;
7019   guint                path_down_mode   : 1;
7020   guint                empty_view_drop  : 1;
7021   guint                drop_append_mode : 1;
7022 }
7023 DestRow;
7024
7025 static void
7026 dest_row_free (gpointer data)
7027 {
7028   DestRow *dr = (DestRow *)data;
7029
7030   gtk_tree_row_reference_free (dr->dest_row);
7031   g_slice_free (DestRow, dr);
7032 }
7033
7034 static void
7035 set_dest_row (GdkDragContext *context,
7036               GtkTreeModel   *model,
7037               GtkTreePath    *dest_row,
7038               gboolean        path_down_mode,
7039               gboolean        empty_view_drop,
7040               gboolean        drop_append_mode)
7041 {
7042   DestRow *dr;
7043
7044   if (!dest_row)
7045     {
7046       g_object_set_data_full (G_OBJECT (context), I_("gtk-tree-view-dest-row"),
7047                               NULL, NULL);
7048       return;
7049     }
7050
7051   dr = g_slice_new (DestRow);
7052
7053   dr->dest_row = gtk_tree_row_reference_new (model, dest_row);
7054   dr->path_down_mode = path_down_mode != FALSE;
7055   dr->empty_view_drop = empty_view_drop != FALSE;
7056   dr->drop_append_mode = drop_append_mode != FALSE;
7057
7058   g_object_set_data_full (G_OBJECT (context), I_("gtk-tree-view-dest-row"),
7059                           dr, (GDestroyNotify) dest_row_free);
7060 }
7061
7062 static GtkTreePath*
7063 get_dest_row (GdkDragContext *context,
7064               gboolean       *path_down_mode)
7065 {
7066   DestRow *dr =
7067     g_object_get_data (G_OBJECT (context), "gtk-tree-view-dest-row");
7068
7069   if (dr)
7070     {
7071       GtkTreePath *path = NULL;
7072
7073       if (path_down_mode)
7074         *path_down_mode = dr->path_down_mode;
7075
7076       if (dr->dest_row)
7077         path = gtk_tree_row_reference_get_path (dr->dest_row);
7078       else if (dr->empty_view_drop)
7079         path = gtk_tree_path_new_from_indices (0, -1);
7080       else
7081         path = NULL;
7082
7083       if (path && dr->drop_append_mode)
7084         gtk_tree_path_next (path);
7085
7086       return path;
7087     }
7088   else
7089     return NULL;
7090 }
7091
7092 /* Get/set whether drag_motion requested the drag data and
7093  * drag_data_received should thus not actually insert the data,
7094  * since the data doesn't result from a drop.
7095  */
7096 static void
7097 set_status_pending (GdkDragContext *context,
7098                     GdkDragAction   suggested_action)
7099 {
7100   g_object_set_data (G_OBJECT (context),
7101                      I_("gtk-tree-view-status-pending"),
7102                      GINT_TO_POINTER (suggested_action));
7103 }
7104
7105 static GdkDragAction
7106 get_status_pending (GdkDragContext *context)
7107 {
7108   return GPOINTER_TO_INT (g_object_get_data (G_OBJECT (context),
7109                                              "gtk-tree-view-status-pending"));
7110 }
7111
7112 static TreeViewDragInfo*
7113 get_info (GtkTreeView *tree_view)
7114 {
7115   return g_object_get_data (G_OBJECT (tree_view), "gtk-tree-view-drag-info");
7116 }
7117
7118 static void
7119 destroy_info (TreeViewDragInfo *di)
7120 {
7121   g_slice_free (TreeViewDragInfo, di);
7122 }
7123
7124 static TreeViewDragInfo*
7125 ensure_info (GtkTreeView *tree_view)
7126 {
7127   TreeViewDragInfo *di;
7128
7129   di = get_info (tree_view);
7130
7131   if (di == NULL)
7132     {
7133       di = g_slice_new0 (TreeViewDragInfo);
7134
7135       g_object_set_data_full (G_OBJECT (tree_view),
7136                               I_("gtk-tree-view-drag-info"),
7137                               di,
7138                               (GDestroyNotify) destroy_info);
7139     }
7140
7141   return di;
7142 }
7143
7144 static void
7145 remove_info (GtkTreeView *tree_view)
7146 {
7147   g_object_set_data (G_OBJECT (tree_view), I_("gtk-tree-view-drag-info"), NULL);
7148 }
7149
7150 #if 0
7151 static gint
7152 drag_scan_timeout (gpointer data)
7153 {
7154   GtkTreeView *tree_view;
7155   gint x, y;
7156   GdkModifierType state;
7157   GtkTreePath *path = NULL;
7158   GtkTreeViewColumn *column = NULL;
7159   GdkRectangle visible_rect;
7160
7161   gdk_threads_enter ();
7162
7163   tree_view = GTK_TREE_VIEW (data);
7164
7165   gdk_window_get_device_position (tree_view->priv->bin_window,
7166                                   gdk_device_manager_get_client_pointer (
7167                                     gdk_display_get_device_manager (
7168                                       gtk_widget_get_display (GTK_WIDGET (tree_view)))),
7169                                   &x, &y, &state);
7170
7171   gtk_tree_view_get_visible_rect (tree_view, &visible_rect);
7172
7173   /* See if we are near the edge. */
7174   if ((x - visible_rect.x) < SCROLL_EDGE_SIZE ||
7175       (visible_rect.x + visible_rect.width - x) < SCROLL_EDGE_SIZE ||
7176       (y - visible_rect.y) < SCROLL_EDGE_SIZE ||
7177       (visible_rect.y + visible_rect.height - y) < SCROLL_EDGE_SIZE)
7178     {
7179       gtk_tree_view_get_path_at_pos (tree_view,
7180                                      tree_view->priv->bin_window,
7181                                      x, y,
7182                                      &path,
7183                                      &column,
7184                                      NULL,
7185                                      NULL);
7186
7187       if (path != NULL)
7188         {
7189           gtk_tree_view_scroll_to_cell (tree_view,
7190                                         path,
7191                                         column,
7192                                         TRUE,
7193                                         0.5, 0.5);
7194
7195           gtk_tree_path_free (path);
7196         }
7197     }
7198
7199   gdk_threads_leave ();
7200
7201   return TRUE;
7202 }
7203 #endif /* 0 */
7204
7205 static void
7206 add_scroll_timeout (GtkTreeView *tree_view)
7207 {
7208   if (tree_view->priv->scroll_timeout == 0)
7209     {
7210       tree_view->priv->scroll_timeout =
7211         gdk_threads_add_timeout (150, scroll_row_timeout, tree_view);
7212     }
7213 }
7214
7215 static void
7216 remove_scroll_timeout (GtkTreeView *tree_view)
7217 {
7218   if (tree_view->priv->scroll_timeout != 0)
7219     {
7220       g_source_remove (tree_view->priv->scroll_timeout);
7221       tree_view->priv->scroll_timeout = 0;
7222     }
7223 }
7224
7225 static gboolean
7226 check_model_dnd (GtkTreeModel *model,
7227                  GType         required_iface,
7228                  const gchar  *signal)
7229 {
7230   if (model == NULL || !G_TYPE_CHECK_INSTANCE_TYPE ((model), required_iface))
7231     {
7232       g_warning ("You must override the default '%s' handler "
7233                  "on GtkTreeView when using models that don't support "
7234                  "the %s interface and enabling drag-and-drop. The simplest way to do this "
7235                  "is to connect to '%s' and call "
7236                  "g_signal_stop_emission_by_name() in your signal handler to prevent "
7237                  "the default handler from running. Look at the source code "
7238                  "for the default handler in gtktreeview.c to get an idea what "
7239                  "your handler should do. (gtktreeview.c is in the GTK source "
7240                  "code.) If you're using GTK from a language other than C, "
7241                  "there may be a more natural way to override default handlers, e.g. via derivation.",
7242                  signal, g_type_name (required_iface), signal);
7243       return FALSE;
7244     }
7245   else
7246     return TRUE;
7247 }
7248
7249 static void
7250 remove_open_timeout (GtkTreeView *tree_view)
7251 {
7252   if (tree_view->priv->open_dest_timeout != 0)
7253     {
7254       g_source_remove (tree_view->priv->open_dest_timeout);
7255       tree_view->priv->open_dest_timeout = 0;
7256     }
7257 }
7258
7259
7260 static gint
7261 open_row_timeout (gpointer data)
7262 {
7263   GtkTreeView *tree_view = data;
7264   GtkTreePath *dest_path = NULL;
7265   GtkTreeViewDropPosition pos;
7266   gboolean result = FALSE;
7267
7268   gtk_tree_view_get_drag_dest_row (tree_view,
7269                                    &dest_path,
7270                                    &pos);
7271
7272   if (dest_path &&
7273       (pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER ||
7274        pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE))
7275     {
7276       gtk_tree_view_expand_row (tree_view, dest_path, FALSE);
7277       tree_view->priv->open_dest_timeout = 0;
7278
7279       gtk_tree_path_free (dest_path);
7280     }
7281   else
7282     {
7283       if (dest_path)
7284         gtk_tree_path_free (dest_path);
7285
7286       result = TRUE;
7287     }
7288
7289   return result;
7290 }
7291
7292 static gboolean
7293 scroll_row_timeout (gpointer data)
7294 {
7295   GtkTreeView *tree_view = data;
7296
7297   gtk_tree_view_vertical_autoscroll (tree_view);
7298
7299   if (tree_view->priv->rubber_band_status == RUBBER_BAND_ACTIVE)
7300     gtk_tree_view_update_rubber_band (tree_view);
7301
7302   return TRUE;
7303 }
7304
7305 /* Returns TRUE if event should not be propagated to parent widgets */
7306 static gboolean
7307 set_destination_row (GtkTreeView    *tree_view,
7308                      GdkDragContext *context,
7309                      /* coordinates relative to the widget */
7310                      gint            x,
7311                      gint            y,
7312                      GdkDragAction  *suggested_action,
7313                      GdkAtom        *target)
7314 {
7315   GtkTreePath *path = NULL;
7316   GtkTreeViewDropPosition pos;
7317   GtkTreeViewDropPosition old_pos;
7318   TreeViewDragInfo *di;
7319   GtkWidget *widget;
7320   GtkTreePath *old_dest_path = NULL;
7321   gboolean can_drop = FALSE;
7322
7323   *suggested_action = 0;
7324   *target = GDK_NONE;
7325
7326   widget = GTK_WIDGET (tree_view);
7327
7328   di = get_info (tree_view);
7329
7330   if (di == NULL || y - gtk_tree_view_get_effective_header_height (tree_view) < 0)
7331     {
7332       /* someone unset us as a drag dest, note that if
7333        * we return FALSE drag_leave isn't called
7334        */
7335
7336       gtk_tree_view_set_drag_dest_row (tree_view,
7337                                        NULL,
7338                                        GTK_TREE_VIEW_DROP_BEFORE);
7339
7340       remove_scroll_timeout (GTK_TREE_VIEW (widget));
7341       remove_open_timeout (GTK_TREE_VIEW (widget));
7342
7343       return FALSE; /* no longer a drop site */
7344     }
7345
7346   *target = gtk_drag_dest_find_target (widget, context,
7347                                        gtk_drag_dest_get_target_list (widget));
7348   if (*target == GDK_NONE)
7349     {
7350       return FALSE;
7351     }
7352
7353   if (!gtk_tree_view_get_dest_row_at_pos (tree_view,
7354                                           x, y,
7355                                           &path,
7356                                           &pos))
7357     {
7358       gint n_children;
7359       GtkTreeModel *model;
7360
7361       remove_open_timeout (tree_view);
7362
7363       /* the row got dropped on empty space, let's setup a special case
7364        */
7365
7366       if (path)
7367         gtk_tree_path_free (path);
7368
7369       model = gtk_tree_view_get_model (tree_view);
7370
7371       n_children = gtk_tree_model_iter_n_children (model, NULL);
7372       if (n_children)
7373         {
7374           pos = GTK_TREE_VIEW_DROP_AFTER;
7375           path = gtk_tree_path_new_from_indices (n_children - 1, -1);
7376         }
7377       else
7378         {
7379           pos = GTK_TREE_VIEW_DROP_BEFORE;
7380           path = gtk_tree_path_new_from_indices (0, -1);
7381         }
7382
7383       can_drop = TRUE;
7384
7385       goto out;
7386     }
7387
7388   g_assert (path);
7389
7390   /* If we left the current row's "open" zone, unset the timeout for
7391    * opening the row
7392    */
7393   gtk_tree_view_get_drag_dest_row (tree_view,
7394                                    &old_dest_path,
7395                                    &old_pos);
7396
7397   if (old_dest_path &&
7398       (gtk_tree_path_compare (path, old_dest_path) != 0 ||
7399        !(pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER ||
7400          pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE)))
7401     remove_open_timeout (tree_view);
7402
7403   if (old_dest_path)
7404     gtk_tree_path_free (old_dest_path);
7405
7406   if (TRUE /* FIXME if the location droppable predicate */)
7407     {
7408       can_drop = TRUE;
7409     }
7410
7411 out:
7412   if (can_drop)
7413     {
7414       GtkWidget *source_widget;
7415
7416       *suggested_action = gdk_drag_context_get_suggested_action (context);
7417       source_widget = gtk_drag_get_source_widget (context);
7418
7419       if (source_widget == widget)
7420         {
7421           /* Default to MOVE, unless the user has
7422            * pressed ctrl or shift to affect available actions
7423            */
7424           if ((gdk_drag_context_get_actions (context) & GDK_ACTION_MOVE) != 0)
7425             *suggested_action = GDK_ACTION_MOVE;
7426         }
7427
7428       gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
7429                                        path, pos);
7430     }
7431   else
7432     {
7433       /* can't drop here */
7434       remove_open_timeout (tree_view);
7435
7436       gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
7437                                        NULL,
7438                                        GTK_TREE_VIEW_DROP_BEFORE);
7439     }
7440
7441   if (path)
7442     gtk_tree_path_free (path);
7443
7444   return TRUE;
7445 }
7446
7447 static GtkTreePath*
7448 get_logical_dest_row (GtkTreeView *tree_view,
7449                       gboolean    *path_down_mode,
7450                       gboolean    *drop_append_mode)
7451 {
7452   /* adjust path to point to the row the drop goes in front of */
7453   GtkTreePath *path = NULL;
7454   GtkTreeViewDropPosition pos;
7455
7456   g_return_val_if_fail (path_down_mode != NULL, NULL);
7457   g_return_val_if_fail (drop_append_mode != NULL, NULL);
7458
7459   *path_down_mode = FALSE;
7460   *drop_append_mode = 0;
7461
7462   gtk_tree_view_get_drag_dest_row (tree_view, &path, &pos);
7463
7464   if (path == NULL)
7465     return NULL;
7466
7467   if (pos == GTK_TREE_VIEW_DROP_BEFORE)
7468     ; /* do nothing */
7469   else if (pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE ||
7470            pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER)
7471     *path_down_mode = TRUE;
7472   else
7473     {
7474       GtkTreeIter iter;
7475       GtkTreeModel *model = gtk_tree_view_get_model (tree_view);
7476
7477       g_assert (pos == GTK_TREE_VIEW_DROP_AFTER);
7478
7479       if (!gtk_tree_model_get_iter (model, &iter, path) ||
7480           !gtk_tree_model_iter_next (model, &iter))
7481         *drop_append_mode = 1;
7482       else
7483         {
7484           *drop_append_mode = 0;
7485           gtk_tree_path_next (path);
7486         }
7487     }
7488
7489   return path;
7490 }
7491
7492 static gboolean
7493 gtk_tree_view_maybe_begin_dragging_row (GtkTreeView      *tree_view,
7494                                         GdkEventMotion   *event)
7495 {
7496   GtkWidget *widget = GTK_WIDGET (tree_view);
7497   GdkDragContext *context;
7498   TreeViewDragInfo *di;
7499   GtkTreePath *path = NULL;
7500   gint button;
7501   gint cell_x, cell_y;
7502   GtkTreeModel *model;
7503   gboolean retval = FALSE;
7504
7505   di = get_info (tree_view);
7506
7507   if (di == NULL || !di->source_set)
7508     goto out;
7509
7510   if (tree_view->priv->pressed_button < 0)
7511     goto out;
7512
7513   if (!gtk_drag_check_threshold (widget,
7514                                  tree_view->priv->press_start_x,
7515                                  tree_view->priv->press_start_y,
7516                                  event->x, event->y))
7517     goto out;
7518
7519   model = gtk_tree_view_get_model (tree_view);
7520
7521   if (model == NULL)
7522     goto out;
7523
7524   button = tree_view->priv->pressed_button;
7525   tree_view->priv->pressed_button = -1;
7526
7527   gtk_tree_view_get_path_at_pos (tree_view,
7528                                  tree_view->priv->press_start_x,
7529                                  tree_view->priv->press_start_y,
7530                                  &path,
7531                                  NULL,
7532                                  &cell_x,
7533                                  &cell_y);
7534
7535   if (path == NULL)
7536     goto out;
7537
7538   if (!GTK_IS_TREE_DRAG_SOURCE (model) ||
7539       !gtk_tree_drag_source_row_draggable (GTK_TREE_DRAG_SOURCE (model),
7540                                            path))
7541     goto out;
7542
7543   if (!(GDK_BUTTON1_MASK << (button - 1) & di->start_button_mask))
7544     goto out;
7545
7546   /* Now we can begin the drag */
7547
7548   retval = TRUE;
7549
7550   context = gtk_drag_begin (widget,
7551                             gtk_drag_source_get_target_list (widget),
7552                             di->source_actions,
7553                             button,
7554                             (GdkEvent*)event);
7555
7556   set_source_row (context, model, path);
7557
7558  out:
7559   if (path)
7560     gtk_tree_path_free (path);
7561
7562   return retval;
7563 }
7564
7565
7566 static void
7567 gtk_tree_view_drag_begin (GtkWidget      *widget,
7568                           GdkDragContext *context)
7569 {
7570   GtkTreeView *tree_view;
7571   GtkTreePath *path = NULL;
7572   gint cell_x, cell_y;
7573   cairo_surface_t *row_pix;
7574   TreeViewDragInfo *di;
7575
7576   tree_view = GTK_TREE_VIEW (widget);
7577
7578   /* if the user uses a custom DND source impl, we don't set the icon here */
7579   di = get_info (tree_view);
7580
7581   if (di == NULL || !di->source_set)
7582     return;
7583
7584   gtk_tree_view_get_path_at_pos (tree_view,
7585                                  tree_view->priv->press_start_x,
7586                                  tree_view->priv->press_start_y,
7587                                  &path,
7588                                  NULL,
7589                                  &cell_x,
7590                                  &cell_y);
7591
7592   /* If path is NULL, there's nothing we can drag.  For now, we silently
7593    * bail out.  Actually, dragging should not be possible from an empty
7594    * tree view, but there's no way we can cancel that from here.
7595    * Automatically unsetting the tree view as drag source for empty models
7596    * is something that would likely break other people's code ...
7597    */
7598   if (!path)
7599     return;
7600
7601   row_pix = gtk_tree_view_create_row_drag_icon (tree_view,
7602                                                 path);
7603   cairo_surface_set_device_offset (row_pix,
7604                                    /* the + 1 is for the black border in the icon */
7605                                    - (tree_view->priv->press_start_x + 1),
7606                                    - (cell_y + 1));
7607
7608   gtk_drag_set_icon_surface (context, row_pix);
7609
7610   cairo_surface_destroy (row_pix);
7611   gtk_tree_path_free (path);
7612 }
7613
7614 static void
7615 gtk_tree_view_drag_end (GtkWidget      *widget,
7616                         GdkDragContext *context)
7617 {
7618   /* do nothing */
7619 }
7620
7621 /* Default signal implementations for the drag signals */
7622 static void
7623 gtk_tree_view_drag_data_get (GtkWidget        *widget,
7624                              GdkDragContext   *context,
7625                              GtkSelectionData *selection_data,
7626                              guint             info,
7627                              guint             time)
7628 {
7629   GtkTreeView *tree_view;
7630   GtkTreeModel *model;
7631   TreeViewDragInfo *di;
7632   GtkTreePath *source_row;
7633
7634   tree_view = GTK_TREE_VIEW (widget);
7635
7636   model = gtk_tree_view_get_model (tree_view);
7637
7638   if (model == NULL)
7639     return;
7640
7641   di = get_info (GTK_TREE_VIEW (widget));
7642
7643   if (di == NULL)
7644     return;
7645
7646   source_row = get_source_row (context);
7647
7648   if (source_row == NULL)
7649     return;
7650
7651   /* We can implement the GTK_TREE_MODEL_ROW target generically for
7652    * any model; for DragSource models there are some other targets
7653    * we also support.
7654    */
7655
7656   if (GTK_IS_TREE_DRAG_SOURCE (model) &&
7657       gtk_tree_drag_source_drag_data_get (GTK_TREE_DRAG_SOURCE (model),
7658                                           source_row,
7659                                           selection_data))
7660     goto done;
7661
7662   /* If drag_data_get does nothing, try providing row data. */
7663   if (gtk_selection_data_get_target (selection_data) == gdk_atom_intern_static_string ("GTK_TREE_MODEL_ROW"))
7664     {
7665       gtk_tree_set_row_drag_data (selection_data,
7666                                   model,
7667                                   source_row);
7668     }
7669
7670  done:
7671   gtk_tree_path_free (source_row);
7672 }
7673
7674
7675 static void
7676 gtk_tree_view_drag_data_delete (GtkWidget      *widget,
7677                                 GdkDragContext *context)
7678 {
7679   TreeViewDragInfo *di;
7680   GtkTreeModel *model;
7681   GtkTreeView *tree_view;
7682   GtkTreePath *source_row;
7683
7684   tree_view = GTK_TREE_VIEW (widget);
7685   model = gtk_tree_view_get_model (tree_view);
7686
7687   if (!check_model_dnd (model, GTK_TYPE_TREE_DRAG_SOURCE, "drag_data_delete"))
7688     return;
7689
7690   di = get_info (tree_view);
7691
7692   if (di == NULL)
7693     return;
7694
7695   source_row = get_source_row (context);
7696
7697   if (source_row == NULL)
7698     return;
7699
7700   gtk_tree_drag_source_drag_data_delete (GTK_TREE_DRAG_SOURCE (model),
7701                                          source_row);
7702
7703   gtk_tree_path_free (source_row);
7704
7705   set_source_row (context, NULL, NULL);
7706 }
7707
7708 static void
7709 gtk_tree_view_drag_leave (GtkWidget      *widget,
7710                           GdkDragContext *context,
7711                           guint             time)
7712 {
7713   /* unset any highlight row */
7714   gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
7715                                    NULL,
7716                                    GTK_TREE_VIEW_DROP_BEFORE);
7717
7718   remove_scroll_timeout (GTK_TREE_VIEW (widget));
7719   remove_open_timeout (GTK_TREE_VIEW (widget));
7720 }
7721
7722
7723 static gboolean
7724 gtk_tree_view_drag_motion (GtkWidget        *widget,
7725                            GdkDragContext   *context,
7726                            /* coordinates relative to the widget */
7727                            gint              x,
7728                            gint              y,
7729                            guint             time)
7730 {
7731   gboolean empty;
7732   GtkTreePath *path = NULL;
7733   GtkTreeViewDropPosition pos;
7734   GtkTreeView *tree_view;
7735   GdkDragAction suggested_action = 0;
7736   GdkAtom target;
7737
7738   tree_view = GTK_TREE_VIEW (widget);
7739
7740   if (!set_destination_row (tree_view, context, x, y, &suggested_action, &target))
7741     return FALSE;
7742
7743   gtk_tree_view_get_drag_dest_row (tree_view, &path, &pos);
7744
7745   /* we only know this *after* set_desination_row */
7746   empty = tree_view->priv->empty_view_drop;
7747
7748   if (path == NULL && !empty)
7749     {
7750       /* Can't drop here. */
7751       gdk_drag_status (context, 0, time);
7752     }
7753   else
7754     {
7755       if (tree_view->priv->open_dest_timeout == 0 &&
7756           (pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER ||
7757            pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE))
7758         {
7759           tree_view->priv->open_dest_timeout =
7760             gdk_threads_add_timeout (AUTO_EXPAND_TIMEOUT, open_row_timeout, tree_view);
7761         }
7762       else
7763         {
7764           add_scroll_timeout (tree_view);
7765         }
7766
7767       if (target == gdk_atom_intern_static_string ("GTK_TREE_MODEL_ROW"))
7768         {
7769           /* Request data so we can use the source row when
7770            * determining whether to accept the drop
7771            */
7772           set_status_pending (context, suggested_action);
7773           gtk_drag_get_data (widget, context, target, time);
7774         }
7775       else
7776         {
7777           set_status_pending (context, 0);
7778           gdk_drag_status (context, suggested_action, time);
7779         }
7780     }
7781
7782   if (path)
7783     gtk_tree_path_free (path);
7784
7785   return TRUE;
7786 }
7787
7788
7789 static gboolean
7790 gtk_tree_view_drag_drop (GtkWidget        *widget,
7791                          GdkDragContext   *context,
7792                          /* coordinates relative to the widget */
7793                          gint              x,
7794                          gint              y,
7795                          guint             time)
7796 {
7797   GtkTreeView *tree_view;
7798   GtkTreePath *path;
7799   GdkDragAction suggested_action = 0;
7800   GdkAtom target = GDK_NONE;
7801   TreeViewDragInfo *di;
7802   GtkTreeModel *model;
7803   gboolean path_down_mode;
7804   gboolean drop_append_mode;
7805
7806   tree_view = GTK_TREE_VIEW (widget);
7807
7808   model = gtk_tree_view_get_model (tree_view);
7809
7810   remove_scroll_timeout (GTK_TREE_VIEW (widget));
7811   remove_open_timeout (GTK_TREE_VIEW (widget));
7812
7813   di = get_info (tree_view);
7814
7815   if (di == NULL)
7816     return FALSE;
7817
7818   if (!check_model_dnd (model, GTK_TYPE_TREE_DRAG_DEST, "drag_drop"))
7819     return FALSE;
7820
7821   if (!set_destination_row (tree_view, context, x, y, &suggested_action, &target))
7822     return FALSE;
7823
7824   path = get_logical_dest_row (tree_view, &path_down_mode, &drop_append_mode);
7825
7826   if (target != GDK_NONE && path != NULL)
7827     {
7828       /* in case a motion had requested drag data, change things so we
7829        * treat drag data receives as a drop.
7830        */
7831       set_status_pending (context, 0);
7832       set_dest_row (context, model, path,
7833                     path_down_mode, tree_view->priv->empty_view_drop,
7834                     drop_append_mode);
7835     }
7836
7837   if (path)
7838     gtk_tree_path_free (path);
7839
7840   /* Unset this thing */
7841   gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
7842                                    NULL,
7843                                    GTK_TREE_VIEW_DROP_BEFORE);
7844
7845   if (target != GDK_NONE)
7846     {
7847       gtk_drag_get_data (widget, context, target, time);
7848       return TRUE;
7849     }
7850   else
7851     return FALSE;
7852 }
7853
7854 static void
7855 gtk_tree_view_drag_data_received (GtkWidget        *widget,
7856                                   GdkDragContext   *context,
7857                                   /* coordinates relative to the widget */
7858                                   gint              x,
7859                                   gint              y,
7860                                   GtkSelectionData *selection_data,
7861                                   guint             info,
7862                                   guint             time)
7863 {
7864   GtkTreePath *path;
7865   TreeViewDragInfo *di;
7866   gboolean accepted = FALSE;
7867   GtkTreeModel *model;
7868   GtkTreeView *tree_view;
7869   GtkTreePath *dest_row;
7870   GdkDragAction suggested_action;
7871   gboolean path_down_mode;
7872   gboolean drop_append_mode;
7873
7874   tree_view = GTK_TREE_VIEW (widget);
7875
7876   model = gtk_tree_view_get_model (tree_view);
7877
7878   if (!check_model_dnd (model, GTK_TYPE_TREE_DRAG_DEST, "drag_data_received"))
7879     return;
7880
7881   di = get_info (tree_view);
7882
7883   if (di == NULL)
7884     return;
7885
7886   suggested_action = get_status_pending (context);
7887
7888   if (suggested_action)
7889     {
7890       /* We are getting this data due to a request in drag_motion,
7891        * rather than due to a request in drag_drop, so we are just
7892        * supposed to call drag_status, not actually paste in the
7893        * data.
7894        */
7895       path = get_logical_dest_row (tree_view, &path_down_mode,
7896                                    &drop_append_mode);
7897
7898       if (path == NULL)
7899         suggested_action = 0;
7900       else if (path_down_mode)
7901         gtk_tree_path_down (path);
7902
7903       if (suggested_action)
7904         {
7905           if (!gtk_tree_drag_dest_row_drop_possible (GTK_TREE_DRAG_DEST (model),
7906                                                      path,
7907                                                      selection_data))
7908             {
7909               if (path_down_mode)
7910                 {
7911                   path_down_mode = FALSE;
7912                   gtk_tree_path_up (path);
7913
7914                   if (!gtk_tree_drag_dest_row_drop_possible (GTK_TREE_DRAG_DEST (model),
7915                                                              path,
7916                                                              selection_data))
7917                     suggested_action = 0;
7918                 }
7919               else
7920                 suggested_action = 0;
7921             }
7922         }
7923
7924       gdk_drag_status (context, suggested_action, time);
7925
7926       if (path)
7927         gtk_tree_path_free (path);
7928
7929       /* If you can't drop, remove user drop indicator until the next motion */
7930       if (suggested_action == 0)
7931         gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
7932                                          NULL,
7933                                          GTK_TREE_VIEW_DROP_BEFORE);
7934
7935       return;
7936     }
7937
7938   dest_row = get_dest_row (context, &path_down_mode);
7939
7940   if (dest_row == NULL)
7941     return;
7942
7943   if (gtk_selection_data_get_length (selection_data) >= 0)
7944     {
7945       if (path_down_mode)
7946         {
7947           gtk_tree_path_down (dest_row);
7948           if (!gtk_tree_drag_dest_row_drop_possible (GTK_TREE_DRAG_DEST (model),
7949                                                      dest_row, selection_data))
7950             gtk_tree_path_up (dest_row);
7951         }
7952     }
7953
7954   if (gtk_selection_data_get_length (selection_data) >= 0)
7955     {
7956       if (gtk_tree_drag_dest_drag_data_received (GTK_TREE_DRAG_DEST (model),
7957                                                  dest_row,
7958                                                  selection_data))
7959         accepted = TRUE;
7960     }
7961
7962   gtk_drag_finish (context,
7963                    accepted,
7964                    (gdk_drag_context_get_selected_action (context) == GDK_ACTION_MOVE),
7965                    time);
7966
7967   if (gtk_tree_path_get_depth (dest_row) == 1 &&
7968       gtk_tree_path_get_indices (dest_row)[0] == 0 &&
7969       gtk_tree_model_iter_n_children (tree_view->priv->model, NULL) != 0)
7970     {
7971       /* special special case drag to "0", scroll to first item */
7972       if (!tree_view->priv->scroll_to_path)
7973         gtk_tree_view_scroll_to_cell (tree_view, dest_row, NULL, FALSE, 0.0, 0.0);
7974     }
7975
7976   gtk_tree_path_free (dest_row);
7977
7978   /* drop dest_row */
7979   set_dest_row (context, NULL, NULL, FALSE, FALSE, FALSE);
7980 }
7981
7982
7983
7984 /* GtkContainer Methods
7985  */
7986
7987
7988 static void
7989 gtk_tree_view_remove (GtkContainer *container,
7990                       GtkWidget    *widget)
7991 {
7992   GtkTreeView *tree_view = GTK_TREE_VIEW (container);
7993   GtkTreeViewChild *child = NULL;
7994   GList *tmp_list;
7995
7996   tmp_list = tree_view->priv->children;
7997   while (tmp_list)
7998     {
7999       child = tmp_list->data;
8000       if (child->widget == widget)
8001         {
8002           gtk_widget_unparent (widget);
8003
8004           tree_view->priv->children = g_list_remove_link (tree_view->priv->children, tmp_list);
8005           g_list_free_1 (tmp_list);
8006           g_slice_free (GtkTreeViewChild, child);
8007           return;
8008         }
8009
8010       tmp_list = tmp_list->next;
8011     }
8012
8013   tmp_list = tree_view->priv->columns;
8014
8015   while (tmp_list)
8016     {
8017       GtkTreeViewColumn *column;
8018       GtkWidget         *button;
8019
8020       column = tmp_list->data;
8021       button = gtk_tree_view_column_get_button (column);
8022
8023       if (button == widget)
8024         {
8025           gtk_widget_unparent (widget);
8026           return;
8027         }
8028       tmp_list = tmp_list->next;
8029     }
8030 }
8031
8032 static void
8033 gtk_tree_view_forall (GtkContainer *container,
8034                       gboolean      include_internals,
8035                       GtkCallback   callback,
8036                       gpointer      callback_data)
8037 {
8038   GtkTreeView *tree_view = GTK_TREE_VIEW (container);
8039   GtkTreeViewChild *child = NULL;
8040   GtkTreeViewColumn *column;
8041   GtkWidget *button;
8042   GList *tmp_list;
8043
8044   tmp_list = tree_view->priv->children;
8045   while (tmp_list)
8046     {
8047       child = tmp_list->data;
8048       tmp_list = tmp_list->next;
8049
8050       (* callback) (child->widget, callback_data);
8051     }
8052   if (include_internals == FALSE)
8053     return;
8054
8055   for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list = tmp_list->next)
8056     {
8057       column = tmp_list->data;
8058       button = gtk_tree_view_column_get_button (column);
8059
8060       if (button)
8061         (* callback) (button, callback_data);
8062     }
8063 }
8064
8065 /* Returns TRUE is any of the columns contains a cell that can-focus.
8066  * If this is not the case, a column-spanning focus rectangle will be
8067  * drawn.
8068  */
8069 static gboolean
8070 gtk_tree_view_has_can_focus_cell (GtkTreeView *tree_view)
8071 {
8072   GList *list;
8073
8074   for (list = tree_view->priv->columns; list; list = list->next)
8075     {
8076       GtkTreeViewColumn *column = list->data;
8077
8078       if (!gtk_tree_view_column_get_visible (column))
8079         continue;
8080       if (gtk_cell_area_is_activatable (gtk_cell_layout_get_area (GTK_CELL_LAYOUT (column))))
8081         return TRUE;
8082     }
8083
8084   return FALSE;
8085 }
8086
8087 static void
8088 column_sizing_notify (GObject    *object,
8089                       GParamSpec *pspec,
8090                       gpointer    data)
8091 {
8092   GtkTreeViewColumn *c = GTK_TREE_VIEW_COLUMN (object);
8093
8094   if (gtk_tree_view_column_get_sizing (c) != GTK_TREE_VIEW_COLUMN_FIXED)
8095     /* disable fixed height mode */
8096     g_object_set (data, "fixed-height-mode", FALSE, NULL);
8097 }
8098
8099 /**
8100  * gtk_tree_view_set_fixed_height_mode:
8101  * @tree_view: a #GtkTreeView
8102  * @enable: %TRUE to enable fixed height mode
8103  *
8104  * Enables or disables the fixed height mode of @tree_view.
8105  * Fixed height mode speeds up #GtkTreeView by assuming that all
8106  * rows have the same height.
8107  * Only enable this option if all rows are the same height and all
8108  * columns are of type %GTK_TREE_VIEW_COLUMN_FIXED.
8109  *
8110  * Since: 2.6
8111  **/
8112 void
8113 gtk_tree_view_set_fixed_height_mode (GtkTreeView *tree_view,
8114                                      gboolean     enable)
8115 {
8116   GList *l;
8117
8118   enable = enable != FALSE;
8119
8120   if (enable == tree_view->priv->fixed_height_mode)
8121     return;
8122
8123   if (!enable)
8124     {
8125       tree_view->priv->fixed_height_mode = 0;
8126       tree_view->priv->fixed_height = -1;
8127     }
8128   else
8129     {
8130       /* make sure all columns are of type FIXED */
8131       for (l = tree_view->priv->columns; l; l = l->next)
8132         {
8133           GtkTreeViewColumn *c = l->data;
8134
8135           g_return_if_fail (gtk_tree_view_column_get_sizing (c) == GTK_TREE_VIEW_COLUMN_FIXED);
8136         }
8137
8138       /* yes, we really have to do this is in a separate loop */
8139       for (l = tree_view->priv->columns; l; l = l->next)
8140         g_signal_connect (l->data, "notify::sizing",
8141                           G_CALLBACK (column_sizing_notify), tree_view);
8142
8143       tree_view->priv->fixed_height_mode = 1;
8144       tree_view->priv->fixed_height = -1;
8145     }
8146
8147   /* force a revalidation */
8148   install_presize_handler (tree_view);
8149
8150   g_object_notify (G_OBJECT (tree_view), "fixed-height-mode");
8151 }
8152
8153 /**
8154  * gtk_tree_view_get_fixed_height_mode:
8155  * @tree_view: a #GtkTreeView
8156  *
8157  * Returns whether fixed height mode is turned on for @tree_view.
8158  *
8159  * Return value: %TRUE if @tree_view is in fixed height mode
8160  *
8161  * Since: 2.6
8162  **/
8163 gboolean
8164 gtk_tree_view_get_fixed_height_mode (GtkTreeView *tree_view)
8165 {
8166   return tree_view->priv->fixed_height_mode;
8167 }
8168
8169 /* Returns TRUE if the focus is within the headers, after the focus operation is
8170  * done
8171  */
8172 static gboolean
8173 gtk_tree_view_header_focus (GtkTreeView      *tree_view,
8174                             GtkDirectionType  dir,
8175                             gboolean          clamp_column_visible)
8176 {
8177   GtkTreeViewColumn *column;
8178   GtkWidget *focus_child;
8179   GtkWidget *button;
8180   GList *last_column, *first_column;
8181   GList *tmp_list;
8182   gboolean rtl;
8183
8184   if (! tree_view->priv->headers_visible)
8185     return FALSE;
8186
8187   focus_child = gtk_container_get_focus_child (GTK_CONTAINER (tree_view));
8188
8189   first_column = tree_view->priv->columns;
8190   while (first_column)
8191     {
8192       column = GTK_TREE_VIEW_COLUMN (first_column->data);
8193       button = gtk_tree_view_column_get_button (column);
8194
8195       if (gtk_widget_get_can_focus (button) &&
8196           gtk_tree_view_column_get_visible (column) &&
8197           (gtk_tree_view_column_get_clickable (column) ||
8198            gtk_tree_view_column_get_reorderable (column)))
8199         break;
8200       first_column = first_column->next;
8201     }
8202
8203   /* No headers are visible, or are focusable.  We can't focus in or out.
8204    */
8205   if (first_column == NULL)
8206     return FALSE;
8207
8208   last_column = g_list_last (tree_view->priv->columns);
8209   while (last_column)
8210     {
8211       column = GTK_TREE_VIEW_COLUMN (last_column->data);
8212       button = gtk_tree_view_column_get_button (column);
8213
8214       if (gtk_widget_get_can_focus (button) &&
8215           gtk_tree_view_column_get_visible (column) &&
8216           (gtk_tree_view_column_get_clickable (column) ||
8217            gtk_tree_view_column_get_reorderable (column)))
8218         break;
8219       last_column = last_column->prev;
8220     }
8221
8222
8223   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
8224
8225   switch (dir)
8226     {
8227     case GTK_DIR_TAB_BACKWARD:
8228     case GTK_DIR_TAB_FORWARD:
8229     case GTK_DIR_UP:
8230     case GTK_DIR_DOWN:
8231       if (focus_child == NULL)
8232         {
8233           if (tree_view->priv->focus_column != NULL)
8234             button = gtk_tree_view_column_get_button (tree_view->priv->focus_column);
8235           else
8236             button = NULL;
8237
8238           if (button && gtk_widget_get_can_focus (button))
8239             focus_child = button;
8240           else
8241             focus_child = gtk_tree_view_column_get_button (GTK_TREE_VIEW_COLUMN (first_column->data));
8242
8243           gtk_widget_grab_focus (focus_child);
8244           break;
8245         }
8246       return FALSE;
8247
8248     case GTK_DIR_LEFT:
8249     case GTK_DIR_RIGHT:
8250       if (focus_child == NULL)
8251         {
8252           if (tree_view->priv->focus_column != NULL)
8253             focus_child = gtk_tree_view_column_get_button (tree_view->priv->focus_column);
8254           else if (dir == GTK_DIR_LEFT)
8255             focus_child = gtk_tree_view_column_get_button (GTK_TREE_VIEW_COLUMN (last_column->data));
8256           else
8257             focus_child = gtk_tree_view_column_get_button (GTK_TREE_VIEW_COLUMN (first_column->data));
8258
8259           gtk_widget_grab_focus (focus_child);
8260           break;
8261         }
8262
8263       if (gtk_widget_child_focus (focus_child, dir))
8264         {
8265           /* The focus moves inside the button. */
8266           /* This is probably a great example of bad UI */
8267           break;
8268         }
8269
8270       /* We need to move the focus among the row of buttons. */
8271       for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list = tmp_list->next)
8272         if (gtk_tree_view_column_get_button (GTK_TREE_VIEW_COLUMN (tmp_list->data)) == focus_child)
8273           break;
8274
8275       if ((tmp_list == first_column && dir == (rtl ? GTK_DIR_RIGHT : GTK_DIR_LEFT))
8276           || (tmp_list == last_column && dir == (rtl ? GTK_DIR_LEFT : GTK_DIR_RIGHT)))
8277         {
8278           gtk_widget_error_bell (GTK_WIDGET (tree_view));
8279           break;
8280         }
8281
8282       while (tmp_list)
8283         {
8284           GtkTreeViewColumn *column;
8285           GtkWidget         *button;
8286
8287           if (dir == (rtl ? GTK_DIR_LEFT : GTK_DIR_RIGHT))
8288             tmp_list = tmp_list->next;
8289           else
8290             tmp_list = tmp_list->prev;
8291
8292           if (tmp_list == NULL)
8293             {
8294               g_warning ("Internal button not found");
8295               break;
8296             }
8297           column = tmp_list->data;
8298           button = gtk_tree_view_column_get_button (column);
8299           if (button &&
8300               gtk_tree_view_column_get_visible (column) &&
8301               gtk_widget_get_can_focus (button))
8302             {
8303               focus_child = button;
8304               gtk_widget_grab_focus (button);
8305               break;
8306             }
8307         }
8308       break;
8309     default:
8310       g_assert_not_reached ();
8311       break;
8312     }
8313
8314   /* if focus child is non-null, we assume it's been set to the current focus child
8315    */
8316   if (focus_child)
8317     {
8318       for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list = tmp_list->next)
8319         if (gtk_tree_view_column_get_button (GTK_TREE_VIEW_COLUMN (tmp_list->data)) == focus_child)
8320           {
8321             _gtk_tree_view_set_focus_column (tree_view, GTK_TREE_VIEW_COLUMN (tmp_list->data));
8322             break;
8323           }
8324
8325       if (clamp_column_visible)
8326         {
8327           gtk_tree_view_clamp_column_visible (tree_view,
8328                                               tree_view->priv->focus_column,
8329                                               FALSE);
8330         }
8331     }
8332
8333   return (focus_child != NULL);
8334 }
8335
8336 /* This function returns in 'path' the first focusable path, if the given path
8337  * is already focusable, it's the returned one.
8338  */
8339 static gboolean
8340 search_first_focusable_path (GtkTreeView  *tree_view,
8341                              GtkTreePath **path,
8342                              gboolean      search_forward,
8343                              GtkRBTree   **new_tree,
8344                              GtkRBNode   **new_node)
8345 {
8346   GtkRBTree *tree = NULL;
8347   GtkRBNode *node = NULL;
8348
8349   if (!path || !*path)
8350     return FALSE;
8351
8352   _gtk_tree_view_find_node (tree_view, *path, &tree, &node);
8353
8354   if (!tree || !node)
8355     return FALSE;
8356
8357   while (node && row_is_separator (tree_view, NULL, *path))
8358     {
8359       if (search_forward)
8360         _gtk_rbtree_next_full (tree, node, &tree, &node);
8361       else
8362         _gtk_rbtree_prev_full (tree, node, &tree, &node);
8363
8364       if (*path)
8365         gtk_tree_path_free (*path);
8366
8367       if (node)
8368         *path = _gtk_tree_path_new_from_rbtree (tree, node);
8369       else
8370         *path = NULL;
8371     }
8372
8373   if (new_tree)
8374     *new_tree = tree;
8375
8376   if (new_node)
8377     *new_node = node;
8378
8379   return (*path != NULL);
8380 }
8381
8382 static gint
8383 gtk_tree_view_focus (GtkWidget        *widget,
8384                      GtkDirectionType  direction)
8385 {
8386   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
8387   GtkContainer *container = GTK_CONTAINER (widget);
8388   GtkWidget *focus_child;
8389
8390   if (!gtk_widget_is_sensitive (widget) || !gtk_widget_get_can_focus (widget))
8391     return FALSE;
8392
8393   focus_child = gtk_container_get_focus_child (container);
8394
8395   gtk_tree_view_stop_editing (GTK_TREE_VIEW (widget), FALSE);
8396   /* Case 1.  Headers currently have focus. */
8397   if (focus_child)
8398     {
8399       switch (direction)
8400         {
8401         case GTK_DIR_LEFT:
8402         case GTK_DIR_RIGHT:
8403           gtk_tree_view_header_focus (tree_view, direction, TRUE);
8404           return TRUE;
8405         case GTK_DIR_TAB_BACKWARD:
8406         case GTK_DIR_UP:
8407           return FALSE;
8408         case GTK_DIR_TAB_FORWARD:
8409         case GTK_DIR_DOWN:
8410           gtk_widget_grab_focus (widget);
8411           return TRUE;
8412         default:
8413           g_assert_not_reached ();
8414           return FALSE;
8415         }
8416     }
8417
8418   /* Case 2. We don't have focus at all. */
8419   if (!gtk_widget_has_focus (widget))
8420     {
8421       gtk_widget_grab_focus (widget);
8422       return TRUE;
8423     }
8424
8425   /* Case 3. We have focus already. */
8426   if (direction == GTK_DIR_TAB_BACKWARD)
8427     return (gtk_tree_view_header_focus (tree_view, direction, FALSE));
8428   else if (direction == GTK_DIR_TAB_FORWARD)
8429     return FALSE;
8430
8431   /* Other directions caught by the keybindings */
8432   gtk_widget_grab_focus (widget);
8433   return TRUE;
8434 }
8435
8436 static void
8437 gtk_tree_view_grab_focus (GtkWidget *widget)
8438 {
8439   GTK_WIDGET_CLASS (gtk_tree_view_parent_class)->grab_focus (widget);
8440
8441   gtk_tree_view_focus_to_cursor (GTK_TREE_VIEW (widget));
8442 }
8443
8444 static void
8445 gtk_tree_view_style_updated (GtkWidget *widget)
8446 {
8447   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
8448   GList *list;
8449   GtkTreeViewColumn *column;
8450   GtkStyleContext *style_context;
8451   const GtkBitmask *changes;
8452
8453   GTK_WIDGET_CLASS (gtk_tree_view_parent_class)->style_updated (widget);
8454
8455   if (gtk_widget_get_realized (widget))
8456     {
8457       gtk_tree_view_ensure_background (tree_view);
8458
8459       gtk_tree_view_set_grid_lines (tree_view, tree_view->priv->grid_lines);
8460       gtk_tree_view_set_enable_tree_lines (tree_view, tree_view->priv->tree_lines_enabled);
8461     }
8462
8463   style_context = gtk_widget_get_style_context (widget);
8464   changes = _gtk_style_context_get_changes (style_context);
8465   if (changes == NULL || _gtk_css_style_property_changes_affect_size (changes))
8466     {
8467       for (list = tree_view->priv->columns; list; list = list->next)
8468         {
8469           column = list->data;
8470           _gtk_tree_view_column_cell_set_dirty (column, TRUE);
8471         }
8472
8473       tree_view->priv->fixed_height = -1;
8474       _gtk_rbtree_mark_invalid (tree_view->priv->tree);
8475     }
8476 }
8477
8478
8479 static void
8480 gtk_tree_view_set_focus_child (GtkContainer *container,
8481                                GtkWidget    *child)
8482 {
8483   GtkTreeView *tree_view = GTK_TREE_VIEW (container);
8484   GList *list;
8485
8486   for (list = tree_view->priv->columns; list; list = list->next)
8487     {
8488       if (gtk_tree_view_column_get_button (GTK_TREE_VIEW_COLUMN (list->data)) == child)
8489         {
8490           _gtk_tree_view_set_focus_column (tree_view, GTK_TREE_VIEW_COLUMN (list->data));
8491           break;
8492         }
8493     }
8494
8495   GTK_CONTAINER_CLASS (gtk_tree_view_parent_class)->set_focus_child (container, child);
8496 }
8497
8498 static GtkWidgetPath *
8499 gtk_tree_view_get_path_for_child (GtkContainer *container,
8500                                   GtkWidget    *child)
8501 {
8502   GtkTreeView *tree_view = GTK_TREE_VIEW (container);
8503   GtkWidgetPath *path;
8504   gboolean rtl;
8505   GList *list, *visible_columns = NULL;
8506   gint n_col = 0;
8507
8508   path = GTK_CONTAINER_CLASS (gtk_tree_view_parent_class)->get_path_for_child (container, child);
8509   rtl = (gtk_widget_get_direction (GTK_WIDGET (container)) == GTK_TEXT_DIR_RTL);
8510
8511   for (list = tree_view->priv->columns; list; list = list->next)
8512     {
8513       GtkTreeViewColumn *column = list->data;
8514
8515       if (gtk_tree_view_column_get_visible (column))
8516         visible_columns = g_list_prepend (visible_columns, column);
8517     }
8518
8519   if (!rtl)
8520     visible_columns = g_list_reverse (visible_columns);
8521
8522   for (list = visible_columns; list != NULL; list = list->next)
8523     {
8524       GtkTreeViewColumn *column = list->data;
8525       GtkRegionFlags flags = 0;
8526
8527       n_col++;
8528
8529       if (gtk_tree_view_column_get_widget (column) != child &&
8530           gtk_tree_view_column_get_button (column) != child)
8531         continue;
8532
8533       if ((n_col % 2) == 0)
8534         flags |= GTK_REGION_EVEN;
8535       else
8536         flags |= GTK_REGION_ODD;
8537
8538       if (n_col == 1)
8539         flags |= GTK_REGION_FIRST;
8540
8541       if (!list->next)
8542         flags |= GTK_REGION_LAST;
8543
8544       gtk_widget_path_iter_add_region (path, gtk_widget_path_length (path) - 2, GTK_STYLE_REGION_COLUMN_HEADER, flags);
8545       break;
8546     }
8547   g_list_free (visible_columns);
8548
8549   return path;
8550 }
8551
8552 static gboolean
8553 gtk_tree_view_real_move_cursor (GtkTreeView       *tree_view,
8554                                 GtkMovementStep    step,
8555                                 gint               count)
8556 {
8557   GdkModifierType state;
8558
8559   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
8560   g_return_val_if_fail (step == GTK_MOVEMENT_LOGICAL_POSITIONS ||
8561                         step == GTK_MOVEMENT_VISUAL_POSITIONS ||
8562                         step == GTK_MOVEMENT_DISPLAY_LINES ||
8563                         step == GTK_MOVEMENT_PAGES ||
8564                         step == GTK_MOVEMENT_BUFFER_ENDS, FALSE);
8565
8566   if (tree_view->priv->tree == NULL)
8567     return FALSE;
8568   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
8569     return FALSE;
8570
8571   gtk_tree_view_stop_editing (tree_view, FALSE);
8572   tree_view->priv->draw_keyfocus = TRUE;
8573   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
8574
8575   if (gtk_get_current_event_state (&state))
8576     {
8577       GdkModifierType extend_mod_mask;
8578       GdkModifierType modify_mod_mask;
8579
8580       extend_mod_mask =
8581         gtk_widget_get_modifier_mask (GTK_WIDGET (tree_view),
8582                                       GDK_MODIFIER_INTENT_EXTEND_SELECTION);
8583
8584       modify_mod_mask =
8585         gtk_widget_get_modifier_mask (GTK_WIDGET (tree_view),
8586                                       GDK_MODIFIER_INTENT_MODIFY_SELECTION);
8587
8588       if ((state & modify_mod_mask) == modify_mod_mask)
8589         tree_view->priv->modify_selection_pressed = TRUE;
8590       if ((state & extend_mod_mask) == extend_mod_mask)
8591         tree_view->priv->extend_selection_pressed = TRUE;
8592     }
8593   /* else we assume not pressed */
8594
8595   switch (step)
8596     {
8597       /* currently we make no distinction.  When we go bi-di, we need to */
8598     case GTK_MOVEMENT_LOGICAL_POSITIONS:
8599     case GTK_MOVEMENT_VISUAL_POSITIONS:
8600       gtk_tree_view_move_cursor_left_right (tree_view, count);
8601       break;
8602     case GTK_MOVEMENT_DISPLAY_LINES:
8603       gtk_tree_view_move_cursor_up_down (tree_view, count);
8604       break;
8605     case GTK_MOVEMENT_PAGES:
8606       gtk_tree_view_move_cursor_page_up_down (tree_view, count);
8607       break;
8608     case GTK_MOVEMENT_BUFFER_ENDS:
8609       gtk_tree_view_move_cursor_start_end (tree_view, count);
8610       break;
8611     default:
8612       g_assert_not_reached ();
8613     }
8614
8615   tree_view->priv->modify_selection_pressed = FALSE;
8616   tree_view->priv->extend_selection_pressed = FALSE;
8617
8618   return TRUE;
8619 }
8620
8621 static void
8622 gtk_tree_view_put (GtkTreeView *tree_view,
8623                    GtkWidget   *child_widget,
8624                    /* in bin_window coordinates */
8625                    gint         x,
8626                    gint         y,
8627                    gint         width,
8628                    gint         height)
8629 {
8630   GtkTreeViewChild *child;
8631
8632   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
8633   g_return_if_fail (GTK_IS_WIDGET (child_widget));
8634
8635   child = g_slice_new (GtkTreeViewChild);
8636
8637   child->widget = child_widget;
8638   child->x = x;
8639   child->y = y;
8640   child->width = width;
8641   child->height = height;
8642
8643   tree_view->priv->children = g_list_append (tree_view->priv->children, child);
8644
8645   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
8646     gtk_widget_set_parent_window (child->widget, tree_view->priv->bin_window);
8647
8648   gtk_widget_set_parent (child_widget, GTK_WIDGET (tree_view));
8649 }
8650
8651 void
8652 _gtk_tree_view_child_move_resize (GtkTreeView *tree_view,
8653                                   GtkWidget   *widget,
8654                                   /* in tree coordinates */
8655                                   gint         x,
8656                                   gint         y,
8657                                   gint         width,
8658                                   gint         height)
8659 {
8660   GtkTreeViewChild *child = NULL;
8661   GList *list;
8662   GdkRectangle allocation;
8663
8664   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
8665   g_return_if_fail (GTK_IS_WIDGET (widget));
8666
8667   for (list = tree_view->priv->children; list; list = list->next)
8668     {
8669       if (((GtkTreeViewChild *)list->data)->widget == widget)
8670         {
8671           child = list->data;
8672           break;
8673         }
8674     }
8675   if (child == NULL)
8676     return;
8677
8678   allocation.x = child->x = x;
8679   allocation.y = child->y = y;
8680   allocation.width = child->width = width;
8681   allocation.height = child->height = height;
8682
8683   if (gtk_widget_get_realized (widget))
8684     gtk_widget_size_allocate (widget, &allocation);
8685 }
8686
8687
8688 /* TreeModel Callbacks
8689  */
8690
8691 static void
8692 gtk_tree_view_row_changed (GtkTreeModel *model,
8693                            GtkTreePath  *path,
8694                            GtkTreeIter  *iter,
8695                            gpointer      data)
8696 {
8697   GtkTreeView *tree_view = (GtkTreeView *)data;
8698   GtkRBTree *tree;
8699   GtkRBNode *node;
8700   gboolean free_path = FALSE;
8701   GList *list;
8702   GtkTreePath *cursor_path;
8703
8704   g_return_if_fail (path != NULL || iter != NULL);
8705
8706   if (tree_view->priv->cursor_node != NULL)
8707     cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
8708                                                   tree_view->priv->cursor_node);
8709   else
8710     cursor_path = NULL;
8711
8712   if (tree_view->priv->edited_column &&
8713       (cursor_path == NULL || gtk_tree_path_compare (cursor_path, path) == 0))
8714     gtk_tree_view_stop_editing (tree_view, TRUE);
8715
8716   if (cursor_path != NULL)
8717     gtk_tree_path_free (cursor_path);
8718
8719   if (path == NULL)
8720     {
8721       path = gtk_tree_model_get_path (model, iter);
8722       free_path = TRUE;
8723     }
8724   else if (iter == NULL)
8725     gtk_tree_model_get_iter (model, iter, path);
8726
8727   if (_gtk_tree_view_find_node (tree_view,
8728                                 path,
8729                                 &tree,
8730                                 &node))
8731     /* We aren't actually showing the node */
8732     goto done;
8733
8734   if (tree == NULL)
8735     goto done;
8736
8737   _gtk_tree_view_accessible_changed (tree_view, tree, node);
8738
8739   if (tree_view->priv->fixed_height_mode
8740       && tree_view->priv->fixed_height >= 0)
8741     {
8742       _gtk_rbtree_node_set_height (tree, node, tree_view->priv->fixed_height);
8743       if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
8744         gtk_tree_view_node_queue_redraw (tree_view, tree, node);
8745     }
8746   else
8747     {
8748       _gtk_rbtree_node_mark_invalid (tree, node);
8749       for (list = tree_view->priv->columns; list; list = list->next)
8750         {
8751           GtkTreeViewColumn *column;
8752
8753           column = list->data;
8754           if (!gtk_tree_view_column_get_visible (column))
8755             continue;
8756
8757           if (gtk_tree_view_column_get_sizing (column) == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
8758             {
8759               _gtk_tree_view_column_cell_set_dirty (column, TRUE);
8760             }
8761         }
8762     }
8763
8764  done:
8765   if (!tree_view->priv->fixed_height_mode &&
8766       gtk_widget_get_realized (GTK_WIDGET (tree_view)))
8767     install_presize_handler (tree_view);
8768   if (free_path)
8769     gtk_tree_path_free (path);
8770 }
8771
8772 static void
8773 gtk_tree_view_row_inserted (GtkTreeModel *model,
8774                             GtkTreePath  *path,
8775                             GtkTreeIter  *iter,
8776                             gpointer      data)
8777 {
8778   GtkTreeView *tree_view = (GtkTreeView *) data;
8779   gint *indices;
8780   GtkRBTree *tree;
8781   GtkRBNode *tmpnode = NULL;
8782   gint depth;
8783   gint i = 0;
8784   gint height;
8785   gboolean free_path = FALSE;
8786   gboolean node_visible = TRUE;
8787
8788   g_return_if_fail (path != NULL || iter != NULL);
8789
8790   if (tree_view->priv->fixed_height_mode
8791       && tree_view->priv->fixed_height >= 0)
8792     height = tree_view->priv->fixed_height;
8793   else
8794     height = 0;
8795
8796   if (path == NULL)
8797     {
8798       path = gtk_tree_model_get_path (model, iter);
8799       free_path = TRUE;
8800     }
8801   else if (iter == NULL)
8802     gtk_tree_model_get_iter (model, iter, path);
8803
8804   if (tree_view->priv->tree == NULL)
8805     tree_view->priv->tree = _gtk_rbtree_new ();
8806
8807   tree = tree_view->priv->tree;
8808
8809   /* Update all row-references */
8810   gtk_tree_row_reference_inserted (G_OBJECT (data), path);
8811   depth = gtk_tree_path_get_depth (path);
8812   indices = gtk_tree_path_get_indices (path);
8813
8814   /* First, find the parent tree */
8815   while (i < depth - 1)
8816     {
8817       if (tree == NULL)
8818         {
8819           /* We aren't showing the node */
8820           node_visible = FALSE;
8821           goto done;
8822         }
8823
8824       tmpnode = _gtk_rbtree_find_count (tree, indices[i] + 1);
8825       if (tmpnode == NULL)
8826         {
8827           g_warning ("A node was inserted with a parent that's not in the tree.\n" \
8828                      "This possibly means that a GtkTreeModel inserted a child node\n" \
8829                      "before the parent was inserted.");
8830           goto done;
8831         }
8832       else if (!GTK_RBNODE_FLAG_SET (tmpnode, GTK_RBNODE_IS_PARENT))
8833         {
8834           /* FIXME enforce correct behavior on model, probably */
8835           /* In theory, the model should have emitted has_child_toggled here.  We
8836            * try to catch it anyway, just to be safe, in case the model hasn't.
8837            */
8838           GtkTreePath *tmppath = _gtk_tree_path_new_from_rbtree (tree, tmpnode);
8839           gtk_tree_view_row_has_child_toggled (model, tmppath, NULL, data);
8840           gtk_tree_path_free (tmppath);
8841           goto done;
8842         }
8843
8844       tree = tmpnode->children;
8845       i++;
8846     }
8847
8848   if (tree == NULL)
8849     {
8850       node_visible = FALSE;
8851       goto done;
8852     }
8853
8854   /* ref the node */
8855   gtk_tree_model_ref_node (tree_view->priv->model, iter);
8856   if (indices[depth - 1] == 0)
8857     {
8858       tmpnode = _gtk_rbtree_find_count (tree, 1);
8859       tmpnode = _gtk_rbtree_insert_before (tree, tmpnode, height, FALSE);
8860     }
8861   else
8862     {
8863       tmpnode = _gtk_rbtree_find_count (tree, indices[depth - 1]);
8864       tmpnode = _gtk_rbtree_insert_after (tree, tmpnode, height, FALSE);
8865     }
8866
8867   _gtk_tree_view_accessible_add (tree_view, tree, tmpnode);
8868
8869  done:
8870   if (height > 0)
8871     {
8872       if (tree)
8873         _gtk_rbtree_node_mark_valid (tree, tmpnode);
8874
8875       if (node_visible && node_is_visible (tree_view, tree, tmpnode))
8876         gtk_widget_queue_resize (GTK_WIDGET (tree_view));
8877       else
8878         gtk_widget_queue_resize_no_redraw (GTK_WIDGET (tree_view));
8879     }
8880   else
8881     install_presize_handler (tree_view);
8882   if (free_path)
8883     gtk_tree_path_free (path);
8884 }
8885
8886 static void
8887 gtk_tree_view_row_has_child_toggled (GtkTreeModel *model,
8888                                      GtkTreePath  *path,
8889                                      GtkTreeIter  *iter,
8890                                      gpointer      data)
8891 {
8892   GtkTreeView *tree_view = (GtkTreeView *)data;
8893   GtkTreeIter real_iter;
8894   gboolean has_child;
8895   GtkRBTree *tree;
8896   GtkRBNode *node;
8897   gboolean free_path = FALSE;
8898
8899   g_return_if_fail (path != NULL || iter != NULL);
8900
8901   if (iter)
8902     real_iter = *iter;
8903
8904   if (path == NULL)
8905     {
8906       path = gtk_tree_model_get_path (model, iter);
8907       free_path = TRUE;
8908     }
8909   else if (iter == NULL)
8910     gtk_tree_model_get_iter (model, &real_iter, path);
8911
8912   if (_gtk_tree_view_find_node (tree_view,
8913                                 path,
8914                                 &tree,
8915                                 &node))
8916     /* We aren't actually showing the node */
8917     goto done;
8918
8919   if (tree == NULL)
8920     goto done;
8921
8922   has_child = gtk_tree_model_iter_has_child (model, &real_iter);
8923   /* Sanity check.
8924    */
8925   if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT) == has_child)
8926     goto done;
8927
8928   if (has_child)
8929     {
8930       GTK_RBNODE_SET_FLAG (node, GTK_RBNODE_IS_PARENT);
8931       _gtk_tree_view_accessible_add_state (tree_view, tree, node, GTK_CELL_RENDERER_EXPANDABLE);
8932     }
8933   else
8934     {
8935       GTK_RBNODE_UNSET_FLAG (node, GTK_RBNODE_IS_PARENT);
8936       _gtk_tree_view_accessible_remove_state (tree_view, tree, node, GTK_CELL_RENDERER_EXPANDABLE);
8937     }
8938
8939   if (has_child && tree_view->priv->is_list)
8940     {
8941       tree_view->priv->is_list = FALSE;
8942       if (tree_view->priv->show_expanders)
8943         {
8944           GList *list;
8945
8946           for (list = tree_view->priv->columns; list; list = list->next)
8947             if (gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (list->data)))
8948               {
8949                 _gtk_tree_view_column_cell_set_dirty (GTK_TREE_VIEW_COLUMN (list->data), TRUE);
8950                 break;
8951               }
8952         }
8953       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
8954     }
8955   else
8956     {
8957       _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
8958     }
8959
8960  done:
8961   if (free_path)
8962     gtk_tree_path_free (path);
8963 }
8964
8965 static void
8966 count_children_helper (GtkRBTree *tree,
8967                        GtkRBNode *node,
8968                        gpointer   data)
8969 {
8970   if (node->children)
8971     _gtk_rbtree_traverse (node->children, node->children->root, G_POST_ORDER, count_children_helper, data);
8972   (*((gint *)data))++;
8973 }
8974
8975 static void
8976 check_selection_helper (GtkRBTree *tree,
8977                         GtkRBNode *node,
8978                         gpointer   data)
8979 {
8980   gint *value = (gint *)data;
8981
8982   *value |= GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED);
8983
8984   if (node->children && !*value)
8985     _gtk_rbtree_traverse (node->children, node->children->root, G_POST_ORDER, check_selection_helper, data);
8986 }
8987
8988 static void
8989 gtk_tree_view_row_deleted (GtkTreeModel *model,
8990                            GtkTreePath  *path,
8991                            gpointer      data)
8992 {
8993   GtkTreeView *tree_view = (GtkTreeView *)data;
8994   GtkRBTree *tree;
8995   GtkRBNode *node;
8996   GList *list;
8997   gboolean selection_changed = FALSE, cursor_changed = FALSE;
8998   GtkRBTree *cursor_tree = NULL;
8999   GtkRBNode *cursor_node = NULL;
9000
9001   g_return_if_fail (path != NULL);
9002
9003   gtk_tree_row_reference_deleted (G_OBJECT (data), path);
9004
9005   if (_gtk_tree_view_find_node (tree_view, path, &tree, &node))
9006     return;
9007
9008   if (tree == NULL)
9009     return;
9010
9011   /* check if the selection has been changed */
9012   _gtk_rbtree_traverse (tree, node, G_POST_ORDER,
9013                         check_selection_helper, &selection_changed);
9014
9015   for (list = tree_view->priv->columns; list; list = list->next)
9016     if (gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (list->data)) &&
9017         gtk_tree_view_column_get_sizing (GTK_TREE_VIEW_COLUMN (list->data)) == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
9018       _gtk_tree_view_column_cell_set_dirty ((GtkTreeViewColumn *)list->data, TRUE);
9019
9020   /* Ensure we don't have a dangling pointer to a dead node */
9021   ensure_unprelighted (tree_view);
9022
9023   /* Cancel editting if we've started */
9024   gtk_tree_view_stop_editing (tree_view, TRUE);
9025
9026   /* If the cursor row got deleted, move the cursor to the next row */
9027   if (tree_view->priv->cursor_node &&
9028       (tree_view->priv->cursor_node == node ||
9029        (node->children && (tree_view->priv->cursor_tree == node->children ||
9030                            _gtk_rbtree_contains (node->children, tree_view->priv->cursor_tree)))))
9031     {
9032       GtkTreePath *cursor_path;
9033
9034       cursor_tree = tree;
9035       cursor_node = _gtk_rbtree_next (tree, node);
9036       /* find the first node that is not going to be deleted */
9037       while (cursor_node == NULL && cursor_tree->parent_tree)
9038         {
9039           cursor_node = _gtk_rbtree_next (cursor_tree->parent_tree,
9040                                           cursor_tree->parent_node);
9041           cursor_tree = cursor_tree->parent_tree;
9042         }
9043
9044       if (cursor_node != NULL)
9045         cursor_path = _gtk_tree_path_new_from_rbtree (cursor_tree, cursor_node);
9046       else
9047         cursor_path = NULL;
9048
9049       if (cursor_path == NULL ||
9050           ! search_first_focusable_path (tree_view, &cursor_path, TRUE,
9051                                          &cursor_tree, &cursor_node))
9052         {
9053           /* It looks like we reached the end of the view without finding
9054            * a focusable row.  We will step backwards to find the last
9055            * focusable row.
9056            */
9057           _gtk_rbtree_prev_full (tree, node, &cursor_tree, &cursor_node);
9058           if (cursor_node)
9059             {
9060               cursor_path = _gtk_tree_path_new_from_rbtree (cursor_tree, cursor_node);
9061               if (! search_first_focusable_path (tree_view, &cursor_path, FALSE,
9062                                                  &cursor_tree, &cursor_node))
9063                 cursor_node = NULL;
9064               gtk_tree_path_free (cursor_path);
9065             }
9066         }
9067       else if (cursor_path)
9068         gtk_tree_path_free (cursor_path);
9069
9070       cursor_changed = TRUE;
9071     }
9072
9073   if (tree_view->priv->destroy_count_func)
9074     {
9075       gint child_count = 0;
9076       if (node->children)
9077         _gtk_rbtree_traverse (node->children, node->children->root, G_POST_ORDER, count_children_helper, &child_count);
9078       tree_view->priv->destroy_count_func (tree_view, path, child_count, tree_view->priv->destroy_count_data);
9079     }
9080
9081   if (tree->root->count == 1)
9082     {
9083       if (tree_view->priv->tree == tree)
9084         tree_view->priv->tree = NULL;
9085
9086       _gtk_tree_view_accessible_remove_state (tree_view,
9087                                               tree->parent_tree, tree->parent_node,
9088                                               GTK_CELL_RENDERER_EXPANDED);
9089       _gtk_tree_view_accessible_remove (tree_view, tree, NULL);
9090       _gtk_rbtree_remove (tree);
9091     }
9092   else
9093     {
9094       _gtk_tree_view_accessible_remove (tree_view, tree, node);
9095       _gtk_rbtree_remove_node (tree, node);
9096     }
9097
9098   if (! gtk_tree_row_reference_valid (tree_view->priv->top_row))
9099     {
9100       gtk_tree_row_reference_free (tree_view->priv->top_row);
9101       tree_view->priv->top_row = NULL;
9102     }
9103
9104   install_scroll_sync_handler (tree_view);
9105
9106   gtk_widget_queue_resize (GTK_WIDGET (tree_view));
9107
9108   if (cursor_changed)
9109     {
9110       if (cursor_node)
9111         {
9112           GtkTreePath *cursor_path = _gtk_tree_path_new_from_rbtree (cursor_tree, cursor_node);
9113           gtk_tree_view_real_set_cursor (tree_view, cursor_path, CLEAR_AND_SELECT | CURSOR_INVALID);
9114           gtk_tree_path_free (cursor_path);
9115         }
9116       else
9117         gtk_tree_view_real_set_cursor (tree_view, NULL, CLEAR_AND_SELECT | CURSOR_INVALID);
9118     }
9119   if (selection_changed)
9120     g_signal_emit_by_name (tree_view->priv->selection, "changed");
9121 }
9122
9123 static void
9124 gtk_tree_view_rows_reordered (GtkTreeModel *model,
9125                               GtkTreePath  *parent,
9126                               GtkTreeIter  *iter,
9127                               gint         *new_order,
9128                               gpointer      data)
9129 {
9130   GtkTreeView *tree_view = GTK_TREE_VIEW (data);
9131   GtkRBTree *tree;
9132   GtkRBNode *node;
9133   gint len;
9134
9135   len = gtk_tree_model_iter_n_children (model, iter);
9136
9137   if (len < 2)
9138     return;
9139
9140   gtk_tree_row_reference_reordered (G_OBJECT (data),
9141                                     parent,
9142                                     iter,
9143                                     new_order);
9144
9145   if (_gtk_tree_view_find_node (tree_view,
9146                                 parent,
9147                                 &tree,
9148                                 &node))
9149     return;
9150
9151   /* We need to special case the parent path */
9152   if (tree == NULL)
9153     tree = tree_view->priv->tree;
9154   else
9155     tree = node->children;
9156
9157   if (tree == NULL)
9158     return;
9159
9160   if (tree_view->priv->edited_column)
9161     gtk_tree_view_stop_editing (tree_view, TRUE);
9162
9163   /* we need to be unprelighted */
9164   ensure_unprelighted (tree_view);
9165
9166   _gtk_rbtree_reorder (tree, new_order, len);
9167
9168   _gtk_tree_view_accessible_reorder (tree_view);
9169
9170   gtk_widget_queue_draw (GTK_WIDGET (tree_view));
9171
9172   gtk_tree_view_dy_to_top_row (tree_view);
9173 }
9174
9175
9176 /* Internal tree functions
9177  */
9178
9179
9180 static void
9181 gtk_tree_view_get_background_xrange (GtkTreeView       *tree_view,
9182                                      GtkRBTree         *tree,
9183                                      GtkTreeViewColumn *column,
9184                                      gint              *x1,
9185                                      gint              *x2)
9186 {
9187   GtkTreeViewColumn *tmp_column = NULL;
9188   gint total_width;
9189   GList *list;
9190   gboolean rtl;
9191
9192   if (x1)
9193     *x1 = 0;
9194
9195   if (x2)
9196     *x2 = 0;
9197
9198   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
9199
9200   total_width = 0;
9201   for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
9202        list;
9203        list = (rtl ? list->prev : list->next))
9204     {
9205       tmp_column = list->data;
9206
9207       if (tmp_column == column)
9208         break;
9209
9210       if (gtk_tree_view_column_get_visible (tmp_column))
9211         total_width += gtk_tree_view_column_get_width (tmp_column);
9212     }
9213
9214   if (tmp_column != column)
9215     {
9216       g_warning (G_STRLOC": passed-in column isn't in the tree");
9217       return;
9218     }
9219
9220   if (x1)
9221     *x1 = total_width;
9222
9223   if (x2)
9224     {
9225       if (gtk_tree_view_column_get_visible (column))
9226         *x2 = total_width + gtk_tree_view_column_get_width (column);
9227       else
9228         *x2 = total_width; /* width of 0 */
9229     }
9230 }
9231
9232 static void
9233 gtk_tree_view_get_arrow_xrange (GtkTreeView *tree_view,
9234                                 GtkRBTree   *tree,
9235                                 gint        *x1,
9236                                 gint        *x2)
9237 {
9238   gint x_offset = 0;
9239   GList *list;
9240   GtkTreeViewColumn *tmp_column = NULL;
9241   gint total_width;
9242   gint expander_size;
9243   gboolean indent_expanders;
9244   gboolean rtl;
9245
9246   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
9247   expander_size = gtk_tree_view_get_expander_size (tree_view);
9248
9249   total_width = 0;
9250   for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
9251        list;
9252        list = (rtl ? list->prev : list->next))
9253     {
9254       tmp_column = list->data;
9255
9256       if (gtk_tree_view_is_expander_column (tree_view, tmp_column))
9257         {
9258           if (rtl)
9259             x_offset = total_width + gtk_tree_view_column_get_width (tmp_column) - expander_size;
9260           else
9261             x_offset = total_width;
9262           break;
9263         }
9264
9265       if (gtk_tree_view_column_get_visible (tmp_column))
9266         total_width += gtk_tree_view_column_get_width (tmp_column);
9267     }
9268
9269   gtk_widget_style_get (GTK_WIDGET (tree_view),
9270                         "indent-expanders", &indent_expanders,
9271                         NULL);
9272
9273   if (indent_expanders)
9274     {
9275       if (rtl)
9276         x_offset -= expander_size * _gtk_rbtree_get_depth (tree);
9277       else
9278         x_offset += expander_size * _gtk_rbtree_get_depth (tree);
9279     }
9280
9281   *x1 = x_offset;
9282
9283   if (tmp_column &&
9284       gtk_tree_view_column_get_visible (tmp_column))
9285     /* +1 because x2 isn't included in the range. */
9286     *x2 = *x1 + expander_size + 1;
9287   else
9288     *x2 = *x1;
9289 }
9290
9291 static void
9292 gtk_tree_view_build_tree (GtkTreeView *tree_view,
9293                           GtkRBTree   *tree,
9294                           GtkTreeIter *iter,
9295                           gint         depth,
9296                           gboolean     recurse)
9297 {
9298   GtkRBNode *temp = NULL;
9299   GtkTreePath *path = NULL;
9300
9301   do
9302     {
9303       gtk_tree_model_ref_node (tree_view->priv->model, iter);
9304       temp = _gtk_rbtree_insert_after (tree, temp, 0, FALSE);
9305
9306       if (tree_view->priv->fixed_height > 0)
9307         {
9308           if (GTK_RBNODE_FLAG_SET (temp, GTK_RBNODE_INVALID))
9309             {
9310               _gtk_rbtree_node_set_height (tree, temp, tree_view->priv->fixed_height);
9311               _gtk_rbtree_node_mark_valid (tree, temp);
9312             }
9313         }
9314
9315       if (tree_view->priv->is_list)
9316         continue;
9317
9318       if (recurse)
9319         {
9320           GtkTreeIter child;
9321
9322           if (!path)
9323             path = gtk_tree_model_get_path (tree_view->priv->model, iter);
9324           else
9325             gtk_tree_path_next (path);
9326
9327           if (gtk_tree_model_iter_children (tree_view->priv->model, &child, iter))
9328             {
9329               gboolean expand;
9330
9331               g_signal_emit (tree_view, tree_view_signals[TEST_EXPAND_ROW], 0, iter, path, &expand);
9332
9333               if (gtk_tree_model_iter_has_child (tree_view->priv->model, iter)
9334                   && !expand)
9335                 {
9336                   temp->children = _gtk_rbtree_new ();
9337                   temp->children->parent_tree = tree;
9338                   temp->children->parent_node = temp;
9339                   gtk_tree_view_build_tree (tree_view, temp->children, &child, depth + 1, recurse);
9340                 }
9341             }
9342         }
9343
9344       if (gtk_tree_model_iter_has_child (tree_view->priv->model, iter))
9345         {
9346           if ((temp->flags&GTK_RBNODE_IS_PARENT) != GTK_RBNODE_IS_PARENT)
9347             temp->flags ^= GTK_RBNODE_IS_PARENT;
9348         }
9349     }
9350   while (gtk_tree_model_iter_next (tree_view->priv->model, iter));
9351
9352   if (path)
9353     gtk_tree_path_free (path);
9354 }
9355
9356 /* Make sure the node is visible vertically */
9357 static void
9358 gtk_tree_view_clamp_node_visible (GtkTreeView *tree_view,
9359                                   GtkRBTree   *tree,
9360                                   GtkRBNode   *node)
9361 {
9362   gint node_dy, height;
9363   GtkTreePath *path = NULL;
9364
9365   if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
9366     return;
9367
9368   /* just return if the node is visible, avoiding a costly expose */
9369   node_dy = _gtk_rbtree_node_find_offset (tree, node);
9370   height = gtk_tree_view_get_row_height (tree_view, node);
9371   if (! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID)
9372       && node_dy >= gtk_adjustment_get_value (tree_view->priv->vadjustment)
9373       && node_dy + height <= (gtk_adjustment_get_value (tree_view->priv->vadjustment)
9374                               + gtk_adjustment_get_page_size (tree_view->priv->vadjustment)))
9375     return;
9376
9377   path = _gtk_tree_path_new_from_rbtree (tree, node);
9378   if (path)
9379     {
9380       gtk_tree_view_scroll_to_cell (tree_view, path, NULL, FALSE, 0.0, 0.0);
9381       gtk_tree_path_free (path);
9382     }
9383 }
9384
9385 static void
9386 gtk_tree_view_clamp_column_visible (GtkTreeView       *tree_view,
9387                                     GtkTreeViewColumn *column,
9388                                     gboolean           focus_to_cell)
9389 {
9390   GtkAllocation allocation;
9391   gint x, width;
9392
9393   if (column == NULL)
9394     return;
9395
9396   gtk_widget_get_allocation (gtk_tree_view_column_get_button (column), &allocation);
9397   x = allocation.x;
9398   width = allocation.width;
9399
9400   if (width > gtk_adjustment_get_page_size (tree_view->priv->hadjustment))
9401     {
9402       /* The column is larger than the horizontal page size.  If the
9403        * column has cells which can be focussed individually, then we make
9404        * sure the cell which gets focus is fully visible (if even the
9405        * focus cell is bigger than the page size, we make sure the
9406        * left-hand side of the cell is visible).
9407        *
9408        * If the column does not have an activatable cell, we
9409        * make sure the left-hand side of the column is visible.
9410        */
9411
9412       if (focus_to_cell && gtk_tree_view_has_can_focus_cell (tree_view))
9413         {
9414           GtkCellArea *cell_area;
9415           GtkCellRenderer *focus_cell;
9416
9417           cell_area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (column));
9418           focus_cell = gtk_cell_area_get_focus_cell (cell_area);
9419
9420           if (gtk_tree_view_column_cell_get_position (column, focus_cell,
9421                                                       &x, &width))
9422             {
9423               if (width < gtk_adjustment_get_page_size (tree_view->priv->hadjustment))
9424                 {
9425                   if (gtk_adjustment_get_value (tree_view->priv->hadjustment) + gtk_adjustment_get_page_size (tree_view->priv->hadjustment) < x + width)
9426                     gtk_adjustment_set_value (tree_view->priv->hadjustment,
9427                                               x + width - gtk_adjustment_get_page_size (tree_view->priv->hadjustment));
9428                   else if (gtk_adjustment_get_value (tree_view->priv->hadjustment) > x)
9429                     gtk_adjustment_set_value (tree_view->priv->hadjustment, x);
9430                 }
9431             }
9432         }
9433
9434       gtk_adjustment_set_value (tree_view->priv->hadjustment, x);
9435     }
9436   else
9437     {
9438       if ((gtk_adjustment_get_value (tree_view->priv->hadjustment) + gtk_adjustment_get_page_size (tree_view->priv->hadjustment)) < (x + width))
9439           gtk_adjustment_set_value (tree_view->priv->hadjustment,
9440                                     x + width - gtk_adjustment_get_page_size (tree_view->priv->hadjustment));
9441       else if (gtk_adjustment_get_value (tree_view->priv->hadjustment) > x)
9442         gtk_adjustment_set_value (tree_view->priv->hadjustment, x);
9443   }
9444 }
9445
9446 /* This function could be more efficient.  I'll optimize it if profiling seems
9447  * to imply that it is important */
9448 GtkTreePath *
9449 _gtk_tree_path_new_from_rbtree (GtkRBTree   *tree,
9450                                 GtkRBNode   *node)
9451 {
9452   GtkTreePath *path;
9453   GtkRBTree *tmp_tree;
9454   GtkRBNode *tmp_node, *last;
9455   gint count;
9456
9457   path = gtk_tree_path_new ();
9458
9459   g_return_val_if_fail (node != NULL, path);
9460
9461   count = 1 + node->left->count;
9462
9463   last = node;
9464   tmp_node = node->parent;
9465   tmp_tree = tree;
9466   while (tmp_tree)
9467     {
9468       while (!_gtk_rbtree_is_nil (tmp_node))
9469         {
9470           if (tmp_node->right == last)
9471             count += 1 + tmp_node->left->count;
9472           last = tmp_node;
9473           tmp_node = tmp_node->parent;
9474         }
9475       gtk_tree_path_prepend_index (path, count - 1);
9476       last = tmp_tree->parent_node;
9477       tmp_tree = tmp_tree->parent_tree;
9478       if (last)
9479         {
9480           count = 1 + last->left->count;
9481           tmp_node = last->parent;
9482         }
9483     }
9484   return path;
9485 }
9486
9487 /* Returns TRUE if we ran out of tree before finding the path.  If the path is
9488  * invalid (ie. points to a node that's not in the tree), *tree and *node are
9489  * both set to NULL.
9490  */
9491 gboolean
9492 _gtk_tree_view_find_node (GtkTreeView  *tree_view,
9493                           GtkTreePath  *path,
9494                           GtkRBTree   **tree,
9495                           GtkRBNode   **node)
9496 {
9497   GtkRBNode *tmpnode = NULL;
9498   GtkRBTree *tmptree = tree_view->priv->tree;
9499   gint *indices = gtk_tree_path_get_indices (path);
9500   gint depth = gtk_tree_path_get_depth (path);
9501   gint i = 0;
9502
9503   *node = NULL;
9504   *tree = NULL;
9505
9506   if (depth == 0 || tmptree == NULL)
9507     return FALSE;
9508   do
9509     {
9510       tmpnode = _gtk_rbtree_find_count (tmptree, indices[i] + 1);
9511       ++i;
9512       if (tmpnode == NULL)
9513         {
9514           *tree = NULL;
9515           *node = NULL;
9516           return FALSE;
9517         }
9518       if (i >= depth)
9519         {
9520           *tree = tmptree;
9521           *node = tmpnode;
9522           return FALSE;
9523         }
9524       *tree = tmptree;
9525       *node = tmpnode;
9526       tmptree = tmpnode->children;
9527       if (tmptree == NULL)
9528         return TRUE;
9529     }
9530   while (1);
9531 }
9532
9533 static gboolean
9534 gtk_tree_view_is_expander_column (GtkTreeView       *tree_view,
9535                                   GtkTreeViewColumn *column)
9536 {
9537   GList *list;
9538
9539   if (tree_view->priv->is_list)
9540     return FALSE;
9541
9542   if (tree_view->priv->expander_column != NULL)
9543     {
9544       if (tree_view->priv->expander_column == column)
9545         return TRUE;
9546       return FALSE;
9547     }
9548   else
9549     {
9550       for (list = tree_view->priv->columns;
9551            list;
9552            list = list->next)
9553         if (gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (list->data)))
9554           break;
9555       if (list && list->data == column)
9556         return TRUE;
9557     }
9558   return FALSE;
9559 }
9560
9561 static inline gboolean
9562 gtk_tree_view_draw_expanders (GtkTreeView *tree_view)
9563 {
9564   if (!tree_view->priv->is_list && tree_view->priv->show_expanders)
9565     return TRUE;
9566   /* else */
9567   return FALSE;
9568 }
9569
9570 static void
9571 gtk_tree_view_add_move_binding (GtkBindingSet  *binding_set,
9572                                 guint           keyval,
9573                                 guint           modmask,
9574                                 gboolean        add_shifted_binding,
9575                                 GtkMovementStep step,
9576                                 gint            count)
9577 {
9578
9579   gtk_binding_entry_add_signal (binding_set, keyval, modmask,
9580                                 "move-cursor", 2,
9581                                 G_TYPE_ENUM, step,
9582                                 G_TYPE_INT, count);
9583
9584   if (add_shifted_binding)
9585     gtk_binding_entry_add_signal (binding_set, keyval, GDK_SHIFT_MASK,
9586                                   "move-cursor", 2,
9587                                   G_TYPE_ENUM, step,
9588                                   G_TYPE_INT, count);
9589
9590   if ((modmask & GDK_CONTROL_MASK) == GDK_CONTROL_MASK)
9591    return;
9592
9593   gtk_binding_entry_add_signal (binding_set, keyval, GDK_CONTROL_MASK | GDK_SHIFT_MASK,
9594                                 "move-cursor", 2,
9595                                 G_TYPE_ENUM, step,
9596                                 G_TYPE_INT, count);
9597
9598   gtk_binding_entry_add_signal (binding_set, keyval, GDK_CONTROL_MASK,
9599                                 "move-cursor", 2,
9600                                 G_TYPE_ENUM, step,
9601                                 G_TYPE_INT, count);
9602 }
9603
9604 static gint
9605 gtk_tree_view_unref_tree_helper (GtkTreeModel *model,
9606                                  GtkTreeIter  *iter,
9607                                  GtkRBTree    *tree,
9608                                  GtkRBNode    *node)
9609 {
9610   gint retval = FALSE;
9611   do
9612     {
9613       g_return_val_if_fail (node != NULL, FALSE);
9614
9615       if (node->children)
9616         {
9617           GtkTreeIter child;
9618           GtkRBTree *new_tree;
9619           GtkRBNode *new_node;
9620
9621           new_tree = node->children;
9622           new_node = _gtk_rbtree_first (new_tree);
9623
9624           if (!gtk_tree_model_iter_children (model, &child, iter))
9625             return FALSE;
9626
9627           retval = gtk_tree_view_unref_tree_helper (model, &child, new_tree, new_node) | retval;
9628         }
9629
9630       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
9631         retval = TRUE;
9632       gtk_tree_model_unref_node (model, iter);
9633       node = _gtk_rbtree_next (tree, node);
9634     }
9635   while (gtk_tree_model_iter_next (model, iter));
9636
9637   return retval;
9638 }
9639
9640 static gint
9641 gtk_tree_view_unref_and_check_selection_tree (GtkTreeView *tree_view,
9642                                               GtkRBTree   *tree)
9643 {
9644   GtkTreeIter iter;
9645   GtkTreePath *path;
9646   GtkRBNode *node;
9647   gint retval;
9648
9649   if (!tree)
9650     return FALSE;
9651
9652   node = _gtk_rbtree_first (tree);
9653
9654   g_return_val_if_fail (node != NULL, FALSE);
9655   path = _gtk_tree_path_new_from_rbtree (tree, node);
9656   gtk_tree_model_get_iter (GTK_TREE_MODEL (tree_view->priv->model),
9657                            &iter, path);
9658   retval = gtk_tree_view_unref_tree_helper (GTK_TREE_MODEL (tree_view->priv->model), &iter, tree, node);
9659   gtk_tree_path_free (path);
9660
9661   return retval;
9662 }
9663
9664 static void
9665 gtk_tree_view_set_column_drag_info (GtkTreeView       *tree_view,
9666                                     GtkTreeViewColumn *column)
9667 {
9668   GtkTreeViewColumn *left_column;
9669   GtkTreeViewColumn *cur_column = NULL;
9670   GtkTreeViewColumnReorder *reorder;
9671   gboolean rtl;
9672   GList *tmp_list;
9673   gint left;
9674
9675   /* We want to precalculate the motion list such that we know what column slots
9676    * are available.
9677    */
9678   left_column = NULL;
9679   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
9680
9681   /* First, identify all possible drop spots */
9682   if (rtl)
9683     tmp_list = g_list_last (tree_view->priv->columns);
9684   else
9685     tmp_list = g_list_first (tree_view->priv->columns);
9686
9687   while (tmp_list)
9688     {
9689       cur_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
9690       tmp_list = rtl?g_list_previous (tmp_list):g_list_next (tmp_list);
9691
9692       if (gtk_tree_view_column_get_visible (cur_column) == FALSE)
9693         continue;
9694
9695       /* If it's not the column moving and func tells us to skip over the column, we continue. */
9696       if (left_column != column && cur_column != column &&
9697           tree_view->priv->column_drop_func &&
9698           ! tree_view->priv->column_drop_func (tree_view, column, left_column, cur_column, tree_view->priv->column_drop_func_data))
9699         {
9700           left_column = cur_column;
9701           continue;
9702         }
9703       reorder = g_slice_new0 (GtkTreeViewColumnReorder);
9704       reorder->left_column = left_column;
9705       left_column = reorder->right_column = cur_column;
9706
9707       tree_view->priv->column_drag_info = g_list_append (tree_view->priv->column_drag_info, reorder);
9708     }
9709
9710   /* Add the last one */
9711   if (tree_view->priv->column_drop_func == NULL ||
9712       ((left_column != column) &&
9713        tree_view->priv->column_drop_func (tree_view, column, left_column, NULL, tree_view->priv->column_drop_func_data)))
9714     {
9715       reorder = g_slice_new0 (GtkTreeViewColumnReorder);
9716       reorder->left_column = left_column;
9717       reorder->right_column = NULL;
9718       tree_view->priv->column_drag_info = g_list_append (tree_view->priv->column_drag_info, reorder);
9719     }
9720
9721   /* We quickly check to see if it even makes sense to reorder columns. */
9722   /* If there is nothing that can be moved, then we return */
9723
9724   if (tree_view->priv->column_drag_info == NULL)
9725     return;
9726
9727   /* We know there are always 2 slots possbile, as you can always return column. */
9728   /* If that's all there is, return */
9729   if (tree_view->priv->column_drag_info->next == NULL ||
9730       (tree_view->priv->column_drag_info->next->next == NULL &&
9731        ((GtkTreeViewColumnReorder *)tree_view->priv->column_drag_info->data)->right_column == column &&
9732        ((GtkTreeViewColumnReorder *)tree_view->priv->column_drag_info->next->data)->left_column == column))
9733     {
9734       for (tmp_list = tree_view->priv->column_drag_info; tmp_list; tmp_list = tmp_list->next)
9735         g_slice_free (GtkTreeViewColumnReorder, tmp_list->data);
9736       g_list_free (tree_view->priv->column_drag_info);
9737       tree_view->priv->column_drag_info = NULL;
9738       return;
9739     }
9740   /* We fill in the ranges for the columns, now that we've isolated them */
9741   left = - TREE_VIEW_COLUMN_DRAG_DEAD_MULTIPLIER (tree_view);
9742
9743   for (tmp_list = tree_view->priv->column_drag_info; tmp_list; tmp_list = tmp_list->next)
9744     {
9745       reorder = (GtkTreeViewColumnReorder *) tmp_list->data;
9746
9747       reorder->left_align = left;
9748       if (tmp_list->next != NULL)
9749         {
9750           GtkAllocation right_allocation, left_allocation;
9751           GtkWidget    *left_button, *right_button;
9752
9753           g_assert (tmp_list->next->data);
9754
9755           right_button = gtk_tree_view_column_get_button (reorder->right_column);
9756           left_button  = gtk_tree_view_column_get_button
9757             (((GtkTreeViewColumnReorder *)tmp_list->next->data)->left_column);
9758
9759           gtk_widget_get_allocation (right_button, &right_allocation);
9760           gtk_widget_get_allocation (left_button, &left_allocation);
9761           left = reorder->right_align = (right_allocation.x + right_allocation.width + left_allocation.x) / 2;
9762         }
9763       else
9764         {
9765           reorder->right_align = gdk_window_get_width (tree_view->priv->header_window)
9766                                  + TREE_VIEW_COLUMN_DRAG_DEAD_MULTIPLIER (tree_view);
9767         }
9768     }
9769 }
9770
9771 void
9772 _gtk_tree_view_column_start_drag (GtkTreeView       *tree_view,
9773                                   GtkTreeViewColumn *column,
9774                                   GdkDevice         *device)
9775 {
9776   GdkEvent *send_event;
9777   GtkAllocation allocation;
9778   GtkAllocation button_allocation;
9779   GdkScreen *screen = gtk_widget_get_screen (GTK_WIDGET (tree_view));
9780   GtkWidget *button;
9781   GdkDevice *pointer, *keyboard;
9782   GdkWindowAttr attributes;
9783   guint attributes_mask;
9784   GtkStyleContext *context;
9785
9786   g_return_if_fail (tree_view->priv->column_drag_info == NULL);
9787   g_return_if_fail (tree_view->priv->cur_reorder == NULL);
9788   g_return_if_fail (tree_view->priv->drag_window == NULL);
9789
9790   gtk_tree_view_set_column_drag_info (tree_view, column);
9791
9792   if (tree_view->priv->column_drag_info == NULL)
9793     return;
9794
9795   button = gtk_tree_view_column_get_button (column);
9796
9797   context = gtk_widget_get_style_context (button);
9798   gtk_style_context_add_class (context, GTK_STYLE_CLASS_DND);
9799
9800   gtk_widget_get_allocation (button, &button_allocation);
9801
9802   attributes.window_type = GDK_WINDOW_CHILD;
9803   attributes.wclass = GDK_INPUT_OUTPUT;
9804   attributes.x = button_allocation.x;
9805   attributes.y = 0;
9806   attributes.width = button_allocation.width;
9807   attributes.height = button_allocation.height;
9808   attributes.visual = gtk_widget_get_visual (GTK_WIDGET (tree_view));
9809   attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK;
9810   attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
9811
9812   tree_view->priv->drag_window = gdk_window_new (tree_view->priv->header_window,
9813                                                  &attributes,
9814                                                  attributes_mask);
9815   gtk_widget_register_window (GTK_WIDGET (tree_view), tree_view->priv->drag_window);
9816
9817   if (gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD)
9818     {
9819       keyboard = device;
9820       pointer = gdk_device_get_associated_device (device);
9821     }
9822   else
9823     {
9824       pointer = device;
9825       keyboard = gdk_device_get_associated_device (device);
9826     }
9827
9828   gdk_device_ungrab (pointer, GDK_CURRENT_TIME);
9829   gdk_device_ungrab (keyboard, GDK_CURRENT_TIME);
9830
9831   gtk_grab_remove (button);
9832
9833   send_event = gdk_event_new (GDK_LEAVE_NOTIFY);
9834   send_event->crossing.send_event = TRUE;
9835   send_event->crossing.window = g_object_ref (gtk_button_get_event_window (GTK_BUTTON (button)));
9836   send_event->crossing.subwindow = NULL;
9837   send_event->crossing.detail = GDK_NOTIFY_ANCESTOR;
9838   send_event->crossing.time = GDK_CURRENT_TIME;
9839   gdk_event_set_device (send_event, device);
9840
9841   gtk_propagate_event (button, send_event);
9842   gdk_event_free (send_event);
9843
9844   send_event = gdk_event_new (GDK_BUTTON_RELEASE);
9845   send_event->button.window = g_object_ref (gdk_screen_get_root_window (screen));
9846   send_event->button.send_event = TRUE;
9847   send_event->button.time = GDK_CURRENT_TIME;
9848   send_event->button.x = -1;
9849   send_event->button.y = -1;
9850   send_event->button.axes = NULL;
9851   send_event->button.state = 0;
9852   send_event->button.button = GDK_BUTTON_PRIMARY;
9853   send_event->button.x_root = 0;
9854   send_event->button.y_root = 0;
9855   gdk_event_set_device (send_event, device);
9856
9857   gtk_propagate_event (button, send_event);
9858   gdk_event_free (send_event);
9859
9860   /* Kids, don't try this at home */
9861   g_object_ref (button);
9862   gtk_container_remove (GTK_CONTAINER (tree_view), button);
9863   gtk_widget_set_parent_window (button, tree_view->priv->drag_window);
9864   gtk_widget_set_parent (button, GTK_WIDGET (tree_view));
9865   g_object_unref (button);
9866
9867   gtk_widget_get_allocation (button, &button_allocation);
9868   tree_view->priv->drag_column_x = button_allocation.x;
9869   allocation = button_allocation;
9870   allocation.x = 0;
9871   gtk_widget_size_allocate (button, &allocation);
9872   gtk_widget_set_parent_window (button, tree_view->priv->drag_window);
9873
9874   tree_view->priv->drag_column = column;
9875   gdk_window_show (tree_view->priv->drag_window);
9876
9877   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
9878   while (gtk_events_pending ())
9879     gtk_main_iteration ();
9880
9881   tree_view->priv->in_column_drag = TRUE;
9882
9883   gdk_device_grab (pointer,
9884                    tree_view->priv->drag_window,
9885                    GDK_OWNERSHIP_NONE,
9886                    FALSE,
9887                    GDK_POINTER_MOTION_MASK|GDK_BUTTON_RELEASE_MASK,
9888                    NULL,
9889                    GDK_CURRENT_TIME);
9890   gdk_device_grab (keyboard,
9891                    tree_view->priv->drag_window,
9892                    GDK_OWNERSHIP_NONE,
9893                    FALSE,
9894                    GDK_KEY_PRESS_MASK|GDK_KEY_RELEASE_MASK,
9895                    NULL,
9896                    GDK_CURRENT_TIME);
9897 }
9898
9899 static void
9900 gtk_tree_view_queue_draw_arrow (GtkTreeView        *tree_view,
9901                                 GtkRBTree          *tree,
9902                                 GtkRBNode          *node)
9903 {
9904   GtkAllocation allocation;
9905   GdkRectangle rect;
9906
9907   if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
9908     return;
9909
9910   gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
9911   rect.x = 0;
9912   rect.width = gtk_tree_view_get_expander_size (tree_view);
9913   rect.width = MAX (rect.width, MAX (tree_view->priv->width, allocation.width));
9914
9915   rect.y = gtk_tree_view_get_row_y_offset (tree_view, tree, node);
9916   rect.height = gtk_tree_view_get_row_height (tree_view, node);
9917
9918   gdk_window_invalidate_rect (tree_view->priv->bin_window, &rect, TRUE);
9919 }
9920
9921 void
9922 _gtk_tree_view_queue_draw_node (GtkTreeView        *tree_view,
9923                                 GtkRBTree          *tree,
9924                                 GtkRBNode          *node,
9925                                 const GdkRectangle *clip_rect)
9926 {
9927   GtkAllocation allocation;
9928   GdkRectangle rect;
9929
9930   if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
9931     return;
9932
9933   gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
9934   rect.x = 0;
9935   rect.width = MAX (tree_view->priv->width, allocation.width);
9936
9937   rect.y = gtk_tree_view_get_row_y_offset (tree_view, tree, node);
9938   rect.height = gtk_tree_view_get_row_height (tree_view, node);
9939
9940   if (clip_rect)
9941     {
9942       GdkRectangle new_rect;
9943
9944       gdk_rectangle_intersect (clip_rect, &rect, &new_rect);
9945
9946       gdk_window_invalidate_rect (tree_view->priv->bin_window, &new_rect, TRUE);
9947     }
9948   else
9949     {
9950       gdk_window_invalidate_rect (tree_view->priv->bin_window, &rect, TRUE);
9951     }
9952 }
9953
9954 static inline gint
9955 gtk_tree_view_get_effective_header_height (GtkTreeView *tree_view)
9956 {
9957   if (tree_view->priv->headers_visible)
9958     return tree_view->priv->header_height;
9959   /* else */
9960   return 0;
9961 }
9962
9963 gint
9964 _gtk_tree_view_get_header_height (GtkTreeView *tree_view)
9965 {
9966   return tree_view->priv->header_height;
9967 }
9968
9969 void
9970 _gtk_tree_view_get_row_separator_func (GtkTreeView                 *tree_view,
9971                                        GtkTreeViewRowSeparatorFunc *func,
9972                                        gpointer                    *data)
9973 {
9974   *func = tree_view->priv->row_separator_func;
9975   *data = tree_view->priv->row_separator_data;
9976 }
9977
9978 GtkTreePath *
9979 _gtk_tree_view_get_anchor_path (GtkTreeView *tree_view)
9980 {
9981   if (tree_view->priv->anchor)
9982     return gtk_tree_row_reference_get_path (tree_view->priv->anchor);
9983
9984   return NULL;
9985 }
9986
9987 void
9988 _gtk_tree_view_set_anchor_path (GtkTreeView *tree_view,
9989                                 GtkTreePath *anchor_path)
9990 {
9991   if (tree_view->priv->anchor)
9992     {
9993       gtk_tree_row_reference_free (tree_view->priv->anchor);
9994       tree_view->priv->anchor = NULL;
9995     }
9996
9997   if (anchor_path && tree_view->priv->model)
9998     tree_view->priv->anchor =
9999       gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view),
10000                                         tree_view->priv->model, anchor_path);
10001 }
10002
10003 GtkRBTree *
10004 _gtk_tree_view_get_rbtree (GtkTreeView *tree_view)
10005 {
10006   return tree_view->priv->tree;
10007 }
10008
10009 gboolean
10010 _gtk_tree_view_get_cursor_node (GtkTreeView  *tree_view,
10011                                 GtkRBTree   **tree,
10012                                 GtkRBNode   **node)
10013 {
10014   GtkTreeViewPrivate *priv;
10015
10016   priv = tree_view->priv;
10017
10018   if (priv->cursor_node == NULL)
10019     return FALSE;
10020
10021   *tree = priv->cursor_tree;
10022   *node = priv->cursor_node;
10023
10024   return TRUE;
10025 }
10026
10027 GdkWindow *
10028 _gtk_tree_view_get_header_window (GtkTreeView *tree_view)
10029 {
10030   return tree_view->priv->header_window;
10031 }
10032
10033 GtkTreeViewColumn *
10034 _gtk_tree_view_get_focus_column (GtkTreeView *tree_view)
10035 {
10036   return tree_view->priv->focus_column;
10037 }
10038
10039 void
10040 _gtk_tree_view_set_focus_column (GtkTreeView       *tree_view,
10041                                  GtkTreeViewColumn *column)
10042 {
10043   GtkTreeViewColumn *old_column = tree_view->priv->focus_column;
10044
10045   if (old_column == column)
10046     return;
10047
10048   tree_view->priv->focus_column = column;
10049
10050   _gtk_tree_view_accessible_update_focus_column (tree_view,
10051                                                  old_column,
10052                                                  column);
10053 }
10054
10055
10056 static void
10057 gtk_tree_view_queue_draw_path (GtkTreeView        *tree_view,
10058                                GtkTreePath        *path,
10059                                const GdkRectangle *clip_rect)
10060 {
10061   GtkRBTree *tree = NULL;
10062   GtkRBNode *node = NULL;
10063
10064   _gtk_tree_view_find_node (tree_view, path, &tree, &node);
10065
10066   if (tree)
10067     _gtk_tree_view_queue_draw_node (tree_view, tree, node, clip_rect);
10068 }
10069
10070 /* x and y are the mouse position
10071  */
10072 static void
10073 gtk_tree_view_draw_arrow (GtkTreeView *tree_view,
10074                           cairo_t     *cr,
10075                           GtkRBTree   *tree,
10076                           GtkRBNode   *node)
10077 {
10078   GdkRectangle area;
10079   GtkStateFlags state = 0;
10080   GtkStyleContext *context;
10081   GtkWidget *widget;
10082   gint x_offset = 0;
10083   gint x2;
10084   gint vertical_separator;
10085   gint expander_size;
10086   GtkCellRendererState flags = 0;
10087
10088   widget = GTK_WIDGET (tree_view);
10089   context = gtk_widget_get_style_context (widget);
10090
10091   gtk_widget_style_get (widget,
10092                         "vertical-separator", &vertical_separator,
10093                         NULL);
10094   expander_size = gtk_tree_view_get_expander_size (tree_view) - EXPANDER_EXTRA_PADDING;
10095
10096   if (! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT))
10097     return;
10098
10099   gtk_tree_view_get_arrow_xrange (tree_view, tree, &x_offset, &x2);
10100
10101   area.x = x_offset;
10102   area.y = gtk_tree_view_get_cell_area_y_offset (tree_view, tree, node,
10103                                                  vertical_separator);
10104   area.width = expander_size;
10105   area.height = gtk_tree_view_get_cell_area_height (tree_view, node,
10106                                                     vertical_separator);
10107
10108   if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
10109     flags |= GTK_CELL_RENDERER_SELECTED;
10110
10111   if (node == tree_view->priv->prelight_node &&
10112       tree_view->priv->arrow_prelit)
10113     flags |= GTK_CELL_RENDERER_PRELIT;
10114
10115   state = gtk_cell_renderer_get_state (NULL, widget, flags);
10116
10117   if (node->children != NULL)
10118     state |= GTK_STATE_FLAG_ACTIVE;
10119   else
10120     state &= ~(GTK_STATE_FLAG_ACTIVE);
10121
10122   gtk_style_context_save (context);
10123
10124   gtk_style_context_set_state (context, state);
10125   gtk_style_context_add_class (context, GTK_STYLE_CLASS_EXPANDER);
10126
10127   gtk_render_expander (context, cr,
10128                        area.x, area.y,
10129                        area.width, area.height);
10130
10131   gtk_style_context_restore (context);
10132 }
10133
10134 static void
10135 gtk_tree_view_focus_to_cursor (GtkTreeView *tree_view)
10136
10137 {
10138   GtkTreePath *cursor_path;
10139
10140   if ((tree_view->priv->tree == NULL) ||
10141       (! gtk_widget_get_realized (GTK_WIDGET (tree_view))))
10142     return;
10143
10144   cursor_path = NULL;
10145   if (tree_view->priv->cursor_node)
10146     cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
10147                                                   tree_view->priv->cursor_node);
10148
10149   if (cursor_path == NULL)
10150     {
10151       /* Consult the selection before defaulting to the
10152        * first focusable element
10153        */
10154       GList *selected_rows;
10155       GtkTreeModel *model;
10156       GtkTreeSelection *selection;
10157
10158       selection = gtk_tree_view_get_selection (tree_view);
10159       selected_rows = gtk_tree_selection_get_selected_rows (selection, &model);
10160
10161       if (selected_rows)
10162         {
10163           cursor_path = gtk_tree_path_copy((const GtkTreePath *)(selected_rows->data));
10164           g_list_free_full (selected_rows, (GDestroyNotify) gtk_tree_path_free);
10165         }
10166       else
10167         {
10168           cursor_path = gtk_tree_path_new_first ();
10169           search_first_focusable_path (tree_view, &cursor_path,
10170                                        TRUE, NULL, NULL);
10171         }
10172
10173       if (cursor_path)
10174         {
10175           if (gtk_tree_selection_get_mode (tree_view->priv->selection) == GTK_SELECTION_MULTIPLE)
10176             gtk_tree_view_real_set_cursor (tree_view, cursor_path, 0);
10177           else
10178             gtk_tree_view_real_set_cursor (tree_view, cursor_path, CLEAR_AND_SELECT);
10179         }
10180     }
10181
10182   if (cursor_path)
10183     {
10184       tree_view->priv->draw_keyfocus = TRUE;
10185
10186       gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
10187       gtk_tree_path_free (cursor_path);
10188
10189       if (tree_view->priv->focus_column == NULL)
10190         {
10191           GList *list;
10192           for (list = tree_view->priv->columns; list; list = list->next)
10193             {
10194               if (gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (list->data)))
10195                 {
10196                   GtkCellArea *cell_area;
10197
10198                   _gtk_tree_view_set_focus_column (tree_view, GTK_TREE_VIEW_COLUMN (list->data));
10199
10200                   /* This happens when the treeview initially grabs focus and there
10201                    * is no column in focus, here we explicitly focus into the first cell */
10202                   cell_area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (tree_view->priv->focus_column));
10203                   if (!gtk_cell_area_get_focus_cell (cell_area))
10204                     {
10205                       gboolean rtl;
10206
10207                       rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
10208                       gtk_cell_area_focus (cell_area,
10209                                            rtl ? GTK_DIR_LEFT : GTK_DIR_RIGHT);
10210                     }
10211
10212                   break;
10213                 }
10214             }
10215         }
10216     }
10217 }
10218
10219 static void
10220 gtk_tree_view_move_cursor_up_down (GtkTreeView *tree_view,
10221                                    gint         count)
10222 {
10223   gint selection_count;
10224   GtkRBTree *new_cursor_tree = NULL;
10225   GtkRBNode *new_cursor_node = NULL;
10226   GtkTreePath *cursor_path = NULL;
10227   gboolean grab_focus = TRUE;
10228   gboolean selectable;
10229   GtkDirectionType direction;
10230   GtkCellArea *cell_area = NULL;
10231   GtkCellRenderer *last_focus_cell = NULL;
10232   GtkTreeIter iter;
10233
10234   if (! gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10235     return;
10236
10237   if (tree_view->priv->cursor_node == NULL)
10238     return;
10239
10240   cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
10241                                                 tree_view->priv->cursor_node);
10242
10243   direction = count < 0 ? GTK_DIR_UP : GTK_DIR_DOWN;
10244
10245   if (tree_view->priv->focus_column)
10246     cell_area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (tree_view->priv->focus_column));
10247
10248   /* If focus stays in the area for this row, then just return for this round */
10249   if (cell_area && (count == -1 || count == 1) &&
10250       gtk_tree_model_get_iter (tree_view->priv->model, &iter, cursor_path))
10251     {
10252       gtk_tree_view_column_cell_set_cell_data (tree_view->priv->focus_column,
10253                                                tree_view->priv->model,
10254                                                &iter,
10255                                                GTK_RBNODE_FLAG_SET (tree_view->priv->cursor_node, GTK_RBNODE_IS_PARENT),
10256                                                tree_view->priv->cursor_node->children ? TRUE : FALSE);
10257
10258       /* Save the last cell that had focus, if we hit the end of the view we'll give
10259        * focus back to it. */
10260       last_focus_cell = gtk_cell_area_get_focus_cell (cell_area);
10261
10262       /* If focus stays in the area, no need to change the cursor row */
10263       if (gtk_cell_area_focus (cell_area, direction))
10264         return;
10265     }
10266
10267   selection_count = gtk_tree_selection_count_selected_rows (tree_view->priv->selection);
10268   selectable = _gtk_tree_selection_row_is_selectable (tree_view->priv->selection,
10269                                                       tree_view->priv->cursor_node,
10270                                                       cursor_path);
10271
10272   if (selection_count == 0
10273       && gtk_tree_selection_get_mode (tree_view->priv->selection) != GTK_SELECTION_NONE
10274       && !tree_view->priv->modify_selection_pressed
10275       && selectable)
10276     {
10277       /* Don't move the cursor, but just select the current node */
10278       new_cursor_tree = tree_view->priv->cursor_tree;
10279       new_cursor_node = tree_view->priv->cursor_node;
10280     }
10281   else
10282     {
10283       if (count == -1)
10284         _gtk_rbtree_prev_full (tree_view->priv->cursor_tree, tree_view->priv->cursor_node,
10285                                &new_cursor_tree, &new_cursor_node);
10286       else
10287         _gtk_rbtree_next_full (tree_view->priv->cursor_tree, tree_view->priv->cursor_node,
10288                                &new_cursor_tree, &new_cursor_node);
10289     }
10290
10291   gtk_tree_path_free (cursor_path);
10292
10293   if (new_cursor_node)
10294     {
10295       cursor_path = _gtk_tree_path_new_from_rbtree (new_cursor_tree, new_cursor_node);
10296
10297       search_first_focusable_path (tree_view, &cursor_path,
10298                                    (count != -1),
10299                                    &new_cursor_tree,
10300                                    &new_cursor_node);
10301
10302       if (cursor_path)
10303         gtk_tree_path_free (cursor_path);
10304     }
10305
10306   /*
10307    * If the list has only one item and multi-selection is set then select
10308    * the row (if not yet selected).
10309    */
10310   if (gtk_tree_selection_get_mode (tree_view->priv->selection) == GTK_SELECTION_MULTIPLE &&
10311       new_cursor_node == NULL)
10312     {
10313       if (count == -1)
10314         _gtk_rbtree_next_full (tree_view->priv->cursor_tree, tree_view->priv->cursor_node,
10315                                &new_cursor_tree, &new_cursor_node);
10316       else
10317         _gtk_rbtree_prev_full (tree_view->priv->cursor_tree, tree_view->priv->cursor_node,
10318                                &new_cursor_tree, &new_cursor_node);
10319
10320       if (new_cursor_node == NULL
10321           && !GTK_RBNODE_FLAG_SET (tree_view->priv->cursor_node, GTK_RBNODE_IS_SELECTED))
10322         {
10323           new_cursor_node = tree_view->priv->cursor_node;
10324           new_cursor_tree = tree_view->priv->cursor_tree;
10325         }
10326       else
10327         {
10328           new_cursor_tree = NULL;
10329           new_cursor_node = NULL;
10330         }
10331     }
10332
10333   if (new_cursor_node)
10334     {
10335       cursor_path = _gtk_tree_path_new_from_rbtree (new_cursor_tree, new_cursor_node);
10336       gtk_tree_view_real_set_cursor (tree_view, cursor_path, CLEAR_AND_SELECT | CLAMP_NODE);
10337       gtk_tree_path_free (cursor_path);
10338
10339       /* Give focus to the area in the new row */
10340       if (cell_area)
10341         gtk_cell_area_focus (cell_area, direction);
10342     }
10343   else
10344     {
10345       gtk_tree_view_clamp_node_visible (tree_view,
10346                                         tree_view->priv->cursor_tree,
10347                                         tree_view->priv->cursor_node);
10348
10349       if (!tree_view->priv->extend_selection_pressed)
10350         {
10351           if (! gtk_widget_keynav_failed (GTK_WIDGET (tree_view),
10352                                           count < 0 ?
10353                                           GTK_DIR_UP : GTK_DIR_DOWN))
10354             {
10355               GtkWidget *toplevel = gtk_widget_get_toplevel (GTK_WIDGET (tree_view));
10356
10357               if (toplevel)
10358                 gtk_widget_child_focus (toplevel,
10359                                         count < 0 ?
10360                                         GTK_DIR_TAB_BACKWARD :
10361                                         GTK_DIR_TAB_FORWARD);
10362
10363               grab_focus = FALSE;
10364             }
10365         }
10366       else
10367         {
10368           gtk_widget_error_bell (GTK_WIDGET (tree_view));
10369         }
10370
10371       if (cell_area)
10372         gtk_cell_area_set_focus_cell (cell_area, last_focus_cell);
10373     }
10374
10375   if (grab_focus)
10376     gtk_widget_grab_focus (GTK_WIDGET (tree_view));
10377 }
10378
10379 static void
10380 gtk_tree_view_move_cursor_page_up_down (GtkTreeView *tree_view,
10381                                         gint         count)
10382 {
10383   GtkTreePath *old_cursor_path = NULL;
10384   GtkTreePath *cursor_path = NULL;
10385   GtkRBTree *start_cursor_tree = NULL;
10386   GtkRBNode *start_cursor_node = NULL;
10387   GtkRBTree *cursor_tree;
10388   GtkRBNode *cursor_node;
10389   gint y;
10390   gint window_y;
10391   gint vertical_separator;
10392
10393   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10394     return;
10395
10396   if (tree_view->priv->cursor_node == NULL)
10397     return;
10398
10399   old_cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
10400                                                     tree_view->priv->cursor_node);
10401
10402   gtk_widget_style_get (GTK_WIDGET (tree_view), "vertical-separator", &vertical_separator, NULL);
10403
10404   y = _gtk_rbtree_node_find_offset (tree_view->priv->cursor_tree, tree_view->priv->cursor_node);
10405   window_y = RBTREE_Y_TO_TREE_WINDOW_Y (tree_view, y);
10406   y += tree_view->priv->cursor_offset;
10407   y += count * (int)gtk_adjustment_get_page_increment (tree_view->priv->vadjustment);
10408   y = CLAMP (y, (gint)gtk_adjustment_get_lower (tree_view->priv->vadjustment),  (gint)gtk_adjustment_get_upper (tree_view->priv->vadjustment) - vertical_separator);
10409
10410   if (y >= tree_view->priv->height)
10411     y = tree_view->priv->height - 1;
10412
10413   tree_view->priv->cursor_offset =
10414     _gtk_rbtree_find_offset (tree_view->priv->tree, y,
10415                              &cursor_tree, &cursor_node);
10416
10417   if (cursor_tree == NULL)
10418     {
10419       /* FIXME: we lost the cursor.  Should we try to get one? */
10420       gtk_tree_path_free (old_cursor_path);
10421       return;
10422     }
10423
10424   if (tree_view->priv->cursor_offset
10425       > gtk_tree_view_get_row_height (tree_view, cursor_node))
10426     {
10427       _gtk_rbtree_next_full (cursor_tree, cursor_node,
10428                              &cursor_tree, &cursor_node);
10429       tree_view->priv->cursor_offset -= gtk_tree_view_get_row_height (tree_view, cursor_node);
10430     }
10431
10432   y -= tree_view->priv->cursor_offset;
10433   cursor_path = _gtk_tree_path_new_from_rbtree (cursor_tree, cursor_node);
10434
10435   start_cursor_tree = cursor_tree;
10436   start_cursor_node = cursor_node;
10437
10438   if (! search_first_focusable_path (tree_view, &cursor_path,
10439                                      (count != -1),
10440                                      &cursor_tree, &cursor_node))
10441     {
10442       /* It looks like we reached the end of the view without finding
10443        * a focusable row.  We will step backwards to find the last
10444        * focusable row.
10445        */
10446       cursor_tree = start_cursor_tree;
10447       cursor_node = start_cursor_node;
10448       cursor_path = _gtk_tree_path_new_from_rbtree (cursor_tree, cursor_node);
10449
10450       search_first_focusable_path (tree_view, &cursor_path,
10451                                    (count == -1),
10452                                    &cursor_tree, &cursor_node);
10453     }
10454
10455   if (!cursor_path)
10456     goto cleanup;
10457
10458   /* update y */
10459   y = _gtk_rbtree_node_find_offset (cursor_tree, cursor_node);
10460
10461   gtk_tree_view_real_set_cursor (tree_view, cursor_path, CLEAR_AND_SELECT);
10462
10463   y -= window_y;
10464   gtk_tree_view_scroll_to_point (tree_view, -1, y);
10465   gtk_tree_view_clamp_node_visible (tree_view, cursor_tree, cursor_node);
10466   _gtk_tree_view_queue_draw_node (tree_view, cursor_tree, cursor_node, NULL);
10467
10468   if (!gtk_tree_path_compare (old_cursor_path, cursor_path))
10469     gtk_widget_error_bell (GTK_WIDGET (tree_view));
10470
10471   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
10472
10473 cleanup:
10474   gtk_tree_path_free (old_cursor_path);
10475   gtk_tree_path_free (cursor_path);
10476 }
10477
10478 static void
10479 gtk_tree_view_move_cursor_left_right (GtkTreeView *tree_view,
10480                                       gint         count)
10481 {
10482   GtkTreePath *cursor_path = NULL;
10483   GtkTreeViewColumn *column;
10484   GtkTreeIter iter;
10485   GList *list;
10486   gboolean found_column = FALSE;
10487   gboolean rtl;
10488   GtkDirectionType direction;
10489   GtkCellArea     *cell_area;
10490   GtkCellRenderer *last_focus_cell = NULL;
10491   GtkCellArea     *last_focus_area = NULL;
10492
10493   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
10494
10495   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10496     return;
10497
10498   if (tree_view->priv->cursor_node == NULL)
10499     return;
10500
10501   cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
10502                                                 tree_view->priv->cursor_node);
10503
10504   if (gtk_tree_model_get_iter (tree_view->priv->model, &iter, cursor_path) == FALSE)
10505     {
10506       gtk_tree_path_free (cursor_path);
10507       return;
10508     }
10509   gtk_tree_path_free (cursor_path);
10510
10511   list = rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns);
10512   if (tree_view->priv->focus_column)
10513     {
10514       /* Save the cell/area we are moving focus from, if moving the cursor
10515        * by one step hits the end we'll set focus back here */
10516       last_focus_area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (tree_view->priv->focus_column));
10517       last_focus_cell = gtk_cell_area_get_focus_cell (last_focus_area);
10518
10519       for (; list; list = (rtl ? list->prev : list->next))
10520         {
10521           if (list->data == tree_view->priv->focus_column)
10522             break;
10523         }
10524     }
10525
10526   direction = count > 0 ? GTK_DIR_RIGHT : GTK_DIR_LEFT;
10527
10528   while (list)
10529     {
10530       column = list->data;
10531       if (gtk_tree_view_column_get_visible (column) == FALSE)
10532         goto loop_end;
10533
10534       gtk_tree_view_column_cell_set_cell_data (column,
10535                                                tree_view->priv->model,
10536                                                &iter,
10537                                                GTK_RBNODE_FLAG_SET (tree_view->priv->cursor_node, GTK_RBNODE_IS_PARENT),
10538                                                tree_view->priv->cursor_node->children ? TRUE : FALSE);
10539
10540       cell_area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (column));
10541       if (gtk_cell_area_focus (cell_area, direction))
10542         {
10543           _gtk_tree_view_set_focus_column (tree_view, column);
10544           found_column = TRUE;
10545           break;
10546         }
10547
10548     loop_end:
10549       if (count == 1)
10550         list = rtl ? list->prev : list->next;
10551       else
10552         list = rtl ? list->next : list->prev;
10553     }
10554
10555   if (found_column)
10556     {
10557       if (!gtk_tree_view_has_can_focus_cell (tree_view))
10558         _gtk_tree_view_queue_draw_node (tree_view,
10559                                         tree_view->priv->cursor_tree,
10560                                         tree_view->priv->cursor_node,
10561                                         NULL);
10562       g_signal_emit (tree_view, tree_view_signals[CURSOR_CHANGED], 0);
10563       gtk_widget_grab_focus (GTK_WIDGET (tree_view));
10564     }
10565   else
10566     {
10567       gtk_widget_error_bell (GTK_WIDGET (tree_view));
10568
10569       if (last_focus_area)
10570         gtk_cell_area_set_focus_cell (last_focus_area, last_focus_cell);
10571     }
10572
10573   gtk_tree_view_clamp_column_visible (tree_view,
10574                                       tree_view->priv->focus_column, TRUE);
10575 }
10576
10577 static void
10578 gtk_tree_view_move_cursor_start_end (GtkTreeView *tree_view,
10579                                      gint         count)
10580 {
10581   GtkRBTree *cursor_tree;
10582   GtkRBNode *cursor_node;
10583   GtkTreePath *path;
10584   GtkTreePath *old_path;
10585
10586   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10587     return;
10588
10589   g_return_if_fail (tree_view->priv->tree != NULL);
10590
10591   gtk_tree_view_get_cursor (tree_view, &old_path, NULL);
10592
10593   cursor_tree = tree_view->priv->tree;
10594
10595   if (count == -1)
10596     {
10597       cursor_node = _gtk_rbtree_first (cursor_tree);
10598
10599       /* Now go forward to find the first focusable row. */
10600       path = _gtk_tree_path_new_from_rbtree (cursor_tree, cursor_node);
10601       search_first_focusable_path (tree_view, &path,
10602                                    TRUE, &cursor_tree, &cursor_node);
10603     }
10604   else
10605     {
10606       cursor_node = cursor_tree->root;
10607
10608       do
10609         {
10610           while (cursor_node && !_gtk_rbtree_is_nil (cursor_node->right))
10611             cursor_node = cursor_node->right;
10612           if (cursor_node->children == NULL)
10613             break;
10614
10615           cursor_tree = cursor_node->children;
10616           cursor_node = cursor_tree->root;
10617         }
10618       while (1);
10619
10620       /* Now go backwards to find last focusable row. */
10621       path = _gtk_tree_path_new_from_rbtree (cursor_tree, cursor_node);
10622       search_first_focusable_path (tree_view, &path,
10623                                    FALSE, &cursor_tree, &cursor_node);
10624     }
10625
10626   if (!path)
10627     goto cleanup;
10628
10629   if (gtk_tree_path_compare (old_path, path))
10630     {
10631       gtk_tree_view_real_set_cursor (tree_view, path, CLEAR_AND_SELECT | CLAMP_NODE);
10632       gtk_widget_grab_focus (GTK_WIDGET (tree_view));
10633     }
10634   else
10635     {
10636       gtk_widget_error_bell (GTK_WIDGET (tree_view));
10637     }
10638
10639 cleanup:
10640   gtk_tree_path_free (old_path);
10641   gtk_tree_path_free (path);
10642 }
10643
10644 static gboolean
10645 gtk_tree_view_real_select_all (GtkTreeView *tree_view)
10646 {
10647   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10648     return FALSE;
10649
10650   if (gtk_tree_selection_get_mode (tree_view->priv->selection) != GTK_SELECTION_MULTIPLE)
10651     return FALSE;
10652
10653   gtk_tree_selection_select_all (tree_view->priv->selection);
10654
10655   return TRUE;
10656 }
10657
10658 static gboolean
10659 gtk_tree_view_real_unselect_all (GtkTreeView *tree_view)
10660 {
10661   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10662     return FALSE;
10663
10664   if (gtk_tree_selection_get_mode (tree_view->priv->selection) != GTK_SELECTION_MULTIPLE)
10665     return FALSE;
10666
10667   gtk_tree_selection_unselect_all (tree_view->priv->selection);
10668
10669   return TRUE;
10670 }
10671
10672 static gboolean
10673 gtk_tree_view_real_select_cursor_row (GtkTreeView *tree_view,
10674                                       gboolean     start_editing)
10675 {
10676   GtkRBTree *new_tree = NULL;
10677   GtkRBNode *new_node = NULL;
10678   GtkRBTree *cursor_tree = NULL;
10679   GtkRBNode *cursor_node = NULL;
10680   GtkTreePath *cursor_path = NULL;
10681   GtkTreeSelectMode mode = 0;
10682
10683   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10684     return FALSE;
10685
10686   if (tree_view->priv->cursor_node == NULL)
10687     return FALSE;
10688
10689   cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
10690                                                 tree_view->priv->cursor_node);
10691
10692   _gtk_tree_view_find_node (tree_view, cursor_path,
10693                             &cursor_tree, &cursor_node);
10694
10695   if (cursor_tree == NULL)
10696     {
10697       gtk_tree_path_free (cursor_path);
10698       return FALSE;
10699     }
10700
10701   if (!tree_view->priv->extend_selection_pressed && start_editing &&
10702       tree_view->priv->focus_column)
10703     {
10704       if (gtk_tree_view_start_editing (tree_view, cursor_path, FALSE))
10705         {
10706           gtk_tree_path_free (cursor_path);
10707           return TRUE;
10708         }
10709     }
10710
10711   if (tree_view->priv->modify_selection_pressed)
10712     mode |= GTK_TREE_SELECT_MODE_TOGGLE;
10713   if (tree_view->priv->extend_selection_pressed)
10714     mode |= GTK_TREE_SELECT_MODE_EXTEND;
10715
10716   _gtk_tree_selection_internal_select_node (tree_view->priv->selection,
10717                                             cursor_node,
10718                                             cursor_tree,
10719                                             cursor_path,
10720                                             mode,
10721                                             FALSE);
10722
10723   /* We bail out if the original (tree, node) don't exist anymore after
10724    * handling the selection-changed callback.  We do return TRUE because
10725    * the key press has been handled at this point.
10726    */
10727   _gtk_tree_view_find_node (tree_view, cursor_path, &new_tree, &new_node);
10728
10729   if (cursor_tree != new_tree || cursor_node != new_node)
10730     return FALSE;
10731
10732   gtk_tree_view_clamp_node_visible (tree_view, cursor_tree, cursor_node);
10733
10734   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
10735   _gtk_tree_view_queue_draw_node (tree_view, cursor_tree, cursor_node, NULL);
10736
10737   if (!tree_view->priv->extend_selection_pressed)
10738     gtk_tree_view_row_activated (tree_view, cursor_path,
10739                                  tree_view->priv->focus_column);
10740
10741   gtk_tree_path_free (cursor_path);
10742
10743   return TRUE;
10744 }
10745
10746 static gboolean
10747 gtk_tree_view_real_toggle_cursor_row (GtkTreeView *tree_view)
10748 {
10749   GtkRBTree *new_tree = NULL;
10750   GtkRBNode *new_node = NULL;
10751   GtkTreePath *cursor_path = NULL;
10752
10753   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10754     return FALSE;
10755
10756   if (tree_view->priv->cursor_node == NULL)
10757     return FALSE;
10758
10759   cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
10760                                                 tree_view->priv->cursor_node);
10761
10762   _gtk_tree_selection_internal_select_node (tree_view->priv->selection,
10763                                             tree_view->priv->cursor_node,
10764                                             tree_view->priv->cursor_tree,
10765                                             cursor_path,
10766                                             GTK_TREE_SELECT_MODE_TOGGLE,
10767                                             FALSE);
10768
10769   /* We bail out if the original (tree, node) don't exist anymore after
10770    * handling the selection-changed callback.  We do return TRUE because
10771    * the key press has been handled at this point.
10772    */
10773   _gtk_tree_view_find_node (tree_view, cursor_path, &new_tree, &new_node);
10774
10775   if (tree_view->priv->cursor_node != new_node)
10776     return FALSE;
10777
10778   gtk_tree_view_clamp_node_visible (tree_view,
10779                                     tree_view->priv->cursor_tree,
10780                                     tree_view->priv->cursor_node);
10781
10782   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
10783   gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
10784   gtk_tree_path_free (cursor_path);
10785
10786   return TRUE;
10787 }
10788
10789 static gboolean
10790 gtk_tree_view_real_expand_collapse_cursor_row (GtkTreeView *tree_view,
10791                                                gboolean     logical,
10792                                                gboolean     expand,
10793                                                gboolean     open_all)
10794 {
10795   GtkTreePath *cursor_path = NULL;
10796
10797   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10798     return FALSE;
10799
10800   if (tree_view->priv->cursor_node == NULL)
10801     return FALSE;
10802
10803   cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
10804                                                 tree_view->priv->cursor_node);
10805
10806   /* Don't handle the event if we aren't an expander */
10807   if (!GTK_RBNODE_FLAG_SET (tree_view->priv->cursor_node, GTK_RBNODE_IS_PARENT))
10808     return FALSE;
10809
10810   if (!logical
10811       && gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL)
10812     expand = !expand;
10813
10814   if (expand)
10815     gtk_tree_view_real_expand_row (tree_view,
10816                                    cursor_path,
10817                                    tree_view->priv->cursor_tree,
10818                                    tree_view->priv->cursor_node,
10819                                    open_all,
10820                                    TRUE);
10821   else
10822     gtk_tree_view_real_collapse_row (tree_view,
10823                                      cursor_path,
10824                                      tree_view->priv->cursor_tree,
10825                                      tree_view->priv->cursor_node,
10826                                      TRUE);
10827
10828   gtk_tree_path_free (cursor_path);
10829
10830   return TRUE;
10831 }
10832
10833 static gboolean
10834 gtk_tree_view_real_select_cursor_parent (GtkTreeView *tree_view)
10835 {
10836   GtkTreePath *cursor_path = NULL;
10837   GdkModifierType state;
10838
10839   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10840     goto out;
10841
10842   if (tree_view->priv->cursor_node == NULL)
10843     goto out;
10844
10845   cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
10846                                                 tree_view->priv->cursor_node);
10847
10848   if (tree_view->priv->cursor_tree->parent_node)
10849     {
10850       gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
10851
10852       gtk_tree_path_up (cursor_path);
10853
10854       if (gtk_get_current_event_state (&state))
10855         {
10856           GdkModifierType modify_mod_mask;
10857
10858           modify_mod_mask =
10859             gtk_widget_get_modifier_mask (GTK_WIDGET (tree_view),
10860                                           GDK_MODIFIER_INTENT_MODIFY_SELECTION);
10861
10862           if ((state & modify_mod_mask) == modify_mod_mask)
10863             tree_view->priv->modify_selection_pressed = TRUE;
10864         }
10865
10866       gtk_tree_view_real_set_cursor (tree_view, cursor_path, CLEAR_AND_SELECT | CLAMP_NODE);
10867       gtk_tree_path_free (cursor_path);
10868
10869       gtk_widget_grab_focus (GTK_WIDGET (tree_view));
10870
10871       tree_view->priv->modify_selection_pressed = FALSE;
10872
10873       return TRUE;
10874     }
10875
10876  out:
10877
10878   tree_view->priv->search_entry_avoid_unhandled_binding = TRUE;
10879   return FALSE;
10880 }
10881
10882 static gboolean
10883 gtk_tree_view_search_entry_flush_timeout (GtkTreeView *tree_view)
10884 {
10885   gtk_tree_view_search_dialog_hide (tree_view->priv->search_window, tree_view, NULL);
10886   tree_view->priv->typeselect_flush_timeout = 0;
10887
10888   return FALSE;
10889 }
10890
10891 /* Cut and paste from gtkwindow.c */
10892 static void
10893 send_focus_change (GtkWidget *widget,
10894                    GdkDevice *device,
10895                    gboolean   in)
10896 {
10897   GdkDeviceManager *device_manager;
10898   GList *devices, *d;
10899
10900   device_manager = gdk_display_get_device_manager (gtk_widget_get_display (widget));
10901   devices = gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_MASTER);
10902   devices = g_list_concat (devices, gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_SLAVE));
10903   devices = g_list_concat (devices, gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_FLOATING));
10904
10905   for (d = devices; d; d = d->next)
10906     {
10907       GdkDevice *dev = d->data;
10908       GdkEvent *fevent;
10909       GdkWindow *window;
10910
10911       if (gdk_device_get_source (dev) != GDK_SOURCE_KEYBOARD)
10912         continue;
10913
10914       window = gtk_widget_get_window (widget);
10915
10916       /* Skip non-master keyboards that haven't
10917        * selected for events from this window
10918        */
10919       if (gdk_device_get_device_type (dev) != GDK_DEVICE_TYPE_MASTER &&
10920           !gdk_window_get_device_events (window, dev))
10921         continue;
10922
10923       fevent = gdk_event_new (GDK_FOCUS_CHANGE);
10924
10925       fevent->focus_change.type = GDK_FOCUS_CHANGE;
10926       fevent->focus_change.window = g_object_ref (window);
10927       fevent->focus_change.in = in;
10928       gdk_event_set_device (fevent, device);
10929
10930       gtk_widget_send_focus_change (widget, fevent);
10931
10932       gdk_event_free (fevent);
10933     }
10934
10935   g_list_free (devices);
10936 }
10937
10938 static void
10939 gtk_tree_view_ensure_interactive_directory (GtkTreeView *tree_view)
10940 {
10941   GtkWidget *frame, *vbox, *toplevel;
10942   GdkScreen *screen;
10943
10944   if (tree_view->priv->search_custom_entry_set)
10945     return;
10946
10947   toplevel = gtk_widget_get_toplevel (GTK_WIDGET (tree_view));
10948   screen = gtk_widget_get_screen (GTK_WIDGET (tree_view));
10949
10950    if (tree_view->priv->search_window != NULL)
10951      {
10952        if (gtk_window_has_group (GTK_WINDOW (toplevel)))
10953          gtk_window_group_add_window (gtk_window_get_group (GTK_WINDOW (toplevel)),
10954                                       GTK_WINDOW (tree_view->priv->search_window));
10955        else if (gtk_window_has_group (GTK_WINDOW (tree_view->priv->search_window)))
10956          gtk_window_group_remove_window (gtk_window_get_group (GTK_WINDOW (tree_view->priv->search_window)),
10957                                          GTK_WINDOW (tree_view->priv->search_window));
10958
10959        gtk_window_set_screen (GTK_WINDOW (tree_view->priv->search_window), screen);
10960
10961        return;
10962      }
10963
10964   tree_view->priv->search_window = gtk_window_new (GTK_WINDOW_POPUP);
10965   gtk_window_set_screen (GTK_WINDOW (tree_view->priv->search_window), screen);
10966
10967   if (gtk_window_has_group (GTK_WINDOW (toplevel)))
10968     gtk_window_group_add_window (gtk_window_get_group (GTK_WINDOW (toplevel)),
10969                                  GTK_WINDOW (tree_view->priv->search_window));
10970
10971   gtk_window_set_type_hint (GTK_WINDOW (tree_view->priv->search_window),
10972                             GDK_WINDOW_TYPE_HINT_UTILITY);
10973   gtk_window_set_modal (GTK_WINDOW (tree_view->priv->search_window), TRUE);
10974   g_signal_connect (tree_view->priv->search_window, "delete-event",
10975                     G_CALLBACK (gtk_tree_view_search_delete_event),
10976                     tree_view);
10977   g_signal_connect (tree_view->priv->search_window, "key-press-event",
10978                     G_CALLBACK (gtk_tree_view_search_key_press_event),
10979                     tree_view);
10980   g_signal_connect (tree_view->priv->search_window, "button-press-event",
10981                     G_CALLBACK (gtk_tree_view_search_button_press_event),
10982                     tree_view);
10983   g_signal_connect (tree_view->priv->search_window, "scroll-event",
10984                     G_CALLBACK (gtk_tree_view_search_scroll_event),
10985                     tree_view);
10986
10987   frame = gtk_frame_new (NULL);
10988   gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
10989   gtk_widget_show (frame);
10990   gtk_container_add (GTK_CONTAINER (tree_view->priv->search_window), frame);
10991
10992   vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
10993   gtk_widget_show (vbox);
10994   gtk_container_add (GTK_CONTAINER (frame), vbox);
10995   gtk_container_set_border_width (GTK_CONTAINER (vbox), 3);
10996
10997   /* add entry */
10998   tree_view->priv->search_entry = gtk_entry_new ();
10999   gtk_widget_show (tree_view->priv->search_entry);
11000   g_signal_connect (tree_view->priv->search_entry, "populate-popup",
11001                     G_CALLBACK (gtk_tree_view_search_disable_popdown),
11002                     tree_view);
11003   g_signal_connect (tree_view->priv->search_entry,
11004                     "activate", G_CALLBACK (gtk_tree_view_search_activate),
11005                     tree_view);
11006
11007   g_signal_connect (_gtk_entry_get_im_context (GTK_ENTRY (tree_view->priv->search_entry)),
11008                     "preedit-changed",
11009                     G_CALLBACK (gtk_tree_view_search_preedit_changed),
11010                     tree_view);
11011
11012   gtk_container_add (GTK_CONTAINER (vbox),
11013                      tree_view->priv->search_entry);
11014
11015   gtk_widget_realize (tree_view->priv->search_entry);
11016 }
11017
11018 /* Pops up the interactive search entry.  If keybinding is TRUE then the user
11019  * started this by typing the start_interactive_search keybinding.  Otherwise, it came from
11020  */
11021 static gboolean
11022 gtk_tree_view_real_start_interactive_search (GtkTreeView *tree_view,
11023                                              GdkDevice   *device,
11024                                              gboolean     keybinding)
11025 {
11026   /* We only start interactive search if we have focus or the columns
11027    * have focus.  If one of our children have focus, we don't want to
11028    * start the search.
11029    */
11030   GList *list;
11031   gboolean found_focus = FALSE;
11032   GtkWidgetClass *entry_parent_class;
11033
11034   if (!tree_view->priv->enable_search && !keybinding)
11035     return FALSE;
11036
11037   if (tree_view->priv->search_custom_entry_set)
11038     return FALSE;
11039
11040   if (tree_view->priv->search_window != NULL &&
11041       gtk_widget_get_visible (tree_view->priv->search_window))
11042     return TRUE;
11043
11044   for (list = tree_view->priv->columns; list; list = list->next)
11045     {
11046       GtkTreeViewColumn *column;
11047       GtkWidget         *button;
11048
11049       column = list->data;
11050       if (!gtk_tree_view_column_get_visible (column))
11051         continue;
11052
11053       button = gtk_tree_view_column_get_button (column);
11054       if (gtk_widget_has_focus (button))
11055         {
11056           found_focus = TRUE;
11057           break;
11058         }
11059     }
11060
11061   if (gtk_widget_has_focus (GTK_WIDGET (tree_view)))
11062     found_focus = TRUE;
11063
11064   if (!found_focus)
11065     return FALSE;
11066
11067   if (tree_view->priv->search_column < 0)
11068     return FALSE;
11069
11070   gtk_tree_view_ensure_interactive_directory (tree_view);
11071
11072   if (keybinding)
11073     gtk_entry_set_text (GTK_ENTRY (tree_view->priv->search_entry), "");
11074
11075   /* done, show it */
11076   tree_view->priv->search_position_func (tree_view, tree_view->priv->search_window, tree_view->priv->search_position_user_data);
11077   gtk_widget_show (tree_view->priv->search_window);
11078   if (tree_view->priv->search_entry_changed_id == 0)
11079     {
11080       tree_view->priv->search_entry_changed_id =
11081         g_signal_connect (tree_view->priv->search_entry, "changed",
11082                           G_CALLBACK (gtk_tree_view_search_init),
11083                           tree_view);
11084     }
11085
11086   tree_view->priv->typeselect_flush_timeout =
11087     gdk_threads_add_timeout (GTK_TREE_VIEW_SEARCH_DIALOG_TIMEOUT,
11088                    (GSourceFunc) gtk_tree_view_search_entry_flush_timeout,
11089                    tree_view);
11090
11091   /* Grab focus will select all the text.  We don't want that to happen, so we
11092    * call the parent instance and bypass the selection change.  This is probably
11093    * really non-kosher. */
11094   entry_parent_class = g_type_class_peek_parent (GTK_ENTRY_GET_CLASS (tree_view->priv->search_entry));
11095   (entry_parent_class->grab_focus) (tree_view->priv->search_entry);
11096
11097   /* send focus-in event */
11098   send_focus_change (tree_view->priv->search_entry, device, TRUE);
11099
11100   /* search first matching iter */
11101   gtk_tree_view_search_init (tree_view->priv->search_entry, tree_view);
11102
11103   return TRUE;
11104 }
11105
11106 static gboolean
11107 gtk_tree_view_start_interactive_search (GtkTreeView *tree_view)
11108 {
11109   return gtk_tree_view_real_start_interactive_search (tree_view,
11110                                                       gtk_get_current_event_device (),
11111                                                       TRUE);
11112 }
11113
11114 /* FIXME this adjust_allocation is a big cut-and-paste from
11115  * GtkCList, needs to be some "official" way to do this
11116  * factored out.
11117  */
11118 typedef struct
11119 {
11120   GdkWindow *window;
11121   int dx;
11122   int dy;
11123 } ScrollData;
11124
11125 /* The window to which widget->window is relative */
11126 #define ALLOCATION_WINDOW(widget)               \
11127    (!gtk_widget_get_has_window (widget) ?                   \
11128     gtk_widget_get_window (widget) :                        \
11129     gdk_window_get_parent (gtk_widget_get_window (widget)))
11130
11131 static void
11132 adjust_allocation_recurse (GtkWidget *widget,
11133                            gpointer   data)
11134 {
11135   GtkAllocation allocation;
11136   ScrollData *scroll_data = data;
11137
11138   /* Need to really size allocate instead of just poking
11139    * into widget->allocation if the widget is not realized.
11140    * FIXME someone figure out why this was.
11141    */
11142   gtk_widget_get_allocation (widget, &allocation);
11143   if (!gtk_widget_get_realized (widget))
11144     {
11145       if (gtk_widget_get_visible (widget))
11146         {
11147           GdkRectangle tmp_rectangle = allocation;
11148           tmp_rectangle.x += scroll_data->dx;
11149           tmp_rectangle.y += scroll_data->dy;
11150
11151           gtk_widget_size_allocate (widget, &tmp_rectangle);
11152         }
11153     }
11154   else
11155     {
11156       if (ALLOCATION_WINDOW (widget) == scroll_data->window)
11157         {
11158           allocation.x += scroll_data->dx;
11159           allocation.y += scroll_data->dy;
11160           gtk_widget_set_allocation (widget, &allocation);
11161
11162           if (GTK_IS_CONTAINER (widget))
11163             gtk_container_forall (GTK_CONTAINER (widget),
11164                                   adjust_allocation_recurse,
11165                                   data);
11166         }
11167     }
11168 }
11169
11170 static void
11171 adjust_allocation (GtkWidget *widget,
11172                    int        dx,
11173                    int        dy)
11174 {
11175   ScrollData scroll_data;
11176
11177   if (gtk_widget_get_realized (widget))
11178     scroll_data.window = ALLOCATION_WINDOW (widget);
11179   else
11180     scroll_data.window = NULL;
11181
11182   scroll_data.dx = dx;
11183   scroll_data.dy = dy;
11184
11185   adjust_allocation_recurse (widget, &scroll_data);
11186 }
11187
11188 /* Callbacks */
11189 static void
11190 gtk_tree_view_adjustment_changed (GtkAdjustment *adjustment,
11191                                   GtkTreeView   *tree_view)
11192 {
11193   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
11194     {
11195       gint dy;
11196
11197       gdk_window_move (tree_view->priv->bin_window,
11198                        - gtk_adjustment_get_value (tree_view->priv->hadjustment),
11199                        gtk_tree_view_get_effective_header_height (tree_view));
11200       gdk_window_move (tree_view->priv->header_window,
11201                        - gtk_adjustment_get_value (tree_view->priv->hadjustment),
11202                        0);
11203       dy = tree_view->priv->dy - (int) gtk_adjustment_get_value (tree_view->priv->vadjustment);
11204       if (dy)
11205         {
11206           update_prelight (tree_view,
11207                            tree_view->priv->event_last_x,
11208                            tree_view->priv->event_last_y - dy);
11209
11210           if (tree_view->priv->edited_column)
11211             {
11212               GList *list;
11213               GtkTreeViewChild *child = NULL;
11214               GtkCellEditable *edit_widget;
11215               GtkCellArea *area;
11216
11217               area        = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (tree_view->priv->edited_column));
11218               edit_widget = gtk_cell_area_get_edit_widget (area);
11219               if (GTK_IS_WIDGET (edit_widget))
11220                 {
11221                   adjust_allocation (GTK_WIDGET (edit_widget), 0, dy);
11222
11223                   for (list = tree_view->priv->children; list; list = list->next)
11224                     {
11225                       child = (GtkTreeViewChild *)list->data;
11226                       if (child->widget == GTK_WIDGET (edit_widget))
11227                         {
11228                           child->y += dy;
11229                           break;
11230                         }
11231                     }
11232                 }
11233             }
11234         }
11235       gdk_window_scroll (tree_view->priv->bin_window, 0, dy);
11236
11237       if (tree_view->priv->dy != (int) gtk_adjustment_get_value (tree_view->priv->vadjustment))
11238         {
11239           /* update our dy and top_row */
11240           tree_view->priv->dy = (int) gtk_adjustment_get_value (tree_view->priv->vadjustment);
11241
11242           if (!tree_view->priv->in_top_row_to_dy)
11243             gtk_tree_view_dy_to_top_row (tree_view);
11244         }
11245     }
11246 }
11247
11248 \f
11249
11250 /* Public methods
11251  */
11252
11253 /**
11254  * gtk_tree_view_new:
11255  *
11256  * Creates a new #GtkTreeView widget.
11257  *
11258  * Return value: A newly created #GtkTreeView widget.
11259  **/
11260 GtkWidget *
11261 gtk_tree_view_new (void)
11262 {
11263   return g_object_new (GTK_TYPE_TREE_VIEW, NULL);
11264 }
11265
11266 /**
11267  * gtk_tree_view_new_with_model:
11268  * @model: the model.
11269  *
11270  * Creates a new #GtkTreeView widget with the model initialized to @model.
11271  *
11272  * Return value: A newly created #GtkTreeView widget.
11273  **/
11274 GtkWidget *
11275 gtk_tree_view_new_with_model (GtkTreeModel *model)
11276 {
11277   return g_object_new (GTK_TYPE_TREE_VIEW, "model", model, NULL);
11278 }
11279
11280 /* Public Accessors
11281  */
11282
11283 /**
11284  * gtk_tree_view_get_model:
11285  * @tree_view: a #GtkTreeView
11286  *
11287  * Returns the model the #GtkTreeView is based on.  Returns %NULL if the
11288  * model is unset.
11289  *
11290  * Return value: (transfer none): A #GtkTreeModel, or %NULL if none is currently being used.
11291  **/
11292 GtkTreeModel *
11293 gtk_tree_view_get_model (GtkTreeView *tree_view)
11294 {
11295   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
11296
11297   return tree_view->priv->model;
11298 }
11299
11300 /**
11301  * gtk_tree_view_set_model:
11302  * @tree_view: A #GtkTreeView.
11303  * @model: (allow-none): The model.
11304  *
11305  * Sets the model for a #GtkTreeView.  If the @tree_view already has a model
11306  * set, it will remove it before setting the new model.  If @model is %NULL,
11307  * then it will unset the old model.
11308  **/
11309 void
11310 gtk_tree_view_set_model (GtkTreeView  *tree_view,
11311                          GtkTreeModel *model)
11312 {
11313   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11314   g_return_if_fail (model == NULL || GTK_IS_TREE_MODEL (model));
11315
11316   if (model == tree_view->priv->model)
11317     return;
11318
11319   if (tree_view->priv->scroll_to_path)
11320     {
11321       gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
11322       tree_view->priv->scroll_to_path = NULL;
11323     }
11324
11325   if (tree_view->priv->rubber_band_status)
11326     gtk_tree_view_stop_rubber_band (tree_view);
11327
11328   if (tree_view->priv->model)
11329     {
11330       GList *tmplist = tree_view->priv->columns;
11331
11332       gtk_tree_view_unref_and_check_selection_tree (tree_view, tree_view->priv->tree);
11333       gtk_tree_view_stop_editing (tree_view, TRUE);
11334
11335       g_signal_handlers_disconnect_by_func (tree_view->priv->model,
11336                                             gtk_tree_view_row_changed,
11337                                             tree_view);
11338       g_signal_handlers_disconnect_by_func (tree_view->priv->model,
11339                                             gtk_tree_view_row_inserted,
11340                                             tree_view);
11341       g_signal_handlers_disconnect_by_func (tree_view->priv->model,
11342                                             gtk_tree_view_row_has_child_toggled,
11343                                             tree_view);
11344       g_signal_handlers_disconnect_by_func (tree_view->priv->model,
11345                                             gtk_tree_view_row_deleted,
11346                                             tree_view);
11347       g_signal_handlers_disconnect_by_func (tree_view->priv->model,
11348                                             gtk_tree_view_rows_reordered,
11349                                             tree_view);
11350
11351       for (; tmplist; tmplist = tmplist->next)
11352         _gtk_tree_view_column_unset_model (tmplist->data,
11353                                            tree_view->priv->model);
11354
11355       if (tree_view->priv->tree)
11356         gtk_tree_view_free_rbtree (tree_view);
11357
11358       gtk_tree_row_reference_free (tree_view->priv->drag_dest_row);
11359       tree_view->priv->drag_dest_row = NULL;
11360       gtk_tree_row_reference_free (tree_view->priv->anchor);
11361       tree_view->priv->anchor = NULL;
11362       gtk_tree_row_reference_free (tree_view->priv->top_row);
11363       tree_view->priv->top_row = NULL;
11364       gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
11365       tree_view->priv->scroll_to_path = NULL;
11366
11367       tree_view->priv->scroll_to_column = NULL;
11368
11369       g_object_unref (tree_view->priv->model);
11370
11371       tree_view->priv->search_column = -1;
11372       tree_view->priv->fixed_height_check = 0;
11373       tree_view->priv->fixed_height = -1;
11374       tree_view->priv->dy = tree_view->priv->top_row_dy = 0;
11375       tree_view->priv->last_button_x = -1;
11376       tree_view->priv->last_button_y = -1;
11377     }
11378
11379   tree_view->priv->model = model;
11380
11381   if (tree_view->priv->model)
11382     {
11383       gint i;
11384       GtkTreePath *path;
11385       GtkTreeIter iter;
11386       GtkTreeModelFlags flags;
11387
11388       if (tree_view->priv->search_column == -1)
11389         {
11390           for (i = 0; i < gtk_tree_model_get_n_columns (model); i++)
11391             {
11392               GType type = gtk_tree_model_get_column_type (model, i);
11393
11394               if (g_value_type_transformable (type, G_TYPE_STRING))
11395                 {
11396                   tree_view->priv->search_column = i;
11397                   break;
11398                 }
11399             }
11400         }
11401
11402       g_object_ref (tree_view->priv->model);
11403       g_signal_connect (tree_view->priv->model,
11404                         "row-changed",
11405                         G_CALLBACK (gtk_tree_view_row_changed),
11406                         tree_view);
11407       g_signal_connect (tree_view->priv->model,
11408                         "row-inserted",
11409                         G_CALLBACK (gtk_tree_view_row_inserted),
11410                         tree_view);
11411       g_signal_connect (tree_view->priv->model,
11412                         "row-has-child-toggled",
11413                         G_CALLBACK (gtk_tree_view_row_has_child_toggled),
11414                         tree_view);
11415       g_signal_connect (tree_view->priv->model,
11416                         "row-deleted",
11417                         G_CALLBACK (gtk_tree_view_row_deleted),
11418                         tree_view);
11419       g_signal_connect (tree_view->priv->model,
11420                         "rows-reordered",
11421                         G_CALLBACK (gtk_tree_view_rows_reordered),
11422                         tree_view);
11423
11424       flags = gtk_tree_model_get_flags (tree_view->priv->model);
11425       if ((flags & GTK_TREE_MODEL_LIST_ONLY) == GTK_TREE_MODEL_LIST_ONLY)
11426         tree_view->priv->is_list = TRUE;
11427       else
11428         tree_view->priv->is_list = FALSE;
11429
11430       path = gtk_tree_path_new_first ();
11431       if (gtk_tree_model_get_iter (tree_view->priv->model, &iter, path))
11432         {
11433           tree_view->priv->tree = _gtk_rbtree_new ();
11434           gtk_tree_view_build_tree (tree_view, tree_view->priv->tree, &iter, 1, FALSE);
11435           _gtk_tree_view_accessible_add (tree_view, tree_view->priv->tree, NULL);
11436         }
11437       gtk_tree_path_free (path);
11438
11439       /*  FIXME: do I need to do this? gtk_tree_view_create_buttons (tree_view); */
11440       install_presize_handler (tree_view);
11441     }
11442
11443   gtk_tree_view_real_set_cursor (tree_view, NULL, CURSOR_INVALID);
11444
11445   g_object_notify (G_OBJECT (tree_view), "model");
11446
11447   if (tree_view->priv->selection)
11448   _gtk_tree_selection_emit_changed (tree_view->priv->selection);
11449
11450   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
11451     gtk_widget_queue_resize (GTK_WIDGET (tree_view));
11452 }
11453
11454 /**
11455  * gtk_tree_view_get_selection:
11456  * @tree_view: A #GtkTreeView.
11457  *
11458  * Gets the #GtkTreeSelection associated with @tree_view.
11459  *
11460  * Return value: (transfer none): A #GtkTreeSelection object.
11461  **/
11462 GtkTreeSelection *
11463 gtk_tree_view_get_selection (GtkTreeView *tree_view)
11464 {
11465   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
11466
11467   return tree_view->priv->selection;
11468 }
11469
11470 /**
11471  * gtk_tree_view_get_hadjustment:
11472  * @tree_view: A #GtkTreeView
11473  *
11474  * Gets the #GtkAdjustment currently being used for the horizontal aspect.
11475  *
11476  * Return value: (transfer none): A #GtkAdjustment object, or %NULL
11477  *     if none is currently being used.
11478  *
11479  * Deprecated: 3.0: Use gtk_scrollable_get_hadjustment()
11480  **/
11481 GtkAdjustment *
11482 gtk_tree_view_get_hadjustment (GtkTreeView *tree_view)
11483 {
11484   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
11485
11486   return gtk_tree_view_do_get_hadjustment (tree_view);
11487 }
11488
11489 static GtkAdjustment *
11490 gtk_tree_view_do_get_hadjustment (GtkTreeView *tree_view)
11491 {
11492   return tree_view->priv->hadjustment;
11493 }
11494
11495 /**
11496  * gtk_tree_view_set_hadjustment:
11497  * @tree_view: A #GtkTreeView
11498  * @adjustment: (allow-none): The #GtkAdjustment to set, or %NULL
11499  *
11500  * Sets the #GtkAdjustment for the current horizontal aspect.
11501  *
11502  * Deprecated: 3.0: Use gtk_scrollable_set_hadjustment()
11503  **/
11504 void
11505 gtk_tree_view_set_hadjustment (GtkTreeView   *tree_view,
11506                                GtkAdjustment *adjustment)
11507 {
11508   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11509   g_return_if_fail (adjustment == NULL || GTK_IS_ADJUSTMENT (adjustment));
11510
11511   gtk_tree_view_do_set_hadjustment (tree_view, adjustment);
11512 }
11513
11514 static void
11515 gtk_tree_view_do_set_hadjustment (GtkTreeView   *tree_view,
11516                                   GtkAdjustment *adjustment)
11517 {
11518   GtkTreeViewPrivate *priv = tree_view->priv;
11519
11520   if (adjustment && priv->hadjustment == adjustment)
11521     return;
11522
11523   if (priv->hadjustment != NULL)
11524     {
11525       g_signal_handlers_disconnect_by_func (priv->hadjustment,
11526                                             gtk_tree_view_adjustment_changed,
11527                                             tree_view);
11528       g_object_unref (priv->hadjustment);
11529     }
11530
11531   if (adjustment == NULL)
11532     adjustment = gtk_adjustment_new (0.0, 0.0, 0.0,
11533                                      0.0, 0.0, 0.0);
11534
11535   g_signal_connect (adjustment, "value-changed",
11536                     G_CALLBACK (gtk_tree_view_adjustment_changed), tree_view);
11537   priv->hadjustment = g_object_ref_sink (adjustment);
11538   /* FIXME: Adjustment should probably be populated here with fresh values, but
11539    * internal details are too complicated for me to decipher right now.
11540    */
11541   gtk_tree_view_adjustment_changed (NULL, tree_view);
11542
11543   g_object_notify (G_OBJECT (tree_view), "hadjustment");
11544 }
11545
11546 /**
11547  * gtk_tree_view_get_vadjustment:
11548  * @tree_view: A #GtkTreeView
11549  *
11550  * Gets the #GtkAdjustment currently being used for the vertical aspect.
11551  *
11552  * Return value: (transfer none): A #GtkAdjustment object, or %NULL
11553  *     if none is currently being used.
11554  *
11555  * Deprecated: 3.0: Use gtk_scrollable_get_vadjustment()
11556  **/
11557 GtkAdjustment *
11558 gtk_tree_view_get_vadjustment (GtkTreeView *tree_view)
11559 {
11560   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
11561
11562   return gtk_tree_view_do_get_vadjustment (tree_view);
11563 }
11564
11565 static GtkAdjustment *
11566 gtk_tree_view_do_get_vadjustment (GtkTreeView *tree_view)
11567 {
11568   return tree_view->priv->vadjustment;
11569 }
11570
11571 /**
11572  * gtk_tree_view_set_vadjustment:
11573  * @tree_view: A #GtkTreeView
11574  * @adjustment: (allow-none): The #GtkAdjustment to set, or %NULL
11575  *
11576  * Sets the #GtkAdjustment for the current vertical aspect.
11577  *
11578  * Deprecated: 3.0: Use gtk_scrollable_set_vadjustment()
11579  **/
11580 void
11581 gtk_tree_view_set_vadjustment (GtkTreeView   *tree_view,
11582                                GtkAdjustment *adjustment)
11583 {
11584   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11585   g_return_if_fail (adjustment == NULL || GTK_IS_ADJUSTMENT (adjustment));
11586
11587   gtk_tree_view_do_set_vadjustment (tree_view, adjustment);
11588 }
11589
11590 static void
11591 gtk_tree_view_do_set_vadjustment (GtkTreeView   *tree_view,
11592                                   GtkAdjustment *adjustment)
11593 {
11594   GtkTreeViewPrivate *priv = tree_view->priv;
11595
11596   if (adjustment && priv->vadjustment == adjustment)
11597     return;
11598
11599   if (priv->vadjustment != NULL)
11600     {
11601       g_signal_handlers_disconnect_by_func (priv->vadjustment,
11602                                             gtk_tree_view_adjustment_changed,
11603                                             tree_view);
11604       g_object_unref (priv->vadjustment);
11605     }
11606
11607   if (adjustment == NULL)
11608     adjustment = gtk_adjustment_new (0.0, 0.0, 0.0,
11609                                      0.0, 0.0, 0.0);
11610
11611   g_signal_connect (adjustment, "value-changed",
11612                     G_CALLBACK (gtk_tree_view_adjustment_changed), tree_view);
11613   priv->vadjustment = g_object_ref_sink (adjustment);
11614   /* FIXME: Adjustment should probably be populated here with fresh values, but
11615    * internal details are too complicated for me to decipher right now.
11616    */
11617   gtk_tree_view_adjustment_changed (NULL, tree_view);
11618   g_object_notify (G_OBJECT (tree_view), "vadjustment");
11619 }
11620
11621 /* Column and header operations */
11622
11623 /**
11624  * gtk_tree_view_get_headers_visible:
11625  * @tree_view: A #GtkTreeView.
11626  *
11627  * Returns %TRUE if the headers on the @tree_view are visible.
11628  *
11629  * Return value: Whether the headers are visible or not.
11630  **/
11631 gboolean
11632 gtk_tree_view_get_headers_visible (GtkTreeView *tree_view)
11633 {
11634   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
11635
11636   return tree_view->priv->headers_visible;
11637 }
11638
11639 /**
11640  * gtk_tree_view_set_headers_visible:
11641  * @tree_view: A #GtkTreeView.
11642  * @headers_visible: %TRUE if the headers are visible
11643  *
11644  * Sets the visibility state of the headers.
11645  **/
11646 void
11647 gtk_tree_view_set_headers_visible (GtkTreeView *tree_view,
11648                                    gboolean     headers_visible)
11649 {
11650   gint x, y;
11651   GList *list;
11652   GtkTreeViewColumn *column;
11653   GtkAllocation allocation;
11654   GtkWidget *button;
11655
11656   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11657
11658   headers_visible = !! headers_visible;
11659
11660   if (tree_view->priv->headers_visible == headers_visible)
11661     return;
11662
11663   tree_view->priv->headers_visible = headers_visible == TRUE;
11664
11665   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
11666     {
11667       gdk_window_get_position (tree_view->priv->bin_window, &x, &y);
11668       if (headers_visible)
11669         {
11670           gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
11671           gdk_window_move_resize (tree_view->priv->bin_window,
11672                                   x, y  + gtk_tree_view_get_effective_header_height (tree_view),
11673                                   tree_view->priv->width, allocation.height -  + gtk_tree_view_get_effective_header_height (tree_view));
11674
11675           if (gtk_widget_get_mapped (GTK_WIDGET (tree_view)))
11676             gtk_tree_view_map_buttons (tree_view);
11677         }
11678       else
11679         {
11680           gdk_window_move_resize (tree_view->priv->bin_window, x, y, tree_view->priv->width, tree_view->priv->height);
11681
11682           for (list = tree_view->priv->columns; list; list = list->next)
11683             {
11684               column = list->data;
11685               button = gtk_tree_view_column_get_button (column);
11686
11687               gtk_widget_hide (button);
11688               gtk_widget_unmap (button);
11689             }
11690           gdk_window_hide (tree_view->priv->header_window);
11691         }
11692     }
11693
11694   gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
11695   gtk_adjustment_configure (tree_view->priv->vadjustment,
11696                             gtk_adjustment_get_value (tree_view->priv->vadjustment),
11697                             0,
11698                             tree_view->priv->height,
11699                             gtk_adjustment_get_step_increment (tree_view->priv->vadjustment),
11700                             (allocation.height - gtk_tree_view_get_effective_header_height (tree_view)) / 2,
11701                             allocation.height - gtk_tree_view_get_effective_header_height (tree_view));
11702
11703   gtk_widget_queue_resize (GTK_WIDGET (tree_view));
11704
11705   g_object_notify (G_OBJECT (tree_view), "headers-visible");
11706 }
11707
11708 /**
11709  * gtk_tree_view_columns_autosize:
11710  * @tree_view: A #GtkTreeView.
11711  *
11712  * Resizes all columns to their optimal width. Only works after the
11713  * treeview has been realized.
11714  **/
11715 void
11716 gtk_tree_view_columns_autosize (GtkTreeView *tree_view)
11717 {
11718   gboolean dirty = FALSE;
11719   GList *list;
11720   GtkTreeViewColumn *column;
11721
11722   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11723
11724   for (list = tree_view->priv->columns; list; list = list->next)
11725     {
11726       column = list->data;
11727       if (gtk_tree_view_column_get_sizing (column) == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
11728         continue;
11729       _gtk_tree_view_column_cell_set_dirty (column, TRUE);
11730       dirty = TRUE;
11731     }
11732
11733   if (dirty)
11734     gtk_widget_queue_resize (GTK_WIDGET (tree_view));
11735 }
11736
11737 /**
11738  * gtk_tree_view_set_headers_clickable:
11739  * @tree_view: A #GtkTreeView.
11740  * @setting: %TRUE if the columns are clickable.
11741  *
11742  * Allow the column title buttons to be clicked.
11743  **/
11744 void
11745 gtk_tree_view_set_headers_clickable (GtkTreeView *tree_view,
11746                                      gboolean   setting)
11747 {
11748   GList *list;
11749
11750   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11751
11752   for (list = tree_view->priv->columns; list; list = list->next)
11753     gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (list->data), setting);
11754
11755   g_object_notify (G_OBJECT (tree_view), "headers-clickable");
11756 }
11757
11758
11759 /**
11760  * gtk_tree_view_get_headers_clickable:
11761  * @tree_view: A #GtkTreeView.
11762  *
11763  * Returns whether all header columns are clickable.
11764  *
11765  * Return value: %TRUE if all header columns are clickable, otherwise %FALSE
11766  *
11767  * Since: 2.10
11768  **/
11769 gboolean
11770 gtk_tree_view_get_headers_clickable (GtkTreeView *tree_view)
11771 {
11772   GList *list;
11773
11774   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
11775
11776   for (list = tree_view->priv->columns; list; list = list->next)
11777     if (!gtk_tree_view_column_get_clickable (GTK_TREE_VIEW_COLUMN (list->data)))
11778       return FALSE;
11779
11780   return TRUE;
11781 }
11782
11783 /**
11784  * gtk_tree_view_set_rules_hint:
11785  * @tree_view: a #GtkTreeView
11786  * @setting: %TRUE if the tree requires reading across rows
11787  *
11788  * This function tells GTK+ that the user interface for your
11789  * application requires users to read across tree rows and associate
11790  * cells with one another. By default, GTK+ will then render the tree
11791  * with alternating row colors. Do <emphasis>not</emphasis> use it
11792  * just because you prefer the appearance of the ruled tree; that's a
11793  * question for the theme. Some themes will draw tree rows in
11794  * alternating colors even when rules are turned off, and users who
11795  * prefer that appearance all the time can choose those themes. You
11796  * should call this function only as a <emphasis>semantic</emphasis>
11797  * hint to the theme engine that your tree makes alternating colors
11798  * useful from a functional standpoint (since it has lots of columns,
11799  * generally).
11800  *
11801  **/
11802 void
11803 gtk_tree_view_set_rules_hint (GtkTreeView  *tree_view,
11804                               gboolean      setting)
11805 {
11806   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11807
11808   setting = setting != FALSE;
11809
11810   if (tree_view->priv->has_rules != setting)
11811     {
11812       tree_view->priv->has_rules = setting;
11813       gtk_widget_queue_draw (GTK_WIDGET (tree_view));
11814     }
11815
11816   g_object_notify (G_OBJECT (tree_view), "rules-hint");
11817 }
11818
11819 /**
11820  * gtk_tree_view_get_rules_hint:
11821  * @tree_view: a #GtkTreeView
11822  *
11823  * Gets the setting set by gtk_tree_view_set_rules_hint().
11824  *
11825  * Return value: %TRUE if rules are useful for the user of this tree
11826  **/
11827 gboolean
11828 gtk_tree_view_get_rules_hint (GtkTreeView  *tree_view)
11829 {
11830   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
11831
11832   return tree_view->priv->has_rules;
11833 }
11834
11835
11836 /**
11837  * gtk_tree_view_set_activate_on_single_click:
11838  * @tree_view: a #GtkTreeView
11839  * @single: %TRUE to emit row-activated on a single click
11840  *
11841  * Cause the #GtkTreeView::row-activated signal to be emitted
11842  * on a single click instead of a double click.
11843  *
11844  * Since: 3.8
11845  **/
11846 void
11847 gtk_tree_view_set_activate_on_single_click (GtkTreeView *tree_view,
11848                                             gboolean     single)
11849 {
11850   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11851
11852   single = single != FALSE;
11853
11854   if (tree_view->priv->activate_on_single_click == single)
11855     return;
11856
11857   tree_view->priv->activate_on_single_click = single;
11858   g_object_notify (G_OBJECT (tree_view), "activate-on-single-click");
11859 }
11860
11861 /**
11862  * gtk_tree_view_get_activate_on_single_click:
11863  * @tree_view: a #GtkTreeView
11864  *
11865  * Gets the setting set by gtk_tree_view_set_activate_on_single_click().
11866  *
11867  * Return value: %TRUE if row-activated will be emitted on a single click
11868  *
11869  * Since: 3.8
11870  **/
11871 gboolean
11872 gtk_tree_view_get_activate_on_single_click (GtkTreeView *tree_view)
11873 {
11874   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
11875
11876   return tree_view->priv->activate_on_single_click;
11877 }
11878
11879 /* Public Column functions
11880  */
11881
11882 /**
11883  * gtk_tree_view_append_column:
11884  * @tree_view: A #GtkTreeView.
11885  * @column: The #GtkTreeViewColumn to add.
11886  *
11887  * Appends @column to the list of columns. If @tree_view has "fixed_height"
11888  * mode enabled, then @column must have its "sizing" property set to be
11889  * GTK_TREE_VIEW_COLUMN_FIXED.
11890  *
11891  * Return value: The number of columns in @tree_view after appending.
11892  **/
11893 gint
11894 gtk_tree_view_append_column (GtkTreeView       *tree_view,
11895                              GtkTreeViewColumn *column)
11896 {
11897   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
11898   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (column), -1);
11899   g_return_val_if_fail (gtk_tree_view_column_get_tree_view (column) == NULL, -1);
11900
11901   return gtk_tree_view_insert_column (tree_view, column, -1);
11902 }
11903
11904 void
11905 _gtk_tree_view_reset_header_styles (GtkTreeView *tree_view)
11906 {
11907   GList *columns;
11908
11909   for (columns = tree_view->priv->columns; columns; columns = columns->next)
11910     {
11911       GtkTreeViewColumn *column = columns->data;
11912       GtkWidget *header_widget;
11913
11914       if (!gtk_tree_view_column_get_visible (column))
11915         continue;
11916
11917       header_widget = gtk_tree_view_column_get_widget (column);
11918
11919       if (!header_widget)
11920         header_widget = gtk_tree_view_column_get_button (column);
11921
11922       _gtk_widget_invalidate_style_context (header_widget, GTK_CSS_CHANGE_PARENT_REGION);
11923     }
11924 }
11925
11926
11927 /**
11928  * gtk_tree_view_remove_column:
11929  * @tree_view: A #GtkTreeView.
11930  * @column: The #GtkTreeViewColumn to remove.
11931  *
11932  * Removes @column from @tree_view.
11933  *
11934  * Return value: The number of columns in @tree_view after removing.
11935  **/
11936 gint
11937 gtk_tree_view_remove_column (GtkTreeView       *tree_view,
11938                              GtkTreeViewColumn *column)
11939 {
11940   guint position;
11941
11942   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
11943   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (column), -1);
11944   g_return_val_if_fail (gtk_tree_view_column_get_tree_view (column) == GTK_WIDGET (tree_view), -1);
11945
11946   if (tree_view->priv->focus_column == column)
11947     _gtk_tree_view_set_focus_column (tree_view, NULL);
11948
11949   if (tree_view->priv->edited_column == column)
11950     {
11951       gtk_tree_view_stop_editing (tree_view, TRUE);
11952
11953       /* no need to, but just to be sure ... */
11954       tree_view->priv->edited_column = NULL;
11955     }
11956
11957   if (tree_view->priv->expander_column == column)
11958     tree_view->priv->expander_column = NULL;
11959
11960   g_signal_handlers_disconnect_by_func (column,
11961                                         G_CALLBACK (column_sizing_notify),
11962                                         tree_view);
11963
11964   _gtk_tree_view_column_unset_tree_view (column);
11965
11966   position = g_list_index (tree_view->priv->columns, column);
11967
11968   tree_view->priv->columns = g_list_remove (tree_view->priv->columns, column);
11969   tree_view->priv->n_columns--;
11970
11971   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
11972     {
11973       GList *list;
11974
11975       _gtk_tree_view_column_unrealize_button (column);
11976       for (list = tree_view->priv->columns; list; list = list->next)
11977         {
11978           GtkTreeViewColumn *tmp_column;
11979
11980           tmp_column = GTK_TREE_VIEW_COLUMN (list->data);
11981           if (gtk_tree_view_column_get_visible (tmp_column))
11982             _gtk_tree_view_column_cell_set_dirty (tmp_column, TRUE);
11983         }
11984
11985       if (tree_view->priv->n_columns == 0 &&
11986           gtk_tree_view_get_headers_visible (tree_view))
11987         gdk_window_hide (tree_view->priv->header_window);
11988
11989       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
11990     }
11991
11992   _gtk_tree_view_reset_header_styles (tree_view);
11993
11994   _gtk_tree_view_accessible_remove_column (tree_view, column, position);
11995
11996   g_object_unref (column);
11997   g_signal_emit (tree_view, tree_view_signals[COLUMNS_CHANGED], 0);
11998
11999   return tree_view->priv->n_columns;
12000 }
12001
12002 /**
12003  * gtk_tree_view_insert_column:
12004  * @tree_view: A #GtkTreeView.
12005  * @column: The #GtkTreeViewColumn to be inserted.
12006  * @position: The position to insert @column in.
12007  *
12008  * This inserts the @column into the @tree_view at @position.  If @position is
12009  * -1, then the column is inserted at the end. If @tree_view has
12010  * "fixed_height" mode enabled, then @column must have its "sizing" property
12011  * set to be GTK_TREE_VIEW_COLUMN_FIXED.
12012  *
12013  * Return value: The number of columns in @tree_view after insertion.
12014  **/
12015 gint
12016 gtk_tree_view_insert_column (GtkTreeView       *tree_view,
12017                              GtkTreeViewColumn *column,
12018                              gint               position)
12019 {
12020   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
12021   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (column), -1);
12022   g_return_val_if_fail (gtk_tree_view_column_get_tree_view (column) == NULL, -1);
12023
12024   if (tree_view->priv->fixed_height_mode)
12025     g_return_val_if_fail (gtk_tree_view_column_get_sizing (column)
12026                           == GTK_TREE_VIEW_COLUMN_FIXED, -1);
12027
12028   if (position < 0 || position > tree_view->priv->n_columns)
12029     position = tree_view->priv->n_columns;
12030
12031   g_object_ref_sink (column);
12032
12033   if (tree_view->priv->n_columns == 0 &&
12034       gtk_widget_get_realized (GTK_WIDGET (tree_view)) &&
12035       gtk_tree_view_get_headers_visible (tree_view))
12036     {
12037       gdk_window_show (tree_view->priv->header_window);
12038     }
12039
12040   g_signal_connect (column, "notify::sizing",
12041                     G_CALLBACK (column_sizing_notify), tree_view);
12042
12043   tree_view->priv->columns = g_list_insert (tree_view->priv->columns,
12044                                             column, position);
12045   tree_view->priv->n_columns++;
12046
12047   _gtk_tree_view_column_set_tree_view (column, tree_view);
12048
12049   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
12050     {
12051       GList *list;
12052
12053       _gtk_tree_view_column_realize_button (column);
12054
12055       for (list = tree_view->priv->columns; list; list = list->next)
12056         {
12057           column = GTK_TREE_VIEW_COLUMN (list->data);
12058           if (gtk_tree_view_column_get_visible (column))
12059             _gtk_tree_view_column_cell_set_dirty (column, TRUE);
12060         }
12061       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
12062     }
12063
12064   _gtk_tree_view_reset_header_styles (tree_view);
12065
12066   _gtk_tree_view_accessible_add_column (tree_view, column, position);
12067
12068   g_signal_emit (tree_view, tree_view_signals[COLUMNS_CHANGED], 0);
12069
12070   return tree_view->priv->n_columns;
12071 }
12072
12073 /**
12074  * gtk_tree_view_insert_column_with_attributes:
12075  * @tree_view: A #GtkTreeView
12076  * @position: The position to insert the new column in
12077  * @title: The title to set the header to
12078  * @cell: The #GtkCellRenderer
12079  * @...: A %NULL-terminated list of attributes
12080  *
12081  * Creates a new #GtkTreeViewColumn and inserts it into the @tree_view at
12082  * @position.  If @position is -1, then the newly created column is inserted at
12083  * the end.  The column is initialized with the attributes given. If @tree_view
12084  * has "fixed_height" mode enabled, then the new column will have its sizing
12085  * property set to be GTK_TREE_VIEW_COLUMN_FIXED.
12086  *
12087  * Return value: The number of columns in @tree_view after insertion.
12088  **/
12089 gint
12090 gtk_tree_view_insert_column_with_attributes (GtkTreeView     *tree_view,
12091                                              gint             position,
12092                                              const gchar     *title,
12093                                              GtkCellRenderer *cell,
12094                                              ...)
12095 {
12096   GtkTreeViewColumn *column;
12097   gchar *attribute;
12098   va_list args;
12099   gint column_id;
12100
12101   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
12102
12103   column = gtk_tree_view_column_new ();
12104   if (tree_view->priv->fixed_height_mode)
12105     gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED);
12106
12107   gtk_tree_view_column_set_title (column, title);
12108   gtk_tree_view_column_pack_start (column, cell, TRUE);
12109
12110   va_start (args, cell);
12111
12112   attribute = va_arg (args, gchar *);
12113
12114   while (attribute != NULL)
12115     {
12116       column_id = va_arg (args, gint);
12117       gtk_tree_view_column_add_attribute (column, cell, attribute, column_id);
12118       attribute = va_arg (args, gchar *);
12119     }
12120
12121   va_end (args);
12122
12123   return gtk_tree_view_insert_column (tree_view, column, position);
12124 }
12125
12126 /**
12127  * gtk_tree_view_insert_column_with_data_func:
12128  * @tree_view: a #GtkTreeView
12129  * @position: Position to insert, -1 for append
12130  * @title: column title
12131  * @cell: cell renderer for column
12132  * @func: function to set attributes of cell renderer
12133  * @data: data for @func
12134  * @dnotify: destroy notifier for @data
12135  *
12136  * Convenience function that inserts a new column into the #GtkTreeView
12137  * with the given cell renderer and a #GtkTreeCellDataFunc to set cell renderer
12138  * attributes (normally using data from the model). See also
12139  * gtk_tree_view_column_set_cell_data_func(), gtk_tree_view_column_pack_start().
12140  * If @tree_view has "fixed_height" mode enabled, then the new column will have its
12141  * "sizing" property set to be GTK_TREE_VIEW_COLUMN_FIXED.
12142  *
12143  * Return value: number of columns in the tree view post-insert
12144  **/
12145 gint
12146 gtk_tree_view_insert_column_with_data_func  (GtkTreeView               *tree_view,
12147                                              gint                       position,
12148                                              const gchar               *title,
12149                                              GtkCellRenderer           *cell,
12150                                              GtkTreeCellDataFunc        func,
12151                                              gpointer                   data,
12152                                              GDestroyNotify             dnotify)
12153 {
12154   GtkTreeViewColumn *column;
12155
12156   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
12157
12158   column = gtk_tree_view_column_new ();
12159   if (tree_view->priv->fixed_height_mode)
12160     gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED);
12161
12162   gtk_tree_view_column_set_title (column, title);
12163   gtk_tree_view_column_pack_start (column, cell, TRUE);
12164   gtk_tree_view_column_set_cell_data_func (column, cell, func, data, dnotify);
12165
12166   return gtk_tree_view_insert_column (tree_view, column, position);
12167 }
12168
12169 /**
12170  * gtk_tree_view_get_n_columns:
12171  * @tree_view: a #GtkTreeView
12172  *
12173  * Queries the number of columns in the given @tree_view.
12174  *
12175  * Returns: The number of columns in the @tree_view
12176  *
12177  * Since: 3.4
12178  **/
12179 guint
12180 gtk_tree_view_get_n_columns (GtkTreeView *tree_view)
12181 {
12182   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), 0);
12183
12184   return tree_view->priv->n_columns;
12185 }
12186
12187 /**
12188  * gtk_tree_view_get_column:
12189  * @tree_view: A #GtkTreeView.
12190  * @n: The position of the column, counting from 0.
12191  *
12192  * Gets the #GtkTreeViewColumn at the given position in the #tree_view.
12193  *
12194  * Return value: (transfer none): The #GtkTreeViewColumn, or %NULL if the
12195  *     position is outside the range of columns.
12196  **/
12197 GtkTreeViewColumn *
12198 gtk_tree_view_get_column (GtkTreeView *tree_view,
12199                           gint         n)
12200 {
12201   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
12202
12203   if (n < 0 || n >= tree_view->priv->n_columns)
12204     return NULL;
12205
12206   if (tree_view->priv->columns == NULL)
12207     return NULL;
12208
12209   return GTK_TREE_VIEW_COLUMN (g_list_nth (tree_view->priv->columns, n)->data);
12210 }
12211
12212 /**
12213  * gtk_tree_view_get_columns:
12214  * @tree_view: A #GtkTreeView
12215  *
12216  * Returns a #GList of all the #GtkTreeViewColumn s currently in @tree_view.
12217  * The returned list must be freed with g_list_free ().
12218  *
12219  * Return value: (element-type GtkTreeViewColumn) (transfer container): A list of #GtkTreeViewColumn s
12220  **/
12221 GList *
12222 gtk_tree_view_get_columns (GtkTreeView *tree_view)
12223 {
12224   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
12225
12226   return g_list_copy (tree_view->priv->columns);
12227 }
12228
12229 /**
12230  * gtk_tree_view_move_column_after:
12231  * @tree_view: A #GtkTreeView
12232  * @column: The #GtkTreeViewColumn to be moved.
12233  * @base_column: (allow-none): The #GtkTreeViewColumn to be moved relative to, or %NULL.
12234  *
12235  * Moves @column to be after to @base_column.  If @base_column is %NULL, then
12236  * @column is placed in the first position.
12237  **/
12238 void
12239 gtk_tree_view_move_column_after (GtkTreeView       *tree_view,
12240                                  GtkTreeViewColumn *column,
12241                                  GtkTreeViewColumn *base_column)
12242 {
12243   GList *column_list_el, *base_el = NULL;
12244
12245   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12246
12247   column_list_el = g_list_find (tree_view->priv->columns, column);
12248   g_return_if_fail (column_list_el != NULL);
12249
12250   if (base_column)
12251     {
12252       base_el = g_list_find (tree_view->priv->columns, base_column);
12253       g_return_if_fail (base_el != NULL);
12254     }
12255
12256   if (column_list_el->prev == base_el)
12257     return;
12258
12259   tree_view->priv->columns = g_list_remove_link (tree_view->priv->columns, column_list_el);
12260   if (base_el == NULL)
12261     {
12262       column_list_el->prev = NULL;
12263       column_list_el->next = tree_view->priv->columns;
12264       if (column_list_el->next)
12265         column_list_el->next->prev = column_list_el;
12266       tree_view->priv->columns = column_list_el;
12267     }
12268   else
12269     {
12270       column_list_el->prev = base_el;
12271       column_list_el->next = base_el->next;
12272       if (column_list_el->next)
12273         column_list_el->next->prev = column_list_el;
12274       base_el->next = column_list_el;
12275     }
12276
12277   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
12278     {
12279       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
12280       gtk_tree_view_size_allocate_columns (GTK_WIDGET (tree_view), NULL);
12281     }
12282
12283   _gtk_tree_view_reset_header_styles (tree_view);
12284
12285   _gtk_tree_view_accessible_reorder_column (tree_view, column);
12286
12287   g_signal_emit (tree_view, tree_view_signals[COLUMNS_CHANGED], 0);
12288 }
12289
12290 /**
12291  * gtk_tree_view_set_expander_column:
12292  * @tree_view: A #GtkTreeView
12293  * @column: %NULL, or the column to draw the expander arrow at.
12294  *
12295  * Sets the column to draw the expander arrow at. It must be in @tree_view.
12296  * If @column is %NULL, then the expander arrow is always at the first
12297  * visible column.
12298  *
12299  * If you do not want expander arrow to appear in your tree, set the
12300  * expander column to a hidden column.
12301  **/
12302 void
12303 gtk_tree_view_set_expander_column (GtkTreeView       *tree_view,
12304                                    GtkTreeViewColumn *column)
12305 {
12306   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12307   g_return_if_fail (column == NULL || GTK_IS_TREE_VIEW_COLUMN (column));
12308   g_return_if_fail (column == NULL || gtk_tree_view_column_get_tree_view (column) == GTK_WIDGET (tree_view));
12309
12310   if (tree_view->priv->expander_column != column)
12311     {
12312       tree_view->priv->expander_column = column;
12313       g_object_notify (G_OBJECT (tree_view), "expander-column");
12314     }
12315 }
12316
12317 /**
12318  * gtk_tree_view_get_expander_column:
12319  * @tree_view: A #GtkTreeView
12320  *
12321  * Returns the column that is the current expander column.
12322  * This column has the expander arrow drawn next to it.
12323  *
12324  * Return value: (transfer none): The expander column.
12325  **/
12326 GtkTreeViewColumn *
12327 gtk_tree_view_get_expander_column (GtkTreeView *tree_view)
12328 {
12329   GList *list;
12330
12331   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
12332
12333   for (list = tree_view->priv->columns; list; list = list->next)
12334     if (gtk_tree_view_is_expander_column (tree_view, GTK_TREE_VIEW_COLUMN (list->data)))
12335       return (GtkTreeViewColumn *) list->data;
12336   return NULL;
12337 }
12338
12339
12340 /**
12341  * gtk_tree_view_set_column_drag_function:
12342  * @tree_view: A #GtkTreeView.
12343  * @func: (allow-none): A function to determine which columns are reorderable, or %NULL.
12344  * @user_data: (allow-none): User data to be passed to @func, or %NULL
12345  * @destroy: (allow-none): Destroy notifier for @user_data, or %NULL
12346  *
12347  * Sets a user function for determining where a column may be dropped when
12348  * dragged.  This function is called on every column pair in turn at the
12349  * beginning of a column drag to determine where a drop can take place.  The
12350  * arguments passed to @func are: the @tree_view, the #GtkTreeViewColumn being
12351  * dragged, the two #GtkTreeViewColumn s determining the drop spot, and
12352  * @user_data.  If either of the #GtkTreeViewColumn arguments for the drop spot
12353  * are %NULL, then they indicate an edge.  If @func is set to be %NULL, then
12354  * @tree_view reverts to the default behavior of allowing all columns to be
12355  * dropped everywhere.
12356  **/
12357 void
12358 gtk_tree_view_set_column_drag_function (GtkTreeView               *tree_view,
12359                                         GtkTreeViewColumnDropFunc  func,
12360                                         gpointer                   user_data,
12361                                         GDestroyNotify             destroy)
12362 {
12363   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12364
12365   if (tree_view->priv->column_drop_func_data_destroy)
12366     tree_view->priv->column_drop_func_data_destroy (tree_view->priv->column_drop_func_data);
12367
12368   tree_view->priv->column_drop_func = func;
12369   tree_view->priv->column_drop_func_data = user_data;
12370   tree_view->priv->column_drop_func_data_destroy = destroy;
12371 }
12372
12373 /**
12374  * gtk_tree_view_scroll_to_point:
12375  * @tree_view: a #GtkTreeView
12376  * @tree_x: X coordinate of new top-left pixel of visible area, or -1
12377  * @tree_y: Y coordinate of new top-left pixel of visible area, or -1
12378  *
12379  * Scrolls the tree view such that the top-left corner of the visible
12380  * area is @tree_x, @tree_y, where @tree_x and @tree_y are specified
12381  * in tree coordinates.  The @tree_view must be realized before
12382  * this function is called.  If it isn't, you probably want to be
12383  * using gtk_tree_view_scroll_to_cell().
12384  *
12385  * If either @tree_x or @tree_y are -1, then that direction isn't scrolled.
12386  **/
12387 void
12388 gtk_tree_view_scroll_to_point (GtkTreeView *tree_view,
12389                                gint         tree_x,
12390                                gint         tree_y)
12391 {
12392   GtkAdjustment *hadj;
12393   GtkAdjustment *vadj;
12394
12395   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12396   g_return_if_fail (gtk_widget_get_realized (GTK_WIDGET (tree_view)));
12397
12398   hadj = tree_view->priv->hadjustment;
12399   vadj = tree_view->priv->vadjustment;
12400
12401   if (tree_x != -1)
12402     gtk_adjustment_set_value (hadj, tree_x);
12403   if (tree_y != -1)
12404     gtk_adjustment_set_value (vadj, tree_y);
12405 }
12406
12407 /**
12408  * gtk_tree_view_scroll_to_cell:
12409  * @tree_view: A #GtkTreeView.
12410  * @path: (allow-none): The path of the row to move to, or %NULL.
12411  * @column: (allow-none): The #GtkTreeViewColumn to move horizontally to, or %NULL.
12412  * @use_align: whether to use alignment arguments, or %FALSE.
12413  * @row_align: The vertical alignment of the row specified by @path.
12414  * @col_align: The horizontal alignment of the column specified by @column.
12415  *
12416  * Moves the alignments of @tree_view to the position specified by @column and
12417  * @path.  If @column is %NULL, then no horizontal scrolling occurs.  Likewise,
12418  * if @path is %NULL no vertical scrolling occurs.  At a minimum, one of @column
12419  * or @path need to be non-%NULL.  @row_align determines where the row is
12420  * placed, and @col_align determines where @column is placed.  Both are expected
12421  * to be between 0.0 and 1.0. 0.0 means left/top alignment, 1.0 means
12422  * right/bottom alignment, 0.5 means center.
12423  *
12424  * If @use_align is %FALSE, then the alignment arguments are ignored, and the
12425  * tree does the minimum amount of work to scroll the cell onto the screen.
12426  * This means that the cell will be scrolled to the edge closest to its current
12427  * position.  If the cell is currently visible on the screen, nothing is done.
12428  *
12429  * This function only works if the model is set, and @path is a valid row on the
12430  * model.  If the model changes before the @tree_view is realized, the centered
12431  * path will be modified to reflect this change.
12432  **/
12433 void
12434 gtk_tree_view_scroll_to_cell (GtkTreeView       *tree_view,
12435                               GtkTreePath       *path,
12436                               GtkTreeViewColumn *column,
12437                               gboolean           use_align,
12438                               gfloat             row_align,
12439                               gfloat             col_align)
12440 {
12441   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12442   g_return_if_fail (tree_view->priv->model != NULL);
12443   g_return_if_fail (tree_view->priv->tree != NULL);
12444   g_return_if_fail (row_align >= 0.0 && row_align <= 1.0);
12445   g_return_if_fail (col_align >= 0.0 && col_align <= 1.0);
12446   g_return_if_fail (path != NULL || column != NULL);
12447
12448 #if 0
12449   g_print ("gtk_tree_view_scroll_to_cell:\npath: %s\ncolumn: %s\nuse_align: %d\nrow_align: %f\ncol_align: %f\n",
12450            gtk_tree_path_to_string (path), column?"non-null":"null", use_align, row_align, col_align);
12451 #endif
12452   row_align = CLAMP (row_align, 0.0, 1.0);
12453   col_align = CLAMP (col_align, 0.0, 1.0);
12454
12455
12456   /* Note: Despite the benefits that come from having one code path for the
12457    * scrolling code, we short-circuit validate_visible_area's immplementation as
12458    * it is much slower than just going to the point.
12459    */
12460   if (!gtk_widget_get_visible (GTK_WIDGET (tree_view)) ||
12461       !gtk_widget_get_realized (GTK_WIDGET (tree_view)) ||
12462       _gtk_widget_get_alloc_needed (GTK_WIDGET (tree_view)) ||
12463       GTK_RBNODE_FLAG_SET (tree_view->priv->tree->root, GTK_RBNODE_DESCENDANTS_INVALID))
12464     {
12465       if (tree_view->priv->scroll_to_path)
12466         gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
12467
12468       tree_view->priv->scroll_to_path = NULL;
12469       tree_view->priv->scroll_to_column = NULL;
12470
12471       if (path)
12472         tree_view->priv->scroll_to_path = gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view), tree_view->priv->model, path);
12473       if (column)
12474         tree_view->priv->scroll_to_column = column;
12475       tree_view->priv->scroll_to_use_align = use_align;
12476       tree_view->priv->scroll_to_row_align = row_align;
12477       tree_view->priv->scroll_to_col_align = col_align;
12478
12479       install_presize_handler (tree_view);
12480     }
12481   else
12482     {
12483       GdkRectangle cell_rect;
12484       GdkRectangle vis_rect;
12485       gint dest_x, dest_y;
12486
12487       gtk_tree_view_get_background_area (tree_view, path, column, &cell_rect);
12488       gtk_tree_view_get_visible_rect (tree_view, &vis_rect);
12489
12490       cell_rect.y = TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, cell_rect.y);
12491
12492       dest_x = vis_rect.x;
12493       dest_y = vis_rect.y;
12494
12495       if (column)
12496         {
12497           if (use_align)
12498             {
12499               dest_x = cell_rect.x - ((vis_rect.width - cell_rect.width) * col_align);
12500             }
12501           else
12502             {
12503               if (cell_rect.x < vis_rect.x)
12504                 dest_x = cell_rect.x;
12505               if (cell_rect.x + cell_rect.width > vis_rect.x + vis_rect.width)
12506                 dest_x = cell_rect.x + cell_rect.width - vis_rect.width;
12507             }
12508         }
12509
12510       if (path)
12511         {
12512           if (use_align)
12513             {
12514               dest_y = cell_rect.y - ((vis_rect.height - cell_rect.height) * row_align);
12515               dest_y = MAX (dest_y, 0);
12516             }
12517           else
12518             {
12519               if (cell_rect.y < vis_rect.y)
12520                 dest_y = cell_rect.y;
12521               if (cell_rect.y + cell_rect.height > vis_rect.y + vis_rect.height)
12522                 dest_y = cell_rect.y + cell_rect.height - vis_rect.height;
12523             }
12524         }
12525
12526       gtk_tree_view_scroll_to_point (tree_view, dest_x, dest_y);
12527     }
12528 }
12529
12530 /**
12531  * gtk_tree_view_row_activated:
12532  * @tree_view: A #GtkTreeView
12533  * @path: The #GtkTreePath to be activated.
12534  * @column: The #GtkTreeViewColumn to be activated.
12535  *
12536  * Activates the cell determined by @path and @column.
12537  **/
12538 void
12539 gtk_tree_view_row_activated (GtkTreeView       *tree_view,
12540                              GtkTreePath       *path,
12541                              GtkTreeViewColumn *column)
12542 {
12543   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12544
12545   g_signal_emit (tree_view, tree_view_signals[ROW_ACTIVATED], 0, path, column);
12546 }
12547
12548
12549 static void
12550 gtk_tree_view_expand_all_emission_helper (GtkRBTree *tree,
12551                                           GtkRBNode *node,
12552                                           gpointer   data)
12553 {
12554   GtkTreeView *tree_view = data;
12555
12556   if ((node->flags & GTK_RBNODE_IS_PARENT) == GTK_RBNODE_IS_PARENT &&
12557       node->children)
12558     {
12559       GtkTreePath *path;
12560       GtkTreeIter iter;
12561
12562       path = _gtk_tree_path_new_from_rbtree (tree, node);
12563       gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
12564
12565       g_signal_emit (tree_view, tree_view_signals[ROW_EXPANDED], 0, &iter, path);
12566
12567       gtk_tree_path_free (path);
12568     }
12569
12570   if (node->children)
12571     _gtk_rbtree_traverse (node->children,
12572                           node->children->root,
12573                           G_PRE_ORDER,
12574                           gtk_tree_view_expand_all_emission_helper,
12575                           tree_view);
12576 }
12577
12578 /**
12579  * gtk_tree_view_expand_all:
12580  * @tree_view: A #GtkTreeView.
12581  *
12582  * Recursively expands all nodes in the @tree_view.
12583  **/
12584 void
12585 gtk_tree_view_expand_all (GtkTreeView *tree_view)
12586 {
12587   GtkTreePath *path;
12588   GtkRBTree *tree;
12589   GtkRBNode *node;
12590
12591   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12592
12593   if (tree_view->priv->tree == NULL)
12594     return;
12595
12596   path = gtk_tree_path_new_first ();
12597   _gtk_tree_view_find_node (tree_view, path, &tree, &node);
12598
12599   while (node)
12600     {
12601       gtk_tree_view_real_expand_row (tree_view, path, tree, node, TRUE, FALSE);
12602       node = _gtk_rbtree_next (tree, node);
12603       gtk_tree_path_next (path);
12604   }
12605
12606   gtk_tree_path_free (path);
12607 }
12608
12609 /**
12610  * gtk_tree_view_collapse_all:
12611  * @tree_view: A #GtkTreeView.
12612  *
12613  * Recursively collapses all visible, expanded nodes in @tree_view.
12614  **/
12615 void
12616 gtk_tree_view_collapse_all (GtkTreeView *tree_view)
12617 {
12618   GtkRBTree *tree;
12619   GtkRBNode *node;
12620   GtkTreePath *path;
12621   gint *indices;
12622
12623   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12624
12625   if (tree_view->priv->tree == NULL)
12626     return;
12627
12628   path = gtk_tree_path_new ();
12629   gtk_tree_path_down (path);
12630   indices = gtk_tree_path_get_indices (path);
12631
12632   tree = tree_view->priv->tree;
12633   node = _gtk_rbtree_first (tree);
12634
12635   while (node)
12636     {
12637       if (node->children)
12638         gtk_tree_view_real_collapse_row (tree_view, path, tree, node, FALSE);
12639       indices[0]++;
12640       node = _gtk_rbtree_next (tree, node);
12641     }
12642
12643   gtk_tree_path_free (path);
12644 }
12645
12646 /**
12647  * gtk_tree_view_expand_to_path:
12648  * @tree_view: A #GtkTreeView.
12649  * @path: path to a row.
12650  *
12651  * Expands the row at @path. This will also expand all parent rows of
12652  * @path as necessary.
12653  *
12654  * Since: 2.2
12655  **/
12656 void
12657 gtk_tree_view_expand_to_path (GtkTreeView *tree_view,
12658                               GtkTreePath *path)
12659 {
12660   gint i, depth;
12661   gint *indices;
12662   GtkTreePath *tmp;
12663
12664   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12665   g_return_if_fail (path != NULL);
12666
12667   depth = gtk_tree_path_get_depth (path);
12668   indices = gtk_tree_path_get_indices (path);
12669
12670   tmp = gtk_tree_path_new ();
12671   g_return_if_fail (tmp != NULL);
12672
12673   for (i = 0; i < depth; i++)
12674     {
12675       gtk_tree_path_append_index (tmp, indices[i]);
12676       gtk_tree_view_expand_row (tree_view, tmp, FALSE);
12677     }
12678
12679   gtk_tree_path_free (tmp);
12680 }
12681
12682 /* FIXME the bool return values for expand_row and collapse_row are
12683  * not analagous; they should be TRUE if the row had children and
12684  * was not already in the requested state.
12685  */
12686
12687
12688 static gboolean
12689 gtk_tree_view_real_expand_row (GtkTreeView *tree_view,
12690                                GtkTreePath *path,
12691                                GtkRBTree   *tree,
12692                                GtkRBNode   *node,
12693                                gboolean     open_all,
12694                                gboolean     animate)
12695 {
12696   GtkTreeIter iter;
12697   GtkTreeIter temp;
12698   gboolean expand;
12699
12700   if (animate)
12701     g_object_get (gtk_widget_get_settings (GTK_WIDGET (tree_view)),
12702                   "gtk-enable-animations", &animate,
12703                   NULL);
12704
12705   remove_auto_expand_timeout (tree_view);
12706
12707   if (node->children && !open_all)
12708     return FALSE;
12709
12710   if (! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT))
12711     return FALSE;
12712
12713   gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
12714   if (! gtk_tree_model_iter_has_child (tree_view->priv->model, &iter))
12715     return FALSE;
12716
12717
12718    if (node->children && open_all)
12719     {
12720       gboolean retval = FALSE;
12721       GtkTreePath *tmp_path = gtk_tree_path_copy (path);
12722
12723       gtk_tree_path_append_index (tmp_path, 0);
12724       tree = node->children;
12725       node = _gtk_rbtree_first (tree);
12726       /* try to expand the children */
12727       do
12728         {
12729          gboolean t;
12730          t = gtk_tree_view_real_expand_row (tree_view, tmp_path, tree, node,
12731                                             TRUE, animate);
12732          if (t)
12733            retval = TRUE;
12734
12735          gtk_tree_path_next (tmp_path);
12736          node = _gtk_rbtree_next (tree, node);
12737        }
12738       while (node != NULL);
12739
12740       gtk_tree_path_free (tmp_path);
12741
12742       return retval;
12743     }
12744
12745   g_signal_emit (tree_view, tree_view_signals[TEST_EXPAND_ROW], 0, &iter, path, &expand);
12746
12747   if (!gtk_tree_model_iter_has_child (tree_view->priv->model, &iter))
12748     return FALSE;
12749
12750   if (expand)
12751     return FALSE;
12752
12753   node->children = _gtk_rbtree_new ();
12754   node->children->parent_tree = tree;
12755   node->children->parent_node = node;
12756
12757   gtk_tree_model_iter_children (tree_view->priv->model, &temp, &iter);
12758
12759   gtk_tree_view_build_tree (tree_view,
12760                             node->children,
12761                             &temp,
12762                             gtk_tree_path_get_depth (path) + 1,
12763                             open_all);
12764
12765   _gtk_tree_view_accessible_add (tree_view, node->children, NULL);
12766   _gtk_tree_view_accessible_add_state (tree_view,
12767                                        tree, node,
12768                                        GTK_CELL_RENDERER_EXPANDED);
12769
12770   install_presize_handler (tree_view);
12771
12772   g_signal_emit (tree_view, tree_view_signals[ROW_EXPANDED], 0, &iter, path);
12773   if (open_all && node->children)
12774     {
12775       _gtk_rbtree_traverse (node->children,
12776                             node->children->root,
12777                             G_PRE_ORDER,
12778                             gtk_tree_view_expand_all_emission_helper,
12779                             tree_view);
12780     }
12781   return TRUE;
12782 }
12783
12784
12785 /**
12786  * gtk_tree_view_expand_row:
12787  * @tree_view: a #GtkTreeView
12788  * @path: path to a row
12789  * @open_all: whether to recursively expand, or just expand immediate children
12790  *
12791  * Opens the row so its children are visible.
12792  *
12793  * Return value: %TRUE if the row existed and had children
12794  **/
12795 gboolean
12796 gtk_tree_view_expand_row (GtkTreeView *tree_view,
12797                           GtkTreePath *path,
12798                           gboolean     open_all)
12799 {
12800   GtkRBTree *tree;
12801   GtkRBNode *node;
12802
12803   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
12804   g_return_val_if_fail (tree_view->priv->model != NULL, FALSE);
12805   g_return_val_if_fail (path != NULL, FALSE);
12806
12807   if (_gtk_tree_view_find_node (tree_view,
12808                                 path,
12809                                 &tree,
12810                                 &node))
12811     return FALSE;
12812
12813   if (tree != NULL)
12814     return gtk_tree_view_real_expand_row (tree_view, path, tree, node, open_all, FALSE);
12815   else
12816     return FALSE;
12817 }
12818
12819 static gboolean
12820 gtk_tree_view_real_collapse_row (GtkTreeView *tree_view,
12821                                  GtkTreePath *path,
12822                                  GtkRBTree   *tree,
12823                                  GtkRBNode   *node,
12824                                  gboolean     animate)
12825 {
12826   GtkTreeIter iter;
12827   GtkTreeIter children;
12828   gboolean collapse;
12829   gint x, y;
12830   GList *list;
12831   GdkWindow *child;
12832   gboolean selection_changed, cursor_changed;
12833
12834   if (animate)
12835     g_object_get (gtk_widget_get_settings (GTK_WIDGET (tree_view)),
12836                   "gtk-enable-animations", &animate,
12837                   NULL);
12838
12839   remove_auto_expand_timeout (tree_view);
12840
12841   if (node->children == NULL)
12842     return FALSE;
12843   gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
12844
12845   g_signal_emit (tree_view, tree_view_signals[TEST_COLLAPSE_ROW], 0, &iter, path, &collapse);
12846
12847   if (collapse)
12848     return FALSE;
12849
12850   /* if the prelighted node is a child of us, we want to unprelight it.  We have
12851    * a chance to prelight the correct node below */
12852
12853   if (tree_view->priv->prelight_tree)
12854     {
12855       GtkRBTree *parent_tree;
12856       GtkRBNode *parent_node;
12857
12858       parent_tree = tree_view->priv->prelight_tree->parent_tree;
12859       parent_node = tree_view->priv->prelight_tree->parent_node;
12860       while (parent_tree)
12861         {
12862           if (parent_tree == tree && parent_node == node)
12863             {
12864               ensure_unprelighted (tree_view);
12865               break;
12866             }
12867           parent_node = parent_tree->parent_node;
12868           parent_tree = parent_tree->parent_tree;
12869         }
12870     }
12871
12872   TREE_VIEW_INTERNAL_ASSERT (gtk_tree_model_iter_children (tree_view->priv->model, &children, &iter), FALSE);
12873
12874   for (list = tree_view->priv->columns; list; list = list->next)
12875     {
12876       GtkTreeViewColumn *column = list->data;
12877
12878       if (gtk_tree_view_column_get_visible (column) == FALSE)
12879         continue;
12880       if (gtk_tree_view_column_get_sizing (column) == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
12881         _gtk_tree_view_column_cell_set_dirty (column, TRUE);
12882     }
12883
12884   if (tree_view->priv->destroy_count_func)
12885     {
12886       GtkTreePath *child_path;
12887       gint child_count = 0;
12888       child_path = gtk_tree_path_copy (path);
12889       gtk_tree_path_down (child_path);
12890       if (node->children)
12891         _gtk_rbtree_traverse (node->children, node->children->root, G_POST_ORDER, count_children_helper, &child_count);
12892       tree_view->priv->destroy_count_func (tree_view, child_path, child_count, tree_view->priv->destroy_count_data);
12893       gtk_tree_path_free (child_path);
12894     }
12895
12896   if (tree_view->priv->cursor_node)
12897     {
12898       cursor_changed = (node->children == tree_view->priv->cursor_tree)
12899                        || _gtk_rbtree_contains (node->children, tree_view->priv->cursor_tree);
12900     }
12901   else
12902     cursor_changed = FALSE;
12903
12904   if (gtk_tree_row_reference_valid (tree_view->priv->anchor))
12905     {
12906       GtkTreePath *anchor_path = gtk_tree_row_reference_get_path (tree_view->priv->anchor);
12907       if (gtk_tree_path_is_ancestor (path, anchor_path))
12908         {
12909           gtk_tree_row_reference_free (tree_view->priv->anchor);
12910           tree_view->priv->anchor = NULL;
12911         }
12912       gtk_tree_path_free (anchor_path);
12913     }
12914
12915   selection_changed = gtk_tree_view_unref_and_check_selection_tree (tree_view, node->children);
12916
12917   /* Stop a pending double click */
12918   tree_view->priv->last_button_x = -1;
12919   tree_view->priv->last_button_y = -1;
12920
12921   _gtk_tree_view_accessible_remove (tree_view, node->children, NULL);
12922   _gtk_tree_view_accessible_remove_state (tree_view,
12923                                           tree, node,
12924                                           GTK_CELL_RENDERER_EXPANDED);
12925
12926   _gtk_rbtree_remove (node->children);
12927
12928   if (cursor_changed)
12929     gtk_tree_view_real_set_cursor (tree_view, path, CLEAR_AND_SELECT | CURSOR_INVALID);
12930   if (selection_changed)
12931     g_signal_emit_by_name (tree_view->priv->selection, "changed");
12932
12933   if (gtk_widget_get_mapped (GTK_WIDGET (tree_view)))
12934     {
12935       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
12936     }
12937
12938   g_signal_emit (tree_view, tree_view_signals[ROW_COLLAPSED], 0, &iter, path);
12939
12940   if (gtk_widget_get_mapped (GTK_WIDGET (tree_view)))
12941     {
12942       /* now that we've collapsed all rows, we want to try to set the prelight
12943        * again. To do this, we fake a motion event and send it to ourselves. */
12944
12945       child = gdk_window_get_device_position (gdk_window_get_parent (tree_view->priv->bin_window),
12946                                               gdk_device_manager_get_client_pointer (
12947                                                 gdk_display_get_device_manager (
12948                                                   gtk_widget_get_display (GTK_WIDGET (tree_view)))),
12949                                               &x, &y, NULL);
12950       if (child == tree_view->priv->bin_window)
12951         {
12952           GdkEventMotion event;
12953           gint child_x, child_y;
12954
12955           gdk_window_get_position (child, &child_x, &child_y);
12956
12957           event.window = tree_view->priv->bin_window;
12958           event.x = x - child_x;
12959           event.y = y - child_y;
12960
12961           /* despite the fact this isn't a real event, I'm almost positive it will
12962            * never trigger a drag event.  maybe_drag is the only function that uses
12963            * more than just event.x and event.y. */
12964           gtk_tree_view_motion_bin_window (GTK_WIDGET (tree_view), &event);
12965         }
12966     }
12967
12968   return TRUE;
12969 }
12970
12971 /**
12972  * gtk_tree_view_collapse_row:
12973  * @tree_view: a #GtkTreeView
12974  * @path: path to a row in the @tree_view
12975  *
12976  * Collapses a row (hides its child rows, if they exist).
12977  *
12978  * Return value: %TRUE if the row was collapsed.
12979  **/
12980 gboolean
12981 gtk_tree_view_collapse_row (GtkTreeView *tree_view,
12982                             GtkTreePath *path)
12983 {
12984   GtkRBTree *tree;
12985   GtkRBNode *node;
12986
12987   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
12988   g_return_val_if_fail (tree_view->priv->tree != NULL, FALSE);
12989   g_return_val_if_fail (path != NULL, FALSE);
12990
12991   if (_gtk_tree_view_find_node (tree_view,
12992                                 path,
12993                                 &tree,
12994                                 &node))
12995     return FALSE;
12996
12997   if (tree == NULL || node->children == NULL)
12998     return FALSE;
12999
13000   return gtk_tree_view_real_collapse_row (tree_view, path, tree, node, FALSE);
13001 }
13002
13003 static void
13004 gtk_tree_view_map_expanded_rows_helper (GtkTreeView            *tree_view,
13005                                         GtkRBTree              *tree,
13006                                         GtkTreePath            *path,
13007                                         GtkTreeViewMappingFunc  func,
13008                                         gpointer                user_data)
13009 {
13010   GtkRBNode *node;
13011
13012   if (tree == NULL || tree->root == NULL)
13013     return;
13014
13015   node = _gtk_rbtree_first (tree);
13016
13017   while (node)
13018     {
13019       if (node->children)
13020         {
13021           (* func) (tree_view, path, user_data);
13022           gtk_tree_path_down (path);
13023           gtk_tree_view_map_expanded_rows_helper (tree_view, node->children, path, func, user_data);
13024           gtk_tree_path_up (path);
13025         }
13026       gtk_tree_path_next (path);
13027       node = _gtk_rbtree_next (tree, node);
13028     }
13029 }
13030
13031 /**
13032  * gtk_tree_view_map_expanded_rows:
13033  * @tree_view: A #GtkTreeView
13034  * @func: (scope call): A function to be called
13035  * @data: User data to be passed to the function.
13036  *
13037  * Calls @func on all expanded rows.
13038  **/
13039 void
13040 gtk_tree_view_map_expanded_rows (GtkTreeView            *tree_view,
13041                                  GtkTreeViewMappingFunc  func,
13042                                  gpointer                user_data)
13043 {
13044   GtkTreePath *path;
13045
13046   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13047   g_return_if_fail (func != NULL);
13048
13049   path = gtk_tree_path_new_first ();
13050
13051   gtk_tree_view_map_expanded_rows_helper (tree_view,
13052                                           tree_view->priv->tree,
13053                                           path, func, user_data);
13054
13055   gtk_tree_path_free (path);
13056 }
13057
13058 /**
13059  * gtk_tree_view_row_expanded:
13060  * @tree_view: A #GtkTreeView.
13061  * @path: A #GtkTreePath to test expansion state.
13062  *
13063  * Returns %TRUE if the node pointed to by @path is expanded in @tree_view.
13064  *
13065  * Return value: %TRUE if #path is expanded.
13066  **/
13067 gboolean
13068 gtk_tree_view_row_expanded (GtkTreeView *tree_view,
13069                             GtkTreePath *path)
13070 {
13071   GtkRBTree *tree;
13072   GtkRBNode *node;
13073
13074   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
13075   g_return_val_if_fail (path != NULL, FALSE);
13076
13077   _gtk_tree_view_find_node (tree_view, path, &tree, &node);
13078
13079   if (node == NULL)
13080     return FALSE;
13081
13082   return (node->children != NULL);
13083 }
13084
13085 /**
13086  * gtk_tree_view_get_reorderable:
13087  * @tree_view: a #GtkTreeView
13088  *
13089  * Retrieves whether the user can reorder the tree via drag-and-drop. See
13090  * gtk_tree_view_set_reorderable().
13091  *
13092  * Return value: %TRUE if the tree can be reordered.
13093  **/
13094 gboolean
13095 gtk_tree_view_get_reorderable (GtkTreeView *tree_view)
13096 {
13097   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
13098
13099   return tree_view->priv->reorderable;
13100 }
13101
13102 /**
13103  * gtk_tree_view_set_reorderable:
13104  * @tree_view: A #GtkTreeView.
13105  * @reorderable: %TRUE, if the tree can be reordered.
13106  *
13107  * This function is a convenience function to allow you to reorder
13108  * models that support the #GtkTreeDragSourceIface and the
13109  * #GtkTreeDragDestIface.  Both #GtkTreeStore and #GtkListStore support
13110  * these.  If @reorderable is %TRUE, then the user can reorder the
13111  * model by dragging and dropping rows. The developer can listen to
13112  * these changes by connecting to the model's row_inserted and
13113  * row_deleted signals. The reordering is implemented by setting up
13114  * the tree view as a drag source and destination. Therefore, drag and
13115  * drop can not be used in a reorderable view for any other purpose.
13116  *
13117  * This function does not give you any degree of control over the order -- any
13118  * reordering is allowed.  If more control is needed, you should probably
13119  * handle drag and drop manually.
13120  **/
13121 void
13122 gtk_tree_view_set_reorderable (GtkTreeView *tree_view,
13123                                gboolean     reorderable)
13124 {
13125   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13126
13127   reorderable = reorderable != FALSE;
13128
13129   if (tree_view->priv->reorderable == reorderable)
13130     return;
13131
13132   if (reorderable)
13133     {
13134       const GtkTargetEntry row_targets[] = {
13135         { "GTK_TREE_MODEL_ROW", GTK_TARGET_SAME_WIDGET, 0 }
13136       };
13137
13138       gtk_tree_view_enable_model_drag_source (tree_view,
13139                                               GDK_BUTTON1_MASK,
13140                                               row_targets,
13141                                               G_N_ELEMENTS (row_targets),
13142                                               GDK_ACTION_MOVE);
13143       gtk_tree_view_enable_model_drag_dest (tree_view,
13144                                             row_targets,
13145                                             G_N_ELEMENTS (row_targets),
13146                                             GDK_ACTION_MOVE);
13147     }
13148   else
13149     {
13150       gtk_tree_view_unset_rows_drag_source (tree_view);
13151       gtk_tree_view_unset_rows_drag_dest (tree_view);
13152     }
13153
13154   tree_view->priv->reorderable = reorderable;
13155
13156   g_object_notify (G_OBJECT (tree_view), "reorderable");
13157 }
13158
13159 static void
13160 gtk_tree_view_real_set_cursor (GtkTreeView     *tree_view,
13161                                GtkTreePath     *path,
13162                                SetCursorFlags   flags)
13163 {
13164   if (!(flags & CURSOR_INVALID) && tree_view->priv->cursor_node)
13165     {
13166       _gtk_tree_view_accessible_remove_state (tree_view,
13167                                               tree_view->priv->cursor_tree,
13168                                               tree_view->priv->cursor_node,
13169                                               GTK_CELL_RENDERER_FOCUSED);
13170       _gtk_tree_view_queue_draw_node (tree_view,
13171                                       tree_view->priv->cursor_tree,
13172                                       tree_view->priv->cursor_node,
13173                                       NULL);
13174     }
13175
13176   /* One cannot set the cursor on a separator.   Also, if
13177    * _gtk_tree_view_find_node returns TRUE, it ran out of tree
13178    * before finding the tree and node belonging to path.  The
13179    * path maps to a non-existing path and we will silently bail out.
13180    * We unset tree and node to avoid further processing.
13181    */
13182   if (path == NULL ||
13183       row_is_separator (tree_view, NULL, path)
13184       || _gtk_tree_view_find_node (tree_view,
13185                                    path,
13186                                    &tree_view->priv->cursor_tree,
13187                                    &tree_view->priv->cursor_node))
13188     {
13189       tree_view->priv->cursor_tree = NULL;
13190       tree_view->priv->cursor_node = NULL;
13191     }
13192
13193   if (tree_view->priv->cursor_node != NULL)
13194     {
13195       GtkRBTree *new_tree = NULL;
13196       GtkRBNode *new_node = NULL;
13197
13198       if ((flags & CLEAR_AND_SELECT) && !tree_view->priv->modify_selection_pressed)
13199         {
13200           GtkTreeSelectMode mode = 0;
13201
13202           if (tree_view->priv->extend_selection_pressed)
13203             mode |= GTK_TREE_SELECT_MODE_EXTEND;
13204
13205           _gtk_tree_selection_internal_select_node (tree_view->priv->selection,
13206                                                     tree_view->priv->cursor_node,
13207                                                     tree_view->priv->cursor_tree,
13208                                                     path,
13209                                                     mode,
13210                                                     FALSE);
13211         }
13212
13213       /* We have to re-find tree and node here again, somebody might have
13214        * cleared the node or the whole tree in the GtkTreeSelection::changed
13215        * callback. If the nodes differ we bail out here.
13216        */
13217       _gtk_tree_view_find_node (tree_view, path, &new_tree, &new_node);
13218
13219       if (tree_view->priv->cursor_node != new_node)
13220         return;
13221
13222       if (flags & CLAMP_NODE)
13223         {
13224           gtk_tree_view_clamp_node_visible (tree_view,
13225                                             tree_view->priv->cursor_tree,
13226                                             tree_view->priv->cursor_node);
13227           _gtk_tree_view_queue_draw_node (tree_view,
13228                                           tree_view->priv->cursor_tree,
13229                                           tree_view->priv->cursor_node,
13230                                           NULL);
13231         }
13232
13233       _gtk_tree_view_accessible_add_state (tree_view,
13234                                            tree_view->priv->cursor_tree,
13235                                            tree_view->priv->cursor_node,
13236                                            GTK_CELL_RENDERER_FOCUSED);
13237     }
13238
13239   g_signal_emit (tree_view, tree_view_signals[CURSOR_CHANGED], 0);
13240 }
13241
13242 /**
13243  * gtk_tree_view_get_cursor:
13244  * @tree_view: A #GtkTreeView
13245  * @path: (out) (transfer full) (allow-none): A pointer to be filled with the current cursor path, or %NULL
13246  * @focus_column: (out) (transfer none) (allow-none): A pointer to be filled with the current focus column, or %NULL
13247  *
13248  * Fills in @path and @focus_column with the current path and focus column.  If
13249  * the cursor isn't currently set, then *@path will be %NULL.  If no column
13250  * currently has focus, then *@focus_column will be %NULL.
13251  *
13252  * The returned #GtkTreePath must be freed with gtk_tree_path_free() when
13253  * you are done with it.
13254  **/
13255 void
13256 gtk_tree_view_get_cursor (GtkTreeView        *tree_view,
13257                           GtkTreePath       **path,
13258                           GtkTreeViewColumn **focus_column)
13259 {
13260   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13261
13262   if (path)
13263     {
13264       if (tree_view->priv->cursor_node)
13265         *path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
13266                                                 tree_view->priv->cursor_node);
13267       else
13268         *path = NULL;
13269     }
13270
13271   if (focus_column)
13272     {
13273       *focus_column = tree_view->priv->focus_column;
13274     }
13275 }
13276
13277 /**
13278  * gtk_tree_view_set_cursor:
13279  * @tree_view: A #GtkTreeView
13280  * @path: A #GtkTreePath
13281  * @focus_column: (allow-none): A #GtkTreeViewColumn, or %NULL
13282  * @start_editing: %TRUE if the specified cell should start being edited.
13283  *
13284  * Sets the current keyboard focus to be at @path, and selects it.  This is
13285  * useful when you want to focus the user's attention on a particular row.  If
13286  * @focus_column is not %NULL, then focus is given to the column specified by
13287  * it. Additionally, if @focus_column is specified, and @start_editing is
13288  * %TRUE, then editing should be started in the specified cell.
13289  * This function is often followed by @gtk_widget_grab_focus (@tree_view)
13290  * in order to give keyboard focus to the widget.  Please note that editing
13291  * can only happen when the widget is realized.
13292  *
13293  * If @path is invalid for @model, the current cursor (if any) will be unset
13294  * and the function will return without failing.
13295  **/
13296 void
13297 gtk_tree_view_set_cursor (GtkTreeView       *tree_view,
13298                           GtkTreePath       *path,
13299                           GtkTreeViewColumn *focus_column,
13300                           gboolean           start_editing)
13301 {
13302   gtk_tree_view_set_cursor_on_cell (tree_view, path, focus_column,
13303                                     NULL, start_editing);
13304 }
13305
13306 /**
13307  * gtk_tree_view_set_cursor_on_cell:
13308  * @tree_view: A #GtkTreeView
13309  * @path: A #GtkTreePath
13310  * @focus_column: (allow-none): A #GtkTreeViewColumn, or %NULL
13311  * @focus_cell: (allow-none): A #GtkCellRenderer, or %NULL
13312  * @start_editing: %TRUE if the specified cell should start being edited.
13313  *
13314  * Sets the current keyboard focus to be at @path, and selects it.  This is
13315  * useful when you want to focus the user's attention on a particular row.  If
13316  * @focus_column is not %NULL, then focus is given to the column specified by
13317  * it. If @focus_column and @focus_cell are not %NULL, and @focus_column
13318  * contains 2 or more editable or activatable cells, then focus is given to
13319  * the cell specified by @focus_cell. Additionally, if @focus_column is
13320  * specified, and @start_editing is %TRUE, then editing should be started in
13321  * the specified cell.  This function is often followed by
13322  * @gtk_widget_grab_focus (@tree_view) in order to give keyboard focus to the
13323  * widget.  Please note that editing can only happen when the widget is
13324  * realized.
13325  *
13326  * If @path is invalid for @model, the current cursor (if any) will be unset
13327  * and the function will return without failing.
13328  *
13329  * Since: 2.2
13330  **/
13331 void
13332 gtk_tree_view_set_cursor_on_cell (GtkTreeView       *tree_view,
13333                                   GtkTreePath       *path,
13334                                   GtkTreeViewColumn *focus_column,
13335                                   GtkCellRenderer   *focus_cell,
13336                                   gboolean           start_editing)
13337 {
13338   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13339   g_return_if_fail (path != NULL);
13340   g_return_if_fail (focus_column == NULL || GTK_IS_TREE_VIEW_COLUMN (focus_column));
13341
13342   if (!tree_view->priv->model)
13343     return;
13344
13345   if (focus_cell)
13346     {
13347       g_return_if_fail (focus_column);
13348       g_return_if_fail (GTK_IS_CELL_RENDERER (focus_cell));
13349     }
13350
13351   /* cancel the current editing, if it exists */
13352   if (tree_view->priv->edited_column &&
13353       gtk_cell_area_get_edit_widget
13354       (gtk_cell_layout_get_area (GTK_CELL_LAYOUT (tree_view->priv->edited_column))))
13355     gtk_tree_view_stop_editing (tree_view, TRUE);
13356
13357   gtk_tree_view_real_set_cursor (tree_view, path, CLEAR_AND_SELECT | CLAMP_NODE);
13358
13359   if (focus_column &&
13360       gtk_tree_view_column_get_visible (focus_column))
13361     {
13362       GList *list;
13363       gboolean column_in_tree = FALSE;
13364
13365       for (list = tree_view->priv->columns; list; list = list->next)
13366         if (list->data == focus_column)
13367           {
13368             column_in_tree = TRUE;
13369             break;
13370           }
13371       g_return_if_fail (column_in_tree);
13372       _gtk_tree_view_set_focus_column (tree_view, focus_column);
13373       if (focus_cell)
13374         gtk_tree_view_column_focus_cell (focus_column, focus_cell);
13375       if (start_editing)
13376         gtk_tree_view_start_editing (tree_view, path, TRUE);
13377     }
13378 }
13379
13380 /**
13381  * gtk_tree_view_get_bin_window:
13382  * @tree_view: A #GtkTreeView
13383  *
13384  * Returns the window that @tree_view renders to.
13385  * This is used primarily to compare to <literal>event->window</literal>
13386  * to confirm that the event on @tree_view is on the right window.
13387  *
13388  * Return value: (transfer none): A #GdkWindow, or %NULL when @tree_view
13389  *     hasn't been realized yet
13390  **/
13391 GdkWindow *
13392 gtk_tree_view_get_bin_window (GtkTreeView *tree_view)
13393 {
13394   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
13395
13396   return tree_view->priv->bin_window;
13397 }
13398
13399 /**
13400  * gtk_tree_view_get_path_at_pos:
13401  * @tree_view: A #GtkTreeView.
13402  * @x: The x position to be identified (relative to bin_window).
13403  * @y: The y position to be identified (relative to bin_window).
13404  * @path: (out) (allow-none): A pointer to a #GtkTreePath pointer to be filled in, or %NULL
13405  * @column: (out) (transfer none) (allow-none): A pointer to a #GtkTreeViewColumn pointer to be filled in, or %NULL
13406  * @cell_x: (out) (allow-none): A pointer where the X coordinate relative to the cell can be placed, or %NULL
13407  * @cell_y: (out) (allow-none): A pointer where the Y coordinate relative to the cell can be placed, or %NULL
13408  *
13409  * Finds the path at the point (@x, @y), relative to bin_window coordinates
13410  * (please see gtk_tree_view_get_bin_window()).
13411  * That is, @x and @y are relative to an events coordinates. @x and @y must
13412  * come from an event on the @tree_view only where <literal>event->window ==
13413  * gtk_tree_view_get_bin_window (<!-- -->)</literal>. It is primarily for
13414  * things like popup menus. If @path is non-%NULL, then it will be filled
13415  * with the #GtkTreePath at that point.  This path should be freed with
13416  * gtk_tree_path_free().  If @column is non-%NULL, then it will be filled
13417  * with the column at that point.  @cell_x and @cell_y return the coordinates
13418  * relative to the cell background (i.e. the @background_area passed to
13419  * gtk_cell_renderer_render()).  This function is only meaningful if
13420  * @tree_view is realized.  Therefore this function will always return %FALSE
13421  * if @tree_view is not realized or does not have a model.
13422  *
13423  * For converting widget coordinates (eg. the ones you get from
13424  * GtkWidget::query-tooltip), please see
13425  * gtk_tree_view_convert_widget_to_bin_window_coords().
13426  *
13427  * Return value: %TRUE if a row exists at that coordinate.
13428  **/
13429 gboolean
13430 gtk_tree_view_get_path_at_pos (GtkTreeView        *tree_view,
13431                                gint                x,
13432                                gint                y,
13433                                GtkTreePath       **path,
13434                                GtkTreeViewColumn **column,
13435                                gint               *cell_x,
13436                                gint               *cell_y)
13437 {
13438   GtkRBTree *tree;
13439   GtkRBNode *node;
13440   gint y_offset;
13441
13442   g_return_val_if_fail (tree_view != NULL, FALSE);
13443
13444   if (path)
13445     *path = NULL;
13446   if (column)
13447     *column = NULL;
13448
13449   if (tree_view->priv->bin_window == NULL)
13450     return FALSE;
13451
13452   if (tree_view->priv->tree == NULL)
13453     return FALSE;
13454
13455   if (x > gtk_adjustment_get_upper (tree_view->priv->hadjustment))
13456     return FALSE;
13457
13458   if (x < 0 || y < 0)
13459     return FALSE;
13460
13461   if (column || cell_x)
13462     {
13463       GtkTreeViewColumn *tmp_column;
13464       GtkTreeViewColumn *last_column = NULL;
13465       GList *list;
13466       gint remaining_x = x;
13467       gboolean found = FALSE;
13468       gboolean rtl;
13469       gint width;
13470
13471       rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
13472       for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
13473            list;
13474            list = (rtl ? list->prev : list->next))
13475         {
13476           tmp_column = list->data;
13477
13478           if (gtk_tree_view_column_get_visible (tmp_column) == FALSE)
13479             continue;
13480
13481           last_column = tmp_column;
13482           width = gtk_tree_view_column_get_width (tmp_column);
13483           if (remaining_x <= width)
13484             {
13485               found = TRUE;
13486
13487               if (column)
13488                 *column = tmp_column;
13489
13490               if (cell_x)
13491                 *cell_x = remaining_x;
13492
13493               break;
13494             }
13495           remaining_x -= width;
13496         }
13497
13498       /* If found is FALSE and there is a last_column, then it the remainder
13499        * space is in that area
13500        */
13501       if (!found)
13502         {
13503           if (last_column)
13504             {
13505               if (column)
13506                 *column = last_column;
13507
13508               if (cell_x)
13509                 *cell_x = gtk_tree_view_column_get_width (last_column) + remaining_x;
13510             }
13511           else
13512             {
13513               return FALSE;
13514             }
13515         }
13516     }
13517
13518   y_offset = _gtk_rbtree_find_offset (tree_view->priv->tree,
13519                                       TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, y),
13520                                       &tree, &node);
13521
13522   if (tree == NULL)
13523     return FALSE;
13524
13525   if (cell_y)
13526     *cell_y = y_offset;
13527
13528   if (path)
13529     *path = _gtk_tree_path_new_from_rbtree (tree, node);
13530
13531   return TRUE;
13532 }
13533
13534
13535 static inline gint
13536 gtk_tree_view_get_cell_area_height (GtkTreeView *tree_view,
13537                                     GtkRBNode   *node,
13538                                     gint         vertical_separator)
13539 {
13540   int expander_size = gtk_tree_view_get_expander_size (tree_view);
13541   int height;
13542
13543   /* The "cell" areas are the cell_area passed in to gtk_cell_renderer_render(),
13544    * i.e. just the cells, no spacing.
13545    *
13546    * The cell area height is at least expander_size - vertical_separator.
13547    * For regular nodes, the height is then at least expander_size. We should
13548    * be able to enforce the expander_size minimum here, because this
13549    * function will not be called for irregular (e.g. separator) rows.
13550    */
13551   height = gtk_tree_view_get_row_height (tree_view, node);
13552   if (height < expander_size)
13553     height = expander_size;
13554
13555   return height - vertical_separator;
13556 }
13557
13558 static inline gint
13559 gtk_tree_view_get_cell_area_y_offset (GtkTreeView *tree_view,
13560                                       GtkRBTree   *tree,
13561                                       GtkRBNode   *node,
13562                                       gint         vertical_separator)
13563 {
13564   int offset;
13565
13566   offset = gtk_tree_view_get_row_y_offset (tree_view, tree, node);
13567   offset += vertical_separator / 2;
13568
13569   return offset;
13570 }
13571
13572 /**
13573  * gtk_tree_view_get_cell_area:
13574  * @tree_view: a #GtkTreeView
13575  * @path: (allow-none): a #GtkTreePath for the row, or %NULL to get only horizontal coordinates
13576  * @column: (allow-none): a #GtkTreeViewColumn for the column, or %NULL to get only vertical coordinates
13577  * @rect: (out): rectangle to fill with cell rect
13578  *
13579  * Fills the bounding rectangle in bin_window coordinates for the cell at the
13580  * row specified by @path and the column specified by @column.  If @path is
13581  * %NULL, or points to a path not currently displayed, the @y and @height fields
13582  * of the rectangle will be filled with 0. If @column is %NULL, the @x and @width
13583  * fields will be filled with 0.  The sum of all cell rects does not cover the
13584  * entire tree; there are extra pixels in between rows, for example. The
13585  * returned rectangle is equivalent to the @cell_area passed to
13586  * gtk_cell_renderer_render().  This function is only valid if @tree_view is
13587  * realized.
13588  **/
13589 void
13590 gtk_tree_view_get_cell_area (GtkTreeView        *tree_view,
13591                              GtkTreePath        *path,
13592                              GtkTreeViewColumn  *column,
13593                              GdkRectangle       *rect)
13594 {
13595   GtkRBTree *tree = NULL;
13596   GtkRBNode *node = NULL;
13597   gint vertical_separator;
13598   gint horizontal_separator;
13599
13600   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13601   g_return_if_fail (column == NULL || GTK_IS_TREE_VIEW_COLUMN (column));
13602   g_return_if_fail (rect != NULL);
13603   g_return_if_fail (!column || gtk_tree_view_column_get_tree_view (column) == (GtkWidget *) tree_view);
13604   g_return_if_fail (gtk_widget_get_realized (GTK_WIDGET (tree_view)));
13605
13606   gtk_widget_style_get (GTK_WIDGET (tree_view),
13607                         "vertical-separator", &vertical_separator,
13608                         "horizontal-separator", &horizontal_separator,
13609                         NULL);
13610
13611   rect->x = 0;
13612   rect->y = 0;
13613   rect->width = 0;
13614   rect->height = 0;
13615
13616   if (column)
13617     {
13618       rect->x = gtk_tree_view_column_get_x_offset (column) + horizontal_separator/2;
13619       rect->width = gtk_tree_view_column_get_width (column) - horizontal_separator;
13620     }
13621
13622   if (path)
13623     {
13624       gboolean ret = _gtk_tree_view_find_node (tree_view, path, &tree, &node);
13625
13626       /* Get vertical coords */
13627       if ((!ret && tree == NULL) || ret)
13628         return;
13629
13630       if (row_is_separator (tree_view, NULL, path))
13631         {
13632           /* There isn't really a "cell area" for separator, so we
13633            * return the y, height values for background area instead.
13634            */
13635           rect->y = gtk_tree_view_get_row_y_offset (tree_view, tree, node);
13636           rect->height = gtk_tree_view_get_row_height (tree_view, node);
13637         }
13638       else
13639         {
13640           rect->y = gtk_tree_view_get_cell_area_y_offset (tree_view, tree, node,
13641                                                           vertical_separator);
13642           rect->height = gtk_tree_view_get_cell_area_height (tree_view, node,
13643                                                              vertical_separator);
13644         }
13645
13646       if (column &&
13647           gtk_tree_view_is_expander_column (tree_view, column))
13648         {
13649           gint depth = gtk_tree_path_get_depth (path);
13650           gboolean rtl;
13651
13652           rtl = gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL;
13653
13654           if (!rtl)
13655             rect->x += (depth - 1) * tree_view->priv->level_indentation;
13656           rect->width -= (depth - 1) * tree_view->priv->level_indentation;
13657
13658           if (gtk_tree_view_draw_expanders (tree_view))
13659             {
13660               int expander_size = gtk_tree_view_get_expander_size (tree_view);
13661               if (!rtl)
13662                 rect->x += depth * expander_size;
13663               rect->width -= depth * expander_size;
13664             }
13665
13666           rect->width = MAX (rect->width, 0);
13667         }
13668     }
13669 }
13670
13671 static inline gint
13672 gtk_tree_view_get_row_height (GtkTreeView *tree_view,
13673                               GtkRBNode   *node)
13674 {
13675   int expander_size = gtk_tree_view_get_expander_size (tree_view);
13676   int height;
13677
13678   /* The "background" areas of all rows/cells add up to cover the entire tree.
13679    * The background includes all inter-row and inter-cell spacing.
13680    *
13681    * If the row pointed at by node does not have a height set, we default
13682    * to expander_size, which is the minimum height for regular nodes.
13683    * Non-regular nodes (e.g. separators) can have a height set smaller
13684    * than expander_size and should not be overruled here.
13685    */
13686   height = GTK_RBNODE_GET_HEIGHT (node);
13687   if (height <= 0)
13688     height = expander_size;
13689
13690   return height;
13691 }
13692
13693 static inline gint
13694 gtk_tree_view_get_row_y_offset (GtkTreeView *tree_view,
13695                                 GtkRBTree   *tree,
13696                                 GtkRBNode   *node)
13697 {
13698   int offset;
13699
13700   offset = _gtk_rbtree_node_find_offset (tree, node);
13701
13702   return RBTREE_Y_TO_TREE_WINDOW_Y (tree_view, offset);
13703 }
13704
13705 /**
13706  * gtk_tree_view_get_background_area:
13707  * @tree_view: a #GtkTreeView
13708  * @path: (allow-none): a #GtkTreePath for the row, or %NULL to get only horizontal coordinates
13709  * @column: (allow-none): a #GtkTreeViewColumn for the column, or %NULL to get only vertical coordiantes
13710  * @rect: (out): rectangle to fill with cell background rect
13711  *
13712  * Fills the bounding rectangle in bin_window coordinates for the cell at the
13713  * row specified by @path and the column specified by @column.  If @path is
13714  * %NULL, or points to a node not found in the tree, the @y and @height fields of
13715  * the rectangle will be filled with 0. If @column is %NULL, the @x and @width
13716  * fields will be filled with 0.  The returned rectangle is equivalent to the
13717  * @background_area passed to gtk_cell_renderer_render().  These background
13718  * areas tile to cover the entire bin window.  Contrast with the @cell_area,
13719  * returned by gtk_tree_view_get_cell_area(), which returns only the cell
13720  * itself, excluding surrounding borders and the tree expander area.
13721  *
13722  **/
13723 void
13724 gtk_tree_view_get_background_area (GtkTreeView        *tree_view,
13725                                    GtkTreePath        *path,
13726                                    GtkTreeViewColumn  *column,
13727                                    GdkRectangle       *rect)
13728 {
13729   GtkRBTree *tree = NULL;
13730   GtkRBNode *node = NULL;
13731
13732   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13733   g_return_if_fail (column == NULL || GTK_IS_TREE_VIEW_COLUMN (column));
13734   g_return_if_fail (rect != NULL);
13735
13736   rect->x = 0;
13737   rect->y = 0;
13738   rect->width = 0;
13739   rect->height = 0;
13740
13741   if (path)
13742     {
13743       /* Get vertical coords */
13744
13745       if (!_gtk_tree_view_find_node (tree_view, path, &tree, &node) &&
13746           tree == NULL)
13747         return;
13748
13749       rect->y = gtk_tree_view_get_row_y_offset (tree_view, tree, node);
13750       rect->height = gtk_tree_view_get_row_height (tree_view, node);
13751     }
13752
13753   if (column)
13754     {
13755       gint x2 = 0;
13756
13757       gtk_tree_view_get_background_xrange (tree_view, tree, column, &rect->x, &x2);
13758       rect->width = x2 - rect->x;
13759     }
13760 }
13761
13762 /**
13763  * gtk_tree_view_get_visible_rect:
13764  * @tree_view: a #GtkTreeView
13765  * @visible_rect: (out): rectangle to fill
13766  *
13767  * Fills @visible_rect with the currently-visible region of the
13768  * buffer, in tree coordinates. Convert to bin_window coordinates with
13769  * gtk_tree_view_convert_tree_to_bin_window_coords().
13770  * Tree coordinates start at 0,0 for row 0 of the tree, and cover the entire
13771  * scrollable area of the tree.
13772  **/
13773 void
13774 gtk_tree_view_get_visible_rect (GtkTreeView  *tree_view,
13775                                 GdkRectangle *visible_rect)
13776 {
13777   GtkAllocation allocation;
13778   GtkWidget *widget;
13779
13780   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13781
13782   widget = GTK_WIDGET (tree_view);
13783
13784   if (visible_rect)
13785     {
13786       gtk_widget_get_allocation (widget, &allocation);
13787       visible_rect->x = gtk_adjustment_get_value (tree_view->priv->hadjustment);
13788       visible_rect->y = gtk_adjustment_get_value (tree_view->priv->vadjustment);
13789       visible_rect->width = allocation.width;
13790       visible_rect->height = allocation.height - gtk_tree_view_get_effective_header_height (tree_view);
13791     }
13792 }
13793
13794 /**
13795  * gtk_tree_view_convert_widget_to_tree_coords:
13796  * @tree_view: a #GtkTreeView
13797  * @wx: X coordinate relative to the widget
13798  * @wy: Y coordinate relative to the widget
13799  * @tx: (out): return location for tree X coordinate
13800  * @ty: (out): return location for tree Y coordinate
13801  *
13802  * Converts widget coordinates to coordinates for the
13803  * tree (the full scrollable area of the tree).
13804  *
13805  * Since: 2.12
13806  **/
13807 void
13808 gtk_tree_view_convert_widget_to_tree_coords (GtkTreeView *tree_view,
13809                                              gint         wx,
13810                                              gint         wy,
13811                                              gint        *tx,
13812                                              gint        *ty)
13813 {
13814   gint x, y;
13815
13816   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13817
13818   gtk_tree_view_convert_widget_to_bin_window_coords (tree_view,
13819                                                      wx, wy,
13820                                                      &x, &y);
13821   gtk_tree_view_convert_bin_window_to_tree_coords (tree_view,
13822                                                    x, y,
13823                                                    tx, ty);
13824 }
13825
13826 /**
13827  * gtk_tree_view_convert_tree_to_widget_coords:
13828  * @tree_view: a #GtkTreeView
13829  * @tx: X coordinate relative to the tree
13830  * @ty: Y coordinate relative to the tree
13831  * @wx: (out): return location for widget X coordinate
13832  * @wy: (out): return location for widget Y coordinate
13833  *
13834  * Converts tree coordinates (coordinates in full scrollable area of the tree)
13835  * to widget coordinates.
13836  *
13837  * Since: 2.12
13838  **/
13839 void
13840 gtk_tree_view_convert_tree_to_widget_coords (GtkTreeView *tree_view,
13841                                              gint         tx,
13842                                              gint         ty,
13843                                              gint        *wx,
13844                                              gint        *wy)
13845 {
13846   gint x, y;
13847
13848   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13849
13850   gtk_tree_view_convert_tree_to_bin_window_coords (tree_view,
13851                                                    tx, ty,
13852                                                    &x, &y);
13853   gtk_tree_view_convert_bin_window_to_widget_coords (tree_view,
13854                                                      x, y,
13855                                                      wx, wy);
13856 }
13857
13858 /**
13859  * gtk_tree_view_convert_widget_to_bin_window_coords:
13860  * @tree_view: a #GtkTreeView
13861  * @wx: X coordinate relative to the widget
13862  * @wy: Y coordinate relative to the widget
13863  * @bx: (out): return location for bin_window X coordinate
13864  * @by: (out): return location for bin_window Y coordinate
13865  *
13866  * Converts widget coordinates to coordinates for the bin_window
13867  * (see gtk_tree_view_get_bin_window()).
13868  *
13869  * Since: 2.12
13870  **/
13871 void
13872 gtk_tree_view_convert_widget_to_bin_window_coords (GtkTreeView *tree_view,
13873                                                    gint         wx,
13874                                                    gint         wy,
13875                                                    gint        *bx,
13876                                                    gint        *by)
13877 {
13878   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13879
13880   if (bx)
13881     *bx = wx + gtk_adjustment_get_value (tree_view->priv->hadjustment);
13882   if (by)
13883     *by = wy - gtk_tree_view_get_effective_header_height (tree_view);
13884 }
13885
13886 /**
13887  * gtk_tree_view_convert_bin_window_to_widget_coords:
13888  * @tree_view: a #GtkTreeView
13889  * @bx: bin_window X coordinate
13890  * @by: bin_window Y coordinate
13891  * @wx: (out): return location for widget X coordinate
13892  * @wy: (out): return location for widget Y coordinate
13893  *
13894  * Converts bin_window coordinates (see gtk_tree_view_get_bin_window())
13895  * to widget relative coordinates.
13896  *
13897  * Since: 2.12
13898  **/
13899 void
13900 gtk_tree_view_convert_bin_window_to_widget_coords (GtkTreeView *tree_view,
13901                                                    gint         bx,
13902                                                    gint         by,
13903                                                    gint        *wx,
13904                                                    gint        *wy)
13905 {
13906   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13907
13908   if (wx)
13909     *wx = bx - gtk_adjustment_get_value (tree_view->priv->hadjustment);
13910   if (wy)
13911     *wy = by + gtk_tree_view_get_effective_header_height (tree_view);
13912 }
13913
13914 /**
13915  * gtk_tree_view_convert_tree_to_bin_window_coords:
13916  * @tree_view: a #GtkTreeView
13917  * @tx: tree X coordinate
13918  * @ty: tree Y coordinate
13919  * @bx: (out): return location for X coordinate relative to bin_window
13920  * @by: (out): return location for Y coordinate relative to bin_window
13921  *
13922  * Converts tree coordinates (coordinates in full scrollable area of the tree)
13923  * to bin_window coordinates.
13924  *
13925  * Since: 2.12
13926  **/
13927 void
13928 gtk_tree_view_convert_tree_to_bin_window_coords (GtkTreeView *tree_view,
13929                                                  gint         tx,
13930                                                  gint         ty,
13931                                                  gint        *bx,
13932                                                  gint        *by)
13933 {
13934   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13935
13936   if (bx)
13937     *bx = tx;
13938   if (by)
13939     *by = ty - tree_view->priv->dy;
13940 }
13941
13942 /**
13943  * gtk_tree_view_convert_bin_window_to_tree_coords:
13944  * @tree_view: a #GtkTreeView
13945  * @bx: X coordinate relative to bin_window
13946  * @by: Y coordinate relative to bin_window
13947  * @tx: (out): return location for tree X coordinate
13948  * @ty: (out): return location for tree Y coordinate
13949  *
13950  * Converts bin_window coordinates to coordinates for the
13951  * tree (the full scrollable area of the tree).
13952  *
13953  * Since: 2.12
13954  **/
13955 void
13956 gtk_tree_view_convert_bin_window_to_tree_coords (GtkTreeView *tree_view,
13957                                                  gint         bx,
13958                                                  gint         by,
13959                                                  gint        *tx,
13960                                                  gint        *ty)
13961 {
13962   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13963
13964   if (tx)
13965     *tx = bx;
13966   if (ty)
13967     *ty = by + tree_view->priv->dy;
13968 }
13969
13970
13971
13972 /**
13973  * gtk_tree_view_get_visible_range:
13974  * @tree_view: A #GtkTreeView
13975  * @start_path: (out) (allow-none): Return location for start of region,
13976  *              or %NULL.
13977  * @end_path: (out) (allow-none): Return location for end of region, or %NULL.
13978  *
13979  * Sets @start_path and @end_path to be the first and last visible path.
13980  * Note that there may be invisible paths in between.
13981  *
13982  * The paths should be freed with gtk_tree_path_free() after use.
13983  *
13984  * Returns: %TRUE, if valid paths were placed in @start_path and @end_path.
13985  *
13986  * Since: 2.8
13987  **/
13988 gboolean
13989 gtk_tree_view_get_visible_range (GtkTreeView  *tree_view,
13990                                  GtkTreePath **start_path,
13991                                  GtkTreePath **end_path)
13992 {
13993   GtkRBTree *tree;
13994   GtkRBNode *node;
13995   gboolean retval;
13996
13997   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
13998
13999   if (!tree_view->priv->tree)
14000     return FALSE;
14001
14002   retval = TRUE;
14003
14004   if (start_path)
14005     {
14006       _gtk_rbtree_find_offset (tree_view->priv->tree,
14007                                TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, 0),
14008                                &tree, &node);
14009       if (node)
14010         *start_path = _gtk_tree_path_new_from_rbtree (tree, node);
14011       else
14012         retval = FALSE;
14013     }
14014
14015   if (end_path)
14016     {
14017       gint y;
14018
14019       if (tree_view->priv->height < gtk_adjustment_get_page_size (tree_view->priv->vadjustment))
14020         y = tree_view->priv->height - 1;
14021       else
14022         y = TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, gtk_adjustment_get_page_size (tree_view->priv->vadjustment)) - 1;
14023
14024       _gtk_rbtree_find_offset (tree_view->priv->tree, y, &tree, &node);
14025       if (node)
14026         *end_path = _gtk_tree_path_new_from_rbtree (tree, node);
14027       else
14028         retval = FALSE;
14029     }
14030
14031   return retval;
14032 }
14033
14034 /**
14035  * gtk_tree_view_is_blank_at_pos:
14036  * @tree_view: A #GtkTreeView
14037  * @x: The x position to be identified (relative to bin_window)
14038  * @y: The y position to be identified (relative to bin_window)
14039  * @path: (out) (allow-none): A pointer to a #GtkTreePath pointer to be filled in, or %NULL
14040  * @column: (out) (allow-none): A pointer to a #GtkTreeViewColumn pointer to be filled in, or %NULL
14041  * @cell_x: (out) (allow-none): A pointer where the X coordinate relative to the cell can be placed, or %NULL
14042  * @cell_y: (out) (allow-none): A pointer where the Y coordinate relative to the cell can be placed, or %NULL
14043  *
14044  * Determine whether the point (@x, @y) in @tree_view is blank, that is no
14045  * cell content nor an expander arrow is drawn at the location. If so, the
14046  * location can be considered as the background. You might wish to take
14047  * special action on clicks on the background, such as clearing a current
14048  * selection, having a custom context menu or starting rubber banding.
14049  *
14050  * The @x and @y coordinate that are provided must be relative to bin_window
14051  * coordinates.  That is, @x and @y must come from an event on @tree_view
14052  * where <literal>event->window == gtk_tree_view_get_bin_window (<!-- -->)</literal>.
14053  *
14054  * For converting widget coordinates (eg. the ones you get from
14055  * GtkWidget::query-tooltip), please see
14056  * gtk_tree_view_convert_widget_to_bin_window_coords().
14057  *
14058  * The @path, @column, @cell_x and @cell_y arguments will be filled in
14059  * likewise as for gtk_tree_view_get_path_at_pos().  Please see
14060  * gtk_tree_view_get_path_at_pos() for more information.
14061  *
14062  * Return value: %TRUE if the area at the given coordinates is blank,
14063  * %FALSE otherwise.
14064  *
14065  * Since: 3.0
14066  */
14067 gboolean
14068 gtk_tree_view_is_blank_at_pos (GtkTreeView       *tree_view,
14069                                gint                x,
14070                                gint                y,
14071                                GtkTreePath       **path,
14072                                GtkTreeViewColumn **column,
14073                                gint               *cell_x,
14074                                gint               *cell_y)
14075 {
14076   GtkRBTree *tree;
14077   GtkRBNode *node;
14078   GtkTreeIter iter;
14079   GtkTreePath *real_path;
14080   GtkTreeViewColumn *real_column;
14081   GdkRectangle cell_area, background_area;
14082
14083   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
14084
14085   if (!gtk_tree_view_get_path_at_pos (tree_view, x, y,
14086                                       &real_path, &real_column,
14087                                       cell_x, cell_y))
14088     /* If there's no path here, it is blank */
14089     return TRUE;
14090
14091   if (path)
14092     *path = real_path;
14093
14094   if (column)
14095     *column = real_column;
14096
14097   gtk_tree_model_get_iter (tree_view->priv->model, &iter, real_path);
14098   _gtk_tree_view_find_node (tree_view, real_path, &tree, &node);
14099
14100   /* Check if there's an expander arrow at (x, y) */
14101   if (real_column == tree_view->priv->expander_column
14102       && gtk_tree_view_draw_expanders (tree_view))
14103     {
14104       gboolean over_arrow;
14105
14106       over_arrow = coords_are_over_arrow (tree_view, tree, node, x, y);
14107
14108       if (over_arrow)
14109         {
14110           if (!path)
14111             gtk_tree_path_free (real_path);
14112           return FALSE;
14113         }
14114     }
14115
14116   /* Otherwise, have the column see if there's a cell at (x, y) */
14117   gtk_tree_view_column_cell_set_cell_data (real_column,
14118                                            tree_view->priv->model,
14119                                            &iter,
14120                                            GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT),
14121                                            node->children ? TRUE : FALSE);
14122
14123   gtk_tree_view_get_background_area (tree_view, real_path, real_column,
14124                                      &background_area);
14125   gtk_tree_view_get_cell_area (tree_view, real_path, real_column,
14126                                &cell_area);
14127
14128   if (!path)
14129     gtk_tree_path_free (real_path);
14130
14131   return _gtk_tree_view_column_is_blank_at_pos (real_column,
14132                                                 &cell_area,
14133                                                 &background_area,
14134                                                 x, y);
14135 }
14136
14137 static void
14138 unset_reorderable (GtkTreeView *tree_view)
14139 {
14140   if (tree_view->priv->reorderable)
14141     {
14142       tree_view->priv->reorderable = FALSE;
14143       g_object_notify (G_OBJECT (tree_view), "reorderable");
14144     }
14145 }
14146
14147 /**
14148  * gtk_tree_view_enable_model_drag_source:
14149  * @tree_view: a #GtkTreeView
14150  * @start_button_mask: Mask of allowed buttons to start drag
14151  * @targets: (array length=n_targets): the table of targets that the drag will support
14152  * @n_targets: the number of items in @targets
14153  * @actions: the bitmask of possible actions for a drag from this
14154  *    widget
14155  *
14156  * Turns @tree_view into a drag source for automatic DND. Calling this
14157  * method sets #GtkTreeView:reorderable to %FALSE.
14158  **/
14159 void
14160 gtk_tree_view_enable_model_drag_source (GtkTreeView              *tree_view,
14161                                         GdkModifierType           start_button_mask,
14162                                         const GtkTargetEntry     *targets,
14163                                         gint                      n_targets,
14164                                         GdkDragAction             actions)
14165 {
14166   TreeViewDragInfo *di;
14167
14168   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14169
14170   gtk_drag_source_set (GTK_WIDGET (tree_view),
14171                        0,
14172                        targets,
14173                        n_targets,
14174                        actions);
14175
14176   di = ensure_info (tree_view);
14177
14178   di->start_button_mask = start_button_mask;
14179   di->source_actions = actions;
14180   di->source_set = TRUE;
14181
14182   unset_reorderable (tree_view);
14183 }
14184
14185 /**
14186  * gtk_tree_view_enable_model_drag_dest:
14187  * @tree_view: a #GtkTreeView
14188  * @targets: (array length=n_targets): the table of targets that
14189  *           the drag will support
14190  * @n_targets: the number of items in @targets
14191  * @actions: the bitmask of possible actions for a drag from this
14192  *    widget
14193  *
14194  * Turns @tree_view into a drop destination for automatic DND. Calling
14195  * this method sets #GtkTreeView:reorderable to %FALSE.
14196  **/
14197 void
14198 gtk_tree_view_enable_model_drag_dest (GtkTreeView              *tree_view,
14199                                       const GtkTargetEntry     *targets,
14200                                       gint                      n_targets,
14201                                       GdkDragAction             actions)
14202 {
14203   TreeViewDragInfo *di;
14204
14205   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14206
14207   gtk_drag_dest_set (GTK_WIDGET (tree_view),
14208                      0,
14209                      targets,
14210                      n_targets,
14211                      actions);
14212
14213   di = ensure_info (tree_view);
14214   di->dest_set = TRUE;
14215
14216   unset_reorderable (tree_view);
14217 }
14218
14219 /**
14220  * gtk_tree_view_unset_rows_drag_source:
14221  * @tree_view: a #GtkTreeView
14222  *
14223  * Undoes the effect of
14224  * gtk_tree_view_enable_model_drag_source(). Calling this method sets
14225  * #GtkTreeView:reorderable to %FALSE.
14226  **/
14227 void
14228 gtk_tree_view_unset_rows_drag_source (GtkTreeView *tree_view)
14229 {
14230   TreeViewDragInfo *di;
14231
14232   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14233
14234   di = get_info (tree_view);
14235
14236   if (di)
14237     {
14238       if (di->source_set)
14239         {
14240           gtk_drag_source_unset (GTK_WIDGET (tree_view));
14241           di->source_set = FALSE;
14242         }
14243
14244       if (!di->dest_set && !di->source_set)
14245         remove_info (tree_view);
14246     }
14247
14248   unset_reorderable (tree_view);
14249 }
14250
14251 /**
14252  * gtk_tree_view_unset_rows_drag_dest:
14253  * @tree_view: a #GtkTreeView
14254  *
14255  * Undoes the effect of
14256  * gtk_tree_view_enable_model_drag_dest(). Calling this method sets
14257  * #GtkTreeView:reorderable to %FALSE.
14258  **/
14259 void
14260 gtk_tree_view_unset_rows_drag_dest (GtkTreeView *tree_view)
14261 {
14262   TreeViewDragInfo *di;
14263
14264   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14265
14266   di = get_info (tree_view);
14267
14268   if (di)
14269     {
14270       if (di->dest_set)
14271         {
14272           gtk_drag_dest_unset (GTK_WIDGET (tree_view));
14273           di->dest_set = FALSE;
14274         }
14275
14276       if (!di->dest_set && !di->source_set)
14277         remove_info (tree_view);
14278     }
14279
14280   unset_reorderable (tree_view);
14281 }
14282
14283 /**
14284  * gtk_tree_view_set_drag_dest_row:
14285  * @tree_view: a #GtkTreeView
14286  * @path: (allow-none): The path of the row to highlight, or %NULL
14287  * @pos: Specifies whether to drop before, after or into the row
14288  *
14289  * Sets the row that is highlighted for feedback.
14290  * If @path is %NULL, an existing highlight is removed.
14291  */
14292 void
14293 gtk_tree_view_set_drag_dest_row (GtkTreeView            *tree_view,
14294                                  GtkTreePath            *path,
14295                                  GtkTreeViewDropPosition pos)
14296 {
14297   GtkTreePath *current_dest;
14298
14299   /* Note; this function is exported to allow a custom DND
14300    * implementation, so it can't touch TreeViewDragInfo
14301    */
14302
14303   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14304
14305   current_dest = NULL;
14306
14307   if (tree_view->priv->drag_dest_row)
14308     {
14309       current_dest = gtk_tree_row_reference_get_path (tree_view->priv->drag_dest_row);
14310       gtk_tree_row_reference_free (tree_view->priv->drag_dest_row);
14311     }
14312
14313   /* special case a drop on an empty model */
14314   tree_view->priv->empty_view_drop = 0;
14315
14316   if (pos == GTK_TREE_VIEW_DROP_BEFORE && path
14317       && gtk_tree_path_get_depth (path) == 1
14318       && gtk_tree_path_get_indices (path)[0] == 0)
14319     {
14320       gint n_children;
14321
14322       n_children = gtk_tree_model_iter_n_children (tree_view->priv->model,
14323                                                    NULL);
14324
14325       if (!n_children)
14326         tree_view->priv->empty_view_drop = 1;
14327     }
14328
14329   tree_view->priv->drag_dest_pos = pos;
14330
14331   if (path)
14332     {
14333       tree_view->priv->drag_dest_row =
14334         gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view), tree_view->priv->model, path);
14335       gtk_tree_view_queue_draw_path (tree_view, path, NULL);
14336     }
14337   else
14338     tree_view->priv->drag_dest_row = NULL;
14339
14340   if (current_dest)
14341     {
14342       GtkRBTree *tree, *new_tree;
14343       GtkRBNode *node, *new_node;
14344
14345       _gtk_tree_view_find_node (tree_view, current_dest, &tree, &node);
14346       _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
14347
14348       if (tree && node)
14349         {
14350           _gtk_rbtree_next_full (tree, node, &new_tree, &new_node);
14351           if (new_tree && new_node)
14352             _gtk_tree_view_queue_draw_node (tree_view, new_tree, new_node, NULL);
14353
14354           _gtk_rbtree_prev_full (tree, node, &new_tree, &new_node);
14355           if (new_tree && new_node)
14356             _gtk_tree_view_queue_draw_node (tree_view, new_tree, new_node, NULL);
14357         }
14358       gtk_tree_path_free (current_dest);
14359     }
14360 }
14361
14362 /**
14363  * gtk_tree_view_get_drag_dest_row:
14364  * @tree_view: a #GtkTreeView
14365  * @path: (out) (allow-none): Return location for the path of the highlighted row, or %NULL.
14366  * @pos: (out) (allow-none): Return location for the drop position, or %NULL
14367  *
14368  * Gets information about the row that is highlighted for feedback.
14369  **/
14370 void
14371 gtk_tree_view_get_drag_dest_row (GtkTreeView              *tree_view,
14372                                  GtkTreePath             **path,
14373                                  GtkTreeViewDropPosition  *pos)
14374 {
14375   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14376
14377   if (path)
14378     {
14379       if (tree_view->priv->drag_dest_row)
14380         *path = gtk_tree_row_reference_get_path (tree_view->priv->drag_dest_row);
14381       else
14382         {
14383           if (tree_view->priv->empty_view_drop)
14384             *path = gtk_tree_path_new_from_indices (0, -1);
14385           else
14386             *path = NULL;
14387         }
14388     }
14389
14390   if (pos)
14391     *pos = tree_view->priv->drag_dest_pos;
14392 }
14393
14394 /**
14395  * gtk_tree_view_get_dest_row_at_pos:
14396  * @tree_view: a #GtkTreeView
14397  * @drag_x: the position to determine the destination row for
14398  * @drag_y: the position to determine the destination row for
14399  * @path: (out) (allow-none): Return location for the path of the highlighted row, or %NULL.
14400  * @pos: (out) (allow-none): Return location for the drop position, or %NULL
14401  *
14402  * Determines the destination row for a given position.  @drag_x and
14403  * @drag_y are expected to be in widget coordinates.  This function is only
14404  * meaningful if @tree_view is realized.  Therefore this function will always
14405  * return %FALSE if @tree_view is not realized or does not have a model.
14406  *
14407  * Return value: whether there is a row at the given position, %TRUE if this
14408  * is indeed the case.
14409  **/
14410 gboolean
14411 gtk_tree_view_get_dest_row_at_pos (GtkTreeView             *tree_view,
14412                                    gint                     drag_x,
14413                                    gint                     drag_y,
14414                                    GtkTreePath            **path,
14415                                    GtkTreeViewDropPosition *pos)
14416 {
14417   gint cell_y;
14418   gint bin_x, bin_y;
14419   gdouble offset_into_row;
14420   gdouble third;
14421   GdkRectangle cell;
14422   GtkTreeViewColumn *column = NULL;
14423   GtkTreePath *tmp_path = NULL;
14424
14425   /* Note; this function is exported to allow a custom DND
14426    * implementation, so it can't touch TreeViewDragInfo
14427    */
14428
14429   g_return_val_if_fail (tree_view != NULL, FALSE);
14430   g_return_val_if_fail (drag_x >= 0, FALSE);
14431   g_return_val_if_fail (drag_y >= 0, FALSE);
14432
14433   if (path)
14434     *path = NULL;
14435
14436   if (tree_view->priv->bin_window == NULL)
14437     return FALSE;
14438
14439   if (tree_view->priv->tree == NULL)
14440     return FALSE;
14441
14442   /* If in the top third of a row, we drop before that row; if
14443    * in the bottom third, drop after that row; if in the middle,
14444    * and the row has children, drop into the row.
14445    */
14446   gtk_tree_view_convert_widget_to_bin_window_coords (tree_view, drag_x, drag_y,
14447                                                      &bin_x, &bin_y);
14448
14449   if (!gtk_tree_view_get_path_at_pos (tree_view,
14450                                       bin_x,
14451                                       bin_y,
14452                                       &tmp_path,
14453                                       &column,
14454                                       NULL,
14455                                       &cell_y))
14456     return FALSE;
14457
14458   gtk_tree_view_get_background_area (tree_view, tmp_path, column,
14459                                      &cell);
14460
14461   offset_into_row = cell_y;
14462
14463   if (path)
14464     *path = tmp_path;
14465   else
14466     gtk_tree_path_free (tmp_path);
14467
14468   tmp_path = NULL;
14469
14470   third = cell.height / 3.0;
14471
14472   if (pos)
14473     {
14474       if (offset_into_row < third)
14475         {
14476           *pos = GTK_TREE_VIEW_DROP_BEFORE;
14477         }
14478       else if (offset_into_row < (cell.height / 2.0))
14479         {
14480           *pos = GTK_TREE_VIEW_DROP_INTO_OR_BEFORE;
14481         }
14482       else if (offset_into_row < third * 2.0)
14483         {
14484           *pos = GTK_TREE_VIEW_DROP_INTO_OR_AFTER;
14485         }
14486       else
14487         {
14488           *pos = GTK_TREE_VIEW_DROP_AFTER;
14489         }
14490     }
14491
14492   return TRUE;
14493 }
14494
14495
14496
14497 /* KEEP IN SYNC WITH GTK_TREE_VIEW_BIN_EXPOSE */
14498 /**
14499  * gtk_tree_view_create_row_drag_icon:
14500  * @tree_view: a #GtkTreeView
14501  * @path: a #GtkTreePath in @tree_view
14502  *
14503  * Creates a #cairo_surface_t representation of the row at @path.
14504  * This image is used for a drag icon.
14505  *
14506  * Return value: (transfer full): a newly-allocated surface of the drag icon.
14507  **/
14508 cairo_surface_t *
14509 gtk_tree_view_create_row_drag_icon (GtkTreeView  *tree_view,
14510                                     GtkTreePath  *path)
14511 {
14512   GtkTreeIter   iter;
14513   GtkRBTree    *tree;
14514   GtkRBNode    *node;
14515   GtkStyleContext *context;
14516   gint cell_offset;
14517   GList *list;
14518   GdkRectangle background_area;
14519   GtkWidget *widget;
14520   gint depth;
14521   /* start drawing inside the black outline */
14522   gint x = 1, y = 1;
14523   cairo_surface_t *surface;
14524   gint bin_window_width;
14525   gboolean is_separator = FALSE;
14526   gboolean rtl, allow_rules;
14527   cairo_t *cr;
14528
14529   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
14530   g_return_val_if_fail (path != NULL, NULL);
14531
14532   widget = GTK_WIDGET (tree_view);
14533
14534   if (!gtk_widget_get_realized (widget))
14535     return NULL;
14536
14537   depth = gtk_tree_path_get_depth (path);
14538
14539   _gtk_tree_view_find_node (tree_view,
14540                             path,
14541                             &tree,
14542                             &node);
14543
14544   if (tree == NULL)
14545     return NULL;
14546
14547   if (!gtk_tree_model_get_iter (tree_view->priv->model,
14548                                 &iter,
14549                                 path))
14550     return NULL;
14551
14552   context = gtk_widget_get_style_context (widget);
14553
14554   gtk_style_context_save (context);
14555   gtk_style_context_add_region (context, GTK_STYLE_REGION_COLUMN, 0);
14556
14557   gtk_widget_style_get (widget,
14558                         "allow-rules", &allow_rules,
14559                         NULL);
14560
14561   if (allow_rules && tree_view->priv->has_rules)
14562     {
14563       GtkRegionFlags row_flags;
14564
14565       if ((_gtk_rbtree_node_get_index (tree, node) % 2))
14566         row_flags = GTK_REGION_ODD;
14567       else
14568         row_flags = GTK_REGION_EVEN;
14569
14570       gtk_style_context_add_region (context, GTK_STYLE_REGION_ROW, row_flags);
14571     }
14572
14573   is_separator = row_is_separator (tree_view, &iter, NULL);
14574
14575   cell_offset = x;
14576
14577   background_area.y = y;
14578   background_area.height = gtk_tree_view_get_row_height (tree_view, node);
14579
14580   bin_window_width = gdk_window_get_width (tree_view->priv->bin_window);
14581
14582   surface = gdk_window_create_similar_surface (tree_view->priv->bin_window,
14583                                                CAIRO_CONTENT_COLOR,
14584                                                bin_window_width + 2,
14585                                                background_area.height + 2);
14586
14587   cr = cairo_create (surface);
14588
14589   gtk_render_background (context, cr, 0, 0,
14590                          bin_window_width + 2,
14591                          background_area.height + 2);
14592
14593   rtl = gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL;
14594
14595   for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
14596       list;
14597       list = (rtl ? list->prev : list->next))
14598     {
14599       GtkTreeViewColumn *column = list->data;
14600       GdkRectangle cell_area;
14601       gint vertical_separator;
14602
14603       if (!gtk_tree_view_column_get_visible (column))
14604         continue;
14605
14606       gtk_tree_view_column_cell_set_cell_data (column, tree_view->priv->model, &iter,
14607                                                GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT),
14608                                                node->children?TRUE:FALSE);
14609
14610       background_area.x = cell_offset;
14611       background_area.width = gtk_tree_view_column_get_width (column);
14612
14613       gtk_widget_style_get (widget,
14614                             "vertical-separator", &vertical_separator,
14615                             NULL);
14616
14617       cell_area = background_area;
14618
14619       cell_area.y += vertical_separator / 2;
14620       cell_area.height -= vertical_separator;
14621
14622       if (gtk_tree_view_is_expander_column (tree_view, column))
14623         {
14624           if (!rtl)
14625             cell_area.x += (depth - 1) * tree_view->priv->level_indentation;
14626           cell_area.width -= (depth - 1) * tree_view->priv->level_indentation;
14627
14628           if (gtk_tree_view_draw_expanders (tree_view))
14629             {
14630               int expander_size = gtk_tree_view_get_expander_size (tree_view);
14631               if (!rtl)
14632                 cell_area.x += depth * expander_size;
14633               cell_area.width -= depth * expander_size;
14634             }
14635         }
14636
14637       if (gtk_tree_view_column_cell_is_visible (column))
14638         {
14639           if (is_separator)
14640             {
14641               gtk_style_context_save (context);
14642               gtk_style_context_add_class (context, GTK_STYLE_CLASS_SEPARATOR);
14643
14644               gtk_render_line (context, cr,
14645                                cell_area.x,
14646                                cell_area.y + cell_area.height / 2,
14647                                cell_area.x + cell_area.width,
14648                                cell_area.y + cell_area.height / 2);
14649
14650               gtk_style_context_restore (context);
14651             }
14652           else
14653             {
14654               _gtk_tree_view_column_cell_render (column,
14655                                                  cr,
14656                                                  &background_area,
14657                                                  &cell_area,
14658                                                  0, FALSE);
14659             }
14660         }
14661       cell_offset += gtk_tree_view_column_get_width (column);
14662     }
14663
14664   cairo_set_source_rgb (cr, 0, 0, 0);
14665   cairo_rectangle (cr,
14666                    0.5, 0.5,
14667                    bin_window_width + 1,
14668                    background_area.height + 1);
14669   cairo_set_line_width (cr, 1.0);
14670   cairo_stroke (cr);
14671
14672   cairo_destroy (cr);
14673
14674   cairo_surface_set_device_offset (surface, 2, 2);
14675
14676   gtk_style_context_restore (context);
14677
14678   return surface;
14679 }
14680
14681
14682 /**
14683  * gtk_tree_view_set_destroy_count_func:
14684  * @tree_view: A #GtkTreeView
14685  * @func: (allow-none): Function to be called when a view row is destroyed, or %NULL
14686  * @data: (allow-none): User data to be passed to @func, or %NULL
14687  * @destroy: (allow-none): Destroy notifier for @data, or %NULL
14688  *
14689  * This function should almost never be used.  It is meant for private use by
14690  * ATK for determining the number of visible children that are removed when the
14691  * user collapses a row, or a row is deleted.
14692  *
14693  * Deprecated: 3.4: Accessibility does not need the function anymore.
14694  **/
14695 void
14696 gtk_tree_view_set_destroy_count_func (GtkTreeView             *tree_view,
14697                                       GtkTreeDestroyCountFunc  func,
14698                                       gpointer                 data,
14699                                       GDestroyNotify           destroy)
14700 {
14701   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14702
14703   if (tree_view->priv->destroy_count_destroy)
14704     tree_view->priv->destroy_count_destroy (tree_view->priv->destroy_count_data);
14705
14706   tree_view->priv->destroy_count_func = func;
14707   tree_view->priv->destroy_count_data = data;
14708   tree_view->priv->destroy_count_destroy = destroy;
14709 }
14710
14711
14712 /*
14713  * Interactive search
14714  */
14715
14716 /**
14717  * gtk_tree_view_set_enable_search:
14718  * @tree_view: A #GtkTreeView
14719  * @enable_search: %TRUE, if the user can search interactively
14720  *
14721  * If @enable_search is set, then the user can type in text to search through
14722  * the tree interactively (this is sometimes called "typeahead find").
14723  *
14724  * Note that even if this is %FALSE, the user can still initiate a search
14725  * using the "start-interactive-search" key binding.
14726  */
14727 void
14728 gtk_tree_view_set_enable_search (GtkTreeView *tree_view,
14729                                  gboolean     enable_search)
14730 {
14731   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14732
14733   enable_search = !!enable_search;
14734
14735   if (tree_view->priv->enable_search != enable_search)
14736     {
14737        tree_view->priv->enable_search = enable_search;
14738        g_object_notify (G_OBJECT (tree_view), "enable-search");
14739     }
14740 }
14741
14742 /**
14743  * gtk_tree_view_get_enable_search:
14744  * @tree_view: A #GtkTreeView
14745  *
14746  * Returns whether or not the tree allows to start interactive searching
14747  * by typing in text.
14748  *
14749  * Return value: whether or not to let the user search interactively
14750  */
14751 gboolean
14752 gtk_tree_view_get_enable_search (GtkTreeView *tree_view)
14753 {
14754   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
14755
14756   return tree_view->priv->enable_search;
14757 }
14758
14759
14760 /**
14761  * gtk_tree_view_get_search_column:
14762  * @tree_view: A #GtkTreeView
14763  *
14764  * Gets the column searched on by the interactive search code.
14765  *
14766  * Return value: the column the interactive search code searches in.
14767  */
14768 gint
14769 gtk_tree_view_get_search_column (GtkTreeView *tree_view)
14770 {
14771   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
14772
14773   return (tree_view->priv->search_column);
14774 }
14775
14776 /**
14777  * gtk_tree_view_set_search_column:
14778  * @tree_view: A #GtkTreeView
14779  * @column: the column of the model to search in, or -1 to disable searching
14780  *
14781  * Sets @column as the column where the interactive search code should
14782  * search in for the current model.
14783  *
14784  * If the search column is set, users can use the "start-interactive-search"
14785  * key binding to bring up search popup. The enable-search property controls
14786  * whether simply typing text will also start an interactive search.
14787  *
14788  * Note that @column refers to a column of the current model. The search
14789  * column is reset to -1 when the model is changed.
14790  */
14791 void
14792 gtk_tree_view_set_search_column (GtkTreeView *tree_view,
14793                                  gint         column)
14794 {
14795   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14796   g_return_if_fail (column >= -1);
14797
14798   if (tree_view->priv->search_column == column)
14799     return;
14800
14801   tree_view->priv->search_column = column;
14802   g_object_notify (G_OBJECT (tree_view), "search-column");
14803 }
14804
14805 /**
14806  * gtk_tree_view_get_search_equal_func: (skip)
14807  * @tree_view: A #GtkTreeView
14808  *
14809  * Returns the compare function currently in use.
14810  *
14811  * Return value: the currently used compare function for the search code.
14812  */
14813
14814 GtkTreeViewSearchEqualFunc
14815 gtk_tree_view_get_search_equal_func (GtkTreeView *tree_view)
14816 {
14817   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
14818
14819   return tree_view->priv->search_equal_func;
14820 }
14821
14822 /**
14823  * gtk_tree_view_set_search_equal_func:
14824  * @tree_view: A #GtkTreeView
14825  * @search_equal_func: the compare function to use during the search
14826  * @search_user_data: (allow-none): user data to pass to @search_equal_func, or %NULL
14827  * @search_destroy: (allow-none): Destroy notifier for @search_user_data, or %NULL
14828  *
14829  * Sets the compare function for the interactive search capabilities; note
14830  * that somewhat like strcmp() returning 0 for equality
14831  * #GtkTreeViewSearchEqualFunc returns %FALSE on matches.
14832  **/
14833 void
14834 gtk_tree_view_set_search_equal_func (GtkTreeView                *tree_view,
14835                                      GtkTreeViewSearchEqualFunc  search_equal_func,
14836                                      gpointer                    search_user_data,
14837                                      GDestroyNotify              search_destroy)
14838 {
14839   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14840   g_return_if_fail (search_equal_func != NULL);
14841
14842   if (tree_view->priv->search_destroy)
14843     tree_view->priv->search_destroy (tree_view->priv->search_user_data);
14844
14845   tree_view->priv->search_equal_func = search_equal_func;
14846   tree_view->priv->search_user_data = search_user_data;
14847   tree_view->priv->search_destroy = search_destroy;
14848   if (tree_view->priv->search_equal_func == NULL)
14849     tree_view->priv->search_equal_func = gtk_tree_view_search_equal_func;
14850 }
14851
14852 /**
14853  * gtk_tree_view_get_search_entry:
14854  * @tree_view: A #GtkTreeView
14855  *
14856  * Returns the #GtkEntry which is currently in use as interactive search
14857  * entry for @tree_view.  In case the built-in entry is being used, %NULL
14858  * will be returned.
14859  *
14860  * Return value: (transfer none): the entry currently in use as search entry.
14861  *
14862  * Since: 2.10
14863  */
14864 GtkEntry *
14865 gtk_tree_view_get_search_entry (GtkTreeView *tree_view)
14866 {
14867   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
14868
14869   if (tree_view->priv->search_custom_entry_set)
14870     return GTK_ENTRY (tree_view->priv->search_entry);
14871
14872   return NULL;
14873 }
14874
14875 /**
14876  * gtk_tree_view_set_search_entry:
14877  * @tree_view: A #GtkTreeView
14878  * @entry: (allow-none): the entry the interactive search code of @tree_view should use or %NULL
14879  *
14880  * Sets the entry which the interactive search code will use for this
14881  * @tree_view.  This is useful when you want to provide a search entry
14882  * in our interface at all time at a fixed position.  Passing %NULL for
14883  * @entry will make the interactive search code use the built-in popup
14884  * entry again.
14885  *
14886  * Since: 2.10
14887  */
14888 void
14889 gtk_tree_view_set_search_entry (GtkTreeView *tree_view,
14890                                 GtkEntry    *entry)
14891 {
14892   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14893   g_return_if_fail (entry == NULL || GTK_IS_ENTRY (entry));
14894
14895   if (tree_view->priv->search_custom_entry_set)
14896     {
14897       if (tree_view->priv->search_entry_changed_id)
14898         {
14899           g_signal_handler_disconnect (tree_view->priv->search_entry,
14900                                        tree_view->priv->search_entry_changed_id);
14901           tree_view->priv->search_entry_changed_id = 0;
14902         }
14903       g_signal_handlers_disconnect_by_func (tree_view->priv->search_entry,
14904                                             G_CALLBACK (gtk_tree_view_search_key_press_event),
14905                                             tree_view);
14906
14907       g_object_unref (tree_view->priv->search_entry);
14908     }
14909   else if (tree_view->priv->search_window)
14910     {
14911       gtk_widget_destroy (tree_view->priv->search_window);
14912
14913       tree_view->priv->search_window = NULL;
14914     }
14915
14916   if (entry)
14917     {
14918       tree_view->priv->search_entry = g_object_ref (entry);
14919       tree_view->priv->search_custom_entry_set = TRUE;
14920
14921       if (tree_view->priv->search_entry_changed_id == 0)
14922         {
14923           tree_view->priv->search_entry_changed_id =
14924             g_signal_connect (tree_view->priv->search_entry, "changed",
14925                               G_CALLBACK (gtk_tree_view_search_init),
14926                               tree_view);
14927         }
14928
14929         g_signal_connect (tree_view->priv->search_entry, "key-press-event",
14930                           G_CALLBACK (gtk_tree_view_search_key_press_event),
14931                           tree_view);
14932
14933         gtk_tree_view_search_init (tree_view->priv->search_entry, tree_view);
14934     }
14935   else
14936     {
14937       tree_view->priv->search_entry = NULL;
14938       tree_view->priv->search_custom_entry_set = FALSE;
14939     }
14940 }
14941
14942 /**
14943  * gtk_tree_view_set_search_position_func:
14944  * @tree_view: A #GtkTreeView
14945  * @func: (allow-none): the function to use to position the search dialog, or %NULL
14946  *    to use the default search position function
14947  * @data: (allow-none): user data to pass to @func, or %NULL
14948  * @destroy: (allow-none): Destroy notifier for @data, or %NULL
14949  *
14950  * Sets the function to use when positioning the search dialog.
14951  *
14952  * Since: 2.10
14953  **/
14954 void
14955 gtk_tree_view_set_search_position_func (GtkTreeView                   *tree_view,
14956                                         GtkTreeViewSearchPositionFunc  func,
14957                                         gpointer                       user_data,
14958                                         GDestroyNotify                 destroy)
14959 {
14960   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14961
14962   if (tree_view->priv->search_position_destroy)
14963     tree_view->priv->search_position_destroy (tree_view->priv->search_position_user_data);
14964
14965   tree_view->priv->search_position_func = func;
14966   tree_view->priv->search_position_user_data = user_data;
14967   tree_view->priv->search_position_destroy = destroy;
14968   if (tree_view->priv->search_position_func == NULL)
14969     tree_view->priv->search_position_func = gtk_tree_view_search_position_func;
14970 }
14971
14972 /**
14973  * gtk_tree_view_get_search_position_func: (skip)
14974  * @tree_view: A #GtkTreeView
14975  *
14976  * Returns the positioning function currently in use.
14977  *
14978  * Return value: the currently used function for positioning the search dialog.
14979  *
14980  * Since: 2.10
14981  */
14982 GtkTreeViewSearchPositionFunc
14983 gtk_tree_view_get_search_position_func (GtkTreeView *tree_view)
14984 {
14985   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
14986
14987   return tree_view->priv->search_position_func;
14988 }
14989
14990
14991 static void
14992 gtk_tree_view_search_dialog_hide (GtkWidget   *search_dialog,
14993                                   GtkTreeView *tree_view,
14994                                   GdkDevice   *device)
14995 {
14996   if (tree_view->priv->disable_popdown)
14997     return;
14998
14999   if (tree_view->priv->search_entry_changed_id)
15000     {
15001       g_signal_handler_disconnect (tree_view->priv->search_entry,
15002                                    tree_view->priv->search_entry_changed_id);
15003       tree_view->priv->search_entry_changed_id = 0;
15004     }
15005   if (tree_view->priv->typeselect_flush_timeout)
15006     {
15007       g_source_remove (tree_view->priv->typeselect_flush_timeout);
15008       tree_view->priv->typeselect_flush_timeout = 0;
15009     }
15010
15011   if (gtk_widget_get_visible (search_dialog))
15012     {
15013       /* send focus-in event */
15014       send_focus_change (GTK_WIDGET (tree_view->priv->search_entry), device, FALSE);
15015       gtk_widget_hide (search_dialog);
15016       gtk_entry_set_text (GTK_ENTRY (tree_view->priv->search_entry), "");
15017       send_focus_change (GTK_WIDGET (tree_view), device, TRUE);
15018     }
15019 }
15020
15021 static void
15022 gtk_tree_view_search_position_func (GtkTreeView *tree_view,
15023                                     GtkWidget   *search_dialog,
15024                                     gpointer     user_data)
15025 {
15026   gint x, y;
15027   gint tree_x, tree_y;
15028   gint tree_width, tree_height;
15029   GdkWindow *tree_window = gtk_widget_get_window (GTK_WIDGET (tree_view));
15030   GdkScreen *screen = gdk_window_get_screen (tree_window);
15031   GtkRequisition requisition;
15032   gint monitor_num;
15033   GdkRectangle monitor;
15034
15035   monitor_num = gdk_screen_get_monitor_at_window (screen, tree_window);
15036   gdk_screen_get_monitor_workarea (screen, monitor_num, &monitor);
15037
15038   gtk_widget_realize (search_dialog);
15039
15040   gdk_window_get_origin (tree_window, &tree_x, &tree_y);
15041   tree_width = gdk_window_get_width (tree_window);
15042   tree_height = gdk_window_get_height (tree_window);
15043   gtk_widget_get_preferred_size (search_dialog, &requisition, NULL);
15044
15045   if (tree_x + tree_width > gdk_screen_get_width (screen))
15046     x = gdk_screen_get_width (screen) - requisition.width;
15047   else if (tree_x + tree_width - requisition.width < 0)
15048     x = 0;
15049   else
15050     x = tree_x + tree_width - requisition.width;
15051
15052   if (tree_y + tree_height + requisition.height > gdk_screen_get_height (screen))
15053     y = gdk_screen_get_height (screen) - requisition.height;
15054   else if (tree_y + tree_height < 0) /* isn't really possible ... */
15055     y = 0;
15056   else
15057     y = tree_y + tree_height;
15058
15059   gtk_window_move (GTK_WINDOW (search_dialog), x, y);
15060 }
15061
15062 static void
15063 gtk_tree_view_search_disable_popdown (GtkEntry *entry,
15064                                       GtkMenu  *menu,
15065                                       gpointer  data)
15066 {
15067   GtkTreeView *tree_view = (GtkTreeView *)data;
15068
15069   tree_view->priv->disable_popdown = 1;
15070   g_signal_connect (menu, "hide",
15071                     G_CALLBACK (gtk_tree_view_search_enable_popdown), data);
15072 }
15073
15074 /* Because we're visible but offscreen, we just set a flag in the preedit
15075  * callback.
15076  */
15077 static void
15078 gtk_tree_view_search_preedit_changed (GtkIMContext *im_context,
15079                                       GtkTreeView  *tree_view)
15080 {
15081   tree_view->priv->imcontext_changed = 1;
15082   if (tree_view->priv->typeselect_flush_timeout)
15083     {
15084       g_source_remove (tree_view->priv->typeselect_flush_timeout);
15085       tree_view->priv->typeselect_flush_timeout =
15086         gdk_threads_add_timeout (GTK_TREE_VIEW_SEARCH_DIALOG_TIMEOUT,
15087                        (GSourceFunc) gtk_tree_view_search_entry_flush_timeout,
15088                        tree_view);
15089     }
15090
15091 }
15092
15093 static void
15094 gtk_tree_view_search_activate (GtkEntry    *entry,
15095                                GtkTreeView *tree_view)
15096 {
15097   GtkTreePath *path;
15098
15099   gtk_tree_view_search_dialog_hide (tree_view->priv->search_window,
15100                                     tree_view,
15101                                     gtk_get_current_event_device ());
15102
15103   /* If we have a row selected and it's the cursor row, we activate
15104    * the row XXX */
15105   if (tree_view->priv->cursor_node &&
15106       GTK_RBNODE_FLAG_SET (tree_view->priv->cursor_node, GTK_RBNODE_IS_SELECTED))
15107     {
15108       path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
15109                                              tree_view->priv->cursor_node);
15110
15111       gtk_tree_view_row_activated (tree_view, path, tree_view->priv->focus_column);
15112
15113       gtk_tree_path_free (path);
15114     }
15115 }
15116
15117 static gboolean
15118 gtk_tree_view_real_search_enable_popdown (gpointer data)
15119 {
15120   GtkTreeView *tree_view = (GtkTreeView *)data;
15121
15122   tree_view->priv->disable_popdown = 0;
15123
15124   return FALSE;
15125 }
15126
15127 static void
15128 gtk_tree_view_search_enable_popdown (GtkWidget *widget,
15129                                      gpointer   data)
15130 {
15131   gdk_threads_add_timeout_full (G_PRIORITY_HIGH, 200, gtk_tree_view_real_search_enable_popdown, g_object_ref (data), g_object_unref);
15132 }
15133
15134 static gboolean
15135 gtk_tree_view_search_delete_event (GtkWidget *widget,
15136                                    GdkEventAny *event,
15137                                    GtkTreeView *tree_view)
15138 {
15139   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
15140
15141   gtk_tree_view_search_dialog_hide (widget, tree_view, NULL);
15142
15143   return TRUE;
15144 }
15145
15146 static gboolean
15147 gtk_tree_view_search_button_press_event (GtkWidget *widget,
15148                                          GdkEventButton *event,
15149                                          GtkTreeView *tree_view)
15150 {
15151   GdkDevice *keyb_device;
15152
15153   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
15154
15155   keyb_device = gdk_device_get_associated_device (event->device);
15156   gtk_tree_view_search_dialog_hide (widget, tree_view, keyb_device);
15157
15158   if (event->window == tree_view->priv->bin_window)
15159     gtk_tree_view_button_press (GTK_WIDGET (tree_view), event);
15160
15161   return TRUE;
15162 }
15163
15164 static gboolean
15165 gtk_tree_view_search_scroll_event (GtkWidget *widget,
15166                                    GdkEventScroll *event,
15167                                    GtkTreeView *tree_view)
15168 {
15169   gboolean retval = FALSE;
15170
15171   if (event->direction == GDK_SCROLL_UP)
15172     {
15173       gtk_tree_view_search_move (widget, tree_view, TRUE);
15174       retval = TRUE;
15175     }
15176   else if (event->direction == GDK_SCROLL_DOWN)
15177     {
15178       gtk_tree_view_search_move (widget, tree_view, FALSE);
15179       retval = TRUE;
15180     }
15181
15182   /* renew the flush timeout */
15183   if (retval && tree_view->priv->typeselect_flush_timeout
15184       && !tree_view->priv->search_custom_entry_set)
15185     {
15186       g_source_remove (tree_view->priv->typeselect_flush_timeout);
15187       tree_view->priv->typeselect_flush_timeout =
15188         gdk_threads_add_timeout (GTK_TREE_VIEW_SEARCH_DIALOG_TIMEOUT,
15189                        (GSourceFunc) gtk_tree_view_search_entry_flush_timeout,
15190                        tree_view);
15191     }
15192
15193   return retval;
15194 }
15195
15196 static gboolean
15197 gtk_tree_view_search_key_press_event (GtkWidget *widget,
15198                                       GdkEventKey *event,
15199                                       GtkTreeView *tree_view)
15200 {
15201   GdkModifierType default_accel;
15202   gboolean        retval = FALSE;
15203
15204   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
15205   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
15206
15207   /* close window and cancel the search */
15208   if (!tree_view->priv->search_custom_entry_set
15209       && (event->keyval == GDK_KEY_Escape ||
15210           event->keyval == GDK_KEY_Tab ||
15211             event->keyval == GDK_KEY_KP_Tab ||
15212             event->keyval == GDK_KEY_ISO_Left_Tab))
15213     {
15214       gtk_tree_view_search_dialog_hide (widget, tree_view,
15215                                         gdk_event_get_device ((GdkEvent *) event));
15216       return TRUE;
15217     }
15218
15219   default_accel = gtk_widget_get_modifier_mask (widget,
15220                                                 GDK_MODIFIER_INTENT_PRIMARY_ACCELERATOR);
15221
15222   /* select previous matching iter */
15223   if (event->keyval == GDK_KEY_Up || event->keyval == GDK_KEY_KP_Up)
15224     {
15225       if (!gtk_tree_view_search_move (widget, tree_view, TRUE))
15226         gtk_widget_error_bell (widget);
15227
15228       retval = TRUE;
15229     }
15230
15231   if (((event->state & (default_accel | GDK_SHIFT_MASK)) == (default_accel | GDK_SHIFT_MASK))
15232       && (event->keyval == GDK_KEY_g || event->keyval == GDK_KEY_G))
15233     {
15234       if (!gtk_tree_view_search_move (widget, tree_view, TRUE))
15235         gtk_widget_error_bell (widget);
15236
15237       retval = TRUE;
15238     }
15239
15240   /* select next matching iter */
15241   if (event->keyval == GDK_KEY_Down || event->keyval == GDK_KEY_KP_Down)
15242     {
15243       if (!gtk_tree_view_search_move (widget, tree_view, FALSE))
15244         gtk_widget_error_bell (widget);
15245
15246       retval = TRUE;
15247     }
15248
15249   if (((event->state & (default_accel | GDK_SHIFT_MASK)) == default_accel)
15250       && (event->keyval == GDK_KEY_g || event->keyval == GDK_KEY_G))
15251     {
15252       if (!gtk_tree_view_search_move (widget, tree_view, FALSE))
15253         gtk_widget_error_bell (widget);
15254
15255       retval = TRUE;
15256     }
15257
15258   /* renew the flush timeout */
15259   if (retval && tree_view->priv->typeselect_flush_timeout
15260       && !tree_view->priv->search_custom_entry_set)
15261     {
15262       g_source_remove (tree_view->priv->typeselect_flush_timeout);
15263       tree_view->priv->typeselect_flush_timeout =
15264         gdk_threads_add_timeout (GTK_TREE_VIEW_SEARCH_DIALOG_TIMEOUT,
15265                        (GSourceFunc) gtk_tree_view_search_entry_flush_timeout,
15266                        tree_view);
15267     }
15268
15269   return retval;
15270 }
15271
15272 /*  this function returns FALSE if there is a search string but
15273  *  nothing was found, and TRUE otherwise.
15274  */
15275 static gboolean
15276 gtk_tree_view_search_move (GtkWidget   *window,
15277                            GtkTreeView *tree_view,
15278                            gboolean     up)
15279 {
15280   gboolean ret;
15281   gint len;
15282   gint count = 0;
15283   const gchar *text;
15284   GtkTreeIter iter;
15285   GtkTreeModel *model;
15286   GtkTreeSelection *selection;
15287
15288   text = gtk_entry_get_text (GTK_ENTRY (tree_view->priv->search_entry));
15289
15290   g_return_val_if_fail (text != NULL, FALSE);
15291
15292   len = strlen (text);
15293
15294   if (up && tree_view->priv->selected_iter == 1)
15295     return strlen (text) < 1;
15296
15297   len = strlen (text);
15298
15299   if (len < 1)
15300     return TRUE;
15301
15302   model = gtk_tree_view_get_model (tree_view);
15303   selection = gtk_tree_view_get_selection (tree_view);
15304
15305   /* search */
15306   gtk_tree_selection_unselect_all (selection);
15307   if (!gtk_tree_model_get_iter_first (model, &iter))
15308     return TRUE;
15309
15310   ret = gtk_tree_view_search_iter (model, selection, &iter, text,
15311                                    &count, up?((tree_view->priv->selected_iter) - 1):((tree_view->priv->selected_iter + 1)));
15312
15313   if (ret)
15314     {
15315       /* found */
15316       tree_view->priv->selected_iter += up?(-1):(1);
15317       return TRUE;
15318     }
15319   else
15320     {
15321       /* return to old iter */
15322       count = 0;
15323       gtk_tree_model_get_iter_first (model, &iter);
15324       gtk_tree_view_search_iter (model, selection,
15325                                  &iter, text,
15326                                  &count, tree_view->priv->selected_iter);
15327       return FALSE;
15328     }
15329 }
15330
15331 static gboolean
15332 gtk_tree_view_search_equal_func (GtkTreeModel *model,
15333                                  gint          column,
15334                                  const gchar  *key,
15335                                  GtkTreeIter  *iter,
15336                                  gpointer      search_data)
15337 {
15338   gboolean retval = TRUE;
15339   const gchar *str;
15340   gchar *normalized_string;
15341   gchar *normalized_key;
15342   gchar *case_normalized_string = NULL;
15343   gchar *case_normalized_key = NULL;
15344   GValue value = G_VALUE_INIT;
15345   GValue transformed = G_VALUE_INIT;
15346
15347   gtk_tree_model_get_value (model, iter, column, &value);
15348
15349   g_value_init (&transformed, G_TYPE_STRING);
15350
15351   if (!g_value_transform (&value, &transformed))
15352     {
15353       g_value_unset (&value);
15354       return TRUE;
15355     }
15356
15357   g_value_unset (&value);
15358
15359   str = g_value_get_string (&transformed);
15360   if (!str)
15361     {
15362       g_value_unset (&transformed);
15363       return TRUE;
15364     }
15365
15366   normalized_string = g_utf8_normalize (str, -1, G_NORMALIZE_ALL);
15367   normalized_key = g_utf8_normalize (key, -1, G_NORMALIZE_ALL);
15368
15369   if (normalized_string && normalized_key)
15370     {
15371       case_normalized_string = g_utf8_casefold (normalized_string, -1);
15372       case_normalized_key = g_utf8_casefold (normalized_key, -1);
15373
15374       if (strncmp (case_normalized_key, case_normalized_string, strlen (case_normalized_key)) == 0)
15375         retval = FALSE;
15376     }
15377
15378   g_value_unset (&transformed);
15379   g_free (normalized_key);
15380   g_free (normalized_string);
15381   g_free (case_normalized_key);
15382   g_free (case_normalized_string);
15383
15384   return retval;
15385 }
15386
15387 static gboolean
15388 gtk_tree_view_search_iter (GtkTreeModel     *model,
15389                            GtkTreeSelection *selection,
15390                            GtkTreeIter      *iter,
15391                            const gchar      *text,
15392                            gint             *count,
15393                            gint              n)
15394 {
15395   GtkRBTree *tree = NULL;
15396   GtkRBNode *node = NULL;
15397   GtkTreePath *path;
15398
15399   GtkTreeView *tree_view = gtk_tree_selection_get_tree_view (selection);
15400
15401   path = gtk_tree_model_get_path (model, iter);
15402   _gtk_tree_view_find_node (tree_view, path, &tree, &node);
15403
15404   do
15405     {
15406       if (! tree_view->priv->search_equal_func (model, tree_view->priv->search_column, text, iter, tree_view->priv->search_user_data))
15407         {
15408           (*count)++;
15409           if (*count == n)
15410             {
15411               gtk_tree_view_scroll_to_cell (tree_view, path, NULL,
15412                                             TRUE, 0.5, 0.0);
15413               gtk_tree_selection_select_iter (selection, iter);
15414               gtk_tree_view_real_set_cursor (tree_view, path, CLAMP_NODE);
15415
15416               if (path)
15417                 gtk_tree_path_free (path);
15418
15419               return TRUE;
15420             }
15421         }
15422
15423       if (node->children)
15424         {
15425           gboolean has_child;
15426           GtkTreeIter tmp;
15427
15428           tree = node->children;
15429           node = _gtk_rbtree_first (tree);
15430
15431           tmp = *iter;
15432           has_child = gtk_tree_model_iter_children (model, iter, &tmp);
15433           gtk_tree_path_down (path);
15434
15435           /* sanity check */
15436           TREE_VIEW_INTERNAL_ASSERT (has_child, FALSE);
15437         }
15438       else
15439         {
15440           gboolean done = FALSE;
15441
15442           do
15443             {
15444               node = _gtk_rbtree_next (tree, node);
15445
15446               if (node)
15447                 {
15448                   gboolean has_next;
15449
15450                   has_next = gtk_tree_model_iter_next (model, iter);
15451
15452                   done = TRUE;
15453                   gtk_tree_path_next (path);
15454
15455                   /* sanity check */
15456                   TREE_VIEW_INTERNAL_ASSERT (has_next, FALSE);
15457                 }
15458               else
15459                 {
15460                   gboolean has_parent;
15461                   GtkTreeIter tmp_iter = *iter;
15462
15463                   node = tree->parent_node;
15464                   tree = tree->parent_tree;
15465
15466                   if (!tree)
15467                     {
15468                       if (path)
15469                         gtk_tree_path_free (path);
15470
15471                       /* we've run out of tree, done with this func */
15472                       return FALSE;
15473                     }
15474
15475                   has_parent = gtk_tree_model_iter_parent (model,
15476                                                            iter,
15477                                                            &tmp_iter);
15478                   gtk_tree_path_up (path);
15479
15480                   /* sanity check */
15481                   TREE_VIEW_INTERNAL_ASSERT (has_parent, FALSE);
15482                 }
15483             }
15484           while (!done);
15485         }
15486     }
15487   while (1);
15488
15489   return FALSE;
15490 }
15491
15492 static void
15493 gtk_tree_view_search_init (GtkWidget   *entry,
15494                            GtkTreeView *tree_view)
15495 {
15496   gint ret;
15497   gint count = 0;
15498   const gchar *text;
15499   GtkTreeIter iter;
15500   GtkTreeModel *model;
15501   GtkTreeSelection *selection;
15502
15503   g_return_if_fail (GTK_IS_ENTRY (entry));
15504   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
15505
15506   text = gtk_entry_get_text (GTK_ENTRY (entry));
15507
15508   model = gtk_tree_view_get_model (tree_view);
15509   selection = gtk_tree_view_get_selection (tree_view);
15510
15511   /* search */
15512   gtk_tree_selection_unselect_all (selection);
15513   if (tree_view->priv->typeselect_flush_timeout
15514       && !tree_view->priv->search_custom_entry_set)
15515     {
15516       g_source_remove (tree_view->priv->typeselect_flush_timeout);
15517       tree_view->priv->typeselect_flush_timeout =
15518         gdk_threads_add_timeout (GTK_TREE_VIEW_SEARCH_DIALOG_TIMEOUT,
15519                        (GSourceFunc) gtk_tree_view_search_entry_flush_timeout,
15520                        tree_view);
15521     }
15522
15523   if (*text == '\0')
15524     return;
15525
15526   if (!gtk_tree_model_get_iter_first (model, &iter))
15527     return;
15528
15529   ret = gtk_tree_view_search_iter (model, selection,
15530                                    &iter, text,
15531                                    &count, 1);
15532
15533   if (ret)
15534     tree_view->priv->selected_iter = 1;
15535 }
15536
15537 void
15538 _gtk_tree_view_remove_editable (GtkTreeView       *tree_view,
15539                                 GtkTreeViewColumn *column,
15540                                 GtkCellEditable   *cell_editable)
15541 {
15542   if (tree_view->priv->edited_column == NULL)
15543     return;
15544
15545   g_return_if_fail (column == tree_view->priv->edited_column);
15546
15547   tree_view->priv->edited_column = NULL;
15548
15549   if (gtk_widget_has_focus (GTK_WIDGET (cell_editable)))
15550     gtk_widget_grab_focus (GTK_WIDGET (tree_view));
15551
15552   gtk_container_remove (GTK_CONTAINER (tree_view),
15553                         GTK_WIDGET (cell_editable));
15554
15555   /* FIXME should only redraw a single node */
15556   gtk_widget_queue_draw (GTK_WIDGET (tree_view));
15557 }
15558
15559 static gboolean
15560 gtk_tree_view_start_editing (GtkTreeView *tree_view,
15561                              GtkTreePath *cursor_path,
15562                              gboolean     edit_only)
15563 {
15564   GtkTreeIter iter;
15565   GdkRectangle cell_area;
15566   GtkTreeViewColumn *focus_column;
15567   guint flags = 0; /* can be 0, as the flags are primarily for rendering */
15568   gint retval = FALSE;
15569   GtkRBTree *cursor_tree;
15570   GtkRBNode *cursor_node;
15571
15572   g_assert (tree_view->priv->focus_column);
15573   focus_column = tree_view->priv->focus_column;
15574
15575   if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
15576     return FALSE;
15577
15578   if (_gtk_tree_view_find_node (tree_view, cursor_path, &cursor_tree, &cursor_node) ||
15579       cursor_node == NULL)
15580     return FALSE;
15581
15582   gtk_tree_model_get_iter (tree_view->priv->model, &iter, cursor_path);
15583
15584   validate_row (tree_view, cursor_tree, cursor_node, &iter, cursor_path);
15585
15586   gtk_tree_view_column_cell_set_cell_data (focus_column,
15587                                            tree_view->priv->model,
15588                                            &iter,
15589                                            GTK_RBNODE_FLAG_SET (cursor_node, GTK_RBNODE_IS_PARENT),
15590                                            cursor_node->children ? TRUE : FALSE);
15591   gtk_tree_view_get_cell_area (tree_view,
15592                                cursor_path,
15593                                focus_column,
15594                                &cell_area);
15595
15596   if (gtk_cell_area_activate (gtk_cell_layout_get_area (GTK_CELL_LAYOUT (focus_column)),
15597                               _gtk_tree_view_column_get_context (focus_column),
15598                               GTK_WIDGET (tree_view),
15599                               &cell_area,
15600                               flags, edit_only))
15601     retval = TRUE;
15602
15603   return retval;
15604 }
15605
15606 void
15607 _gtk_tree_view_add_editable (GtkTreeView       *tree_view,
15608                              GtkTreeViewColumn *column,
15609                              GtkTreePath       *path,
15610                              GtkCellEditable   *cell_editable,
15611                              GdkRectangle      *cell_area)
15612 {
15613   gint pre_val = gtk_adjustment_get_value (tree_view->priv->vadjustment);
15614   GtkRequisition requisition;
15615
15616   tree_view->priv->edited_column = column;
15617
15618   gtk_tree_view_real_set_cursor (tree_view, path, CLAMP_NODE);
15619   cell_area->y += pre_val - (int)gtk_adjustment_get_value (tree_view->priv->vadjustment);
15620
15621   gtk_widget_get_preferred_size (GTK_WIDGET (cell_editable),
15622                                  &requisition, NULL);
15623
15624   tree_view->priv->draw_keyfocus = TRUE;
15625
15626   if (requisition.height < cell_area->height)
15627     {
15628       gint diff = cell_area->height - requisition.height;
15629       gtk_tree_view_put (tree_view,
15630                          GTK_WIDGET (cell_editable),
15631                          cell_area->x, cell_area->y + diff/2,
15632                          cell_area->width, requisition.height);
15633     }
15634   else
15635     {
15636       gtk_tree_view_put (tree_view,
15637                          GTK_WIDGET (cell_editable),
15638                          cell_area->x, cell_area->y,
15639                          cell_area->width, cell_area->height);
15640     }
15641 }
15642
15643 static void
15644 gtk_tree_view_stop_editing (GtkTreeView *tree_view,
15645                             gboolean     cancel_editing)
15646 {
15647   GtkTreeViewColumn *column;
15648
15649   if (tree_view->priv->edited_column == NULL)
15650     return;
15651
15652   /*
15653    * This is very evil. We need to do this, because
15654    * gtk_cell_editable_editing_done may trigger gtk_tree_view_row_changed
15655    * later on. If gtk_tree_view_row_changed notices
15656    * tree_view->priv->edited_column != NULL, it'll call
15657    * gtk_tree_view_stop_editing again. Bad things will happen then.
15658    *
15659    * Please read that again if you intend to modify anything here.
15660    */
15661
15662   column = tree_view->priv->edited_column;
15663   gtk_cell_area_stop_editing (gtk_cell_layout_get_area (GTK_CELL_LAYOUT (column)), cancel_editing);
15664   tree_view->priv->edited_column = NULL;
15665 }
15666
15667
15668 /**
15669  * gtk_tree_view_set_hover_selection:
15670  * @tree_view: a #GtkTreeView
15671  * @hover: %TRUE to enable hover selection mode
15672  *
15673  * Enables or disables the hover selection mode of @tree_view.
15674  * Hover selection makes the selected row follow the pointer.
15675  * Currently, this works only for the selection modes
15676  * %GTK_SELECTION_SINGLE and %GTK_SELECTION_BROWSE.
15677  *
15678  * Since: 2.6
15679  **/
15680 void
15681 gtk_tree_view_set_hover_selection (GtkTreeView *tree_view,
15682                                    gboolean     hover)
15683 {
15684   hover = hover != FALSE;
15685
15686   if (hover != tree_view->priv->hover_selection)
15687     {
15688       tree_view->priv->hover_selection = hover;
15689
15690       g_object_notify (G_OBJECT (tree_view), "hover-selection");
15691     }
15692 }
15693
15694 /**
15695  * gtk_tree_view_get_hover_selection:
15696  * @tree_view: a #GtkTreeView
15697  *
15698  * Returns whether hover selection mode is turned on for @tree_view.
15699  *
15700  * Return value: %TRUE if @tree_view is in hover selection mode
15701  *
15702  * Since: 2.6
15703  **/
15704 gboolean
15705 gtk_tree_view_get_hover_selection (GtkTreeView *tree_view)
15706 {
15707   return tree_view->priv->hover_selection;
15708 }
15709
15710 /**
15711  * gtk_tree_view_set_hover_expand:
15712  * @tree_view: a #GtkTreeView
15713  * @expand: %TRUE to enable hover selection mode
15714  *
15715  * Enables or disables the hover expansion mode of @tree_view.
15716  * Hover expansion makes rows expand or collapse if the pointer
15717  * moves over them.
15718  *
15719  * Since: 2.6
15720  **/
15721 void
15722 gtk_tree_view_set_hover_expand (GtkTreeView *tree_view,
15723                                 gboolean     expand)
15724 {
15725   expand = expand != FALSE;
15726
15727   if (expand != tree_view->priv->hover_expand)
15728     {
15729       tree_view->priv->hover_expand = expand;
15730
15731       g_object_notify (G_OBJECT (tree_view), "hover-expand");
15732     }
15733 }
15734
15735 /**
15736  * gtk_tree_view_get_hover_expand:
15737  * @tree_view: a #GtkTreeView
15738  *
15739  * Returns whether hover expansion mode is turned on for @tree_view.
15740  *
15741  * Return value: %TRUE if @tree_view is in hover expansion mode
15742  *
15743  * Since: 2.6
15744  **/
15745 gboolean
15746 gtk_tree_view_get_hover_expand (GtkTreeView *tree_view)
15747 {
15748   return tree_view->priv->hover_expand;
15749 }
15750
15751 /**
15752  * gtk_tree_view_set_rubber_banding:
15753  * @tree_view: a #GtkTreeView
15754  * @enable: %TRUE to enable rubber banding
15755  *
15756  * Enables or disables rubber banding in @tree_view.  If the selection mode
15757  * is #GTK_SELECTION_MULTIPLE, rubber banding will allow the user to select
15758  * multiple rows by dragging the mouse.
15759  *
15760  * Since: 2.10
15761  **/
15762 void
15763 gtk_tree_view_set_rubber_banding (GtkTreeView *tree_view,
15764                                   gboolean     enable)
15765 {
15766   enable = enable != FALSE;
15767
15768   if (enable != tree_view->priv->rubber_banding_enable)
15769     {
15770       tree_view->priv->rubber_banding_enable = enable;
15771
15772       g_object_notify (G_OBJECT (tree_view), "rubber-banding");
15773     }
15774 }
15775
15776 /**
15777  * gtk_tree_view_get_rubber_banding:
15778  * @tree_view: a #GtkTreeView
15779  *
15780  * Returns whether rubber banding is turned on for @tree_view.  If the
15781  * selection mode is #GTK_SELECTION_MULTIPLE, rubber banding will allow the
15782  * user to select multiple rows by dragging the mouse.
15783  *
15784  * Return value: %TRUE if rubber banding in @tree_view is enabled.
15785  *
15786  * Since: 2.10
15787  **/
15788 gboolean
15789 gtk_tree_view_get_rubber_banding (GtkTreeView *tree_view)
15790 {
15791   return tree_view->priv->rubber_banding_enable;
15792 }
15793
15794 /**
15795  * gtk_tree_view_is_rubber_banding_active:
15796  * @tree_view: a #GtkTreeView
15797  *
15798  * Returns whether a rubber banding operation is currently being done
15799  * in @tree_view.
15800  *
15801  * Return value: %TRUE if a rubber banding operation is currently being
15802  * done in @tree_view.
15803  *
15804  * Since: 2.12
15805  **/
15806 gboolean
15807 gtk_tree_view_is_rubber_banding_active (GtkTreeView *tree_view)
15808 {
15809   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
15810
15811   if (tree_view->priv->rubber_banding_enable
15812       && tree_view->priv->rubber_band_status == RUBBER_BAND_ACTIVE)
15813     return TRUE;
15814
15815   return FALSE;
15816 }
15817
15818 /**
15819  * gtk_tree_view_get_row_separator_func: (skip)
15820  * @tree_view: a #GtkTreeView
15821  *
15822  * Returns the current row separator function.
15823  *
15824  * Return value: the current row separator function.
15825  *
15826  * Since: 2.6
15827  **/
15828 GtkTreeViewRowSeparatorFunc
15829 gtk_tree_view_get_row_separator_func (GtkTreeView *tree_view)
15830 {
15831   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
15832
15833   return tree_view->priv->row_separator_func;
15834 }
15835
15836 /**
15837  * gtk_tree_view_set_row_separator_func:
15838  * @tree_view: a #GtkTreeView
15839  * @func: (allow-none): a #GtkTreeViewRowSeparatorFunc
15840  * @data: (allow-none): user data to pass to @func, or %NULL
15841  * @destroy: (allow-none): destroy notifier for @data, or %NULL
15842  *
15843  * Sets the row separator function, which is used to determine
15844  * whether a row should be drawn as a separator. If the row separator
15845  * function is %NULL, no separators are drawn. This is the default value.
15846  *
15847  * Since: 2.6
15848  **/
15849 void
15850 gtk_tree_view_set_row_separator_func (GtkTreeView                 *tree_view,
15851                                       GtkTreeViewRowSeparatorFunc  func,
15852                                       gpointer                     data,
15853                                       GDestroyNotify               destroy)
15854 {
15855   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
15856
15857   if (tree_view->priv->row_separator_destroy)
15858     tree_view->priv->row_separator_destroy (tree_view->priv->row_separator_data);
15859
15860   tree_view->priv->row_separator_func = func;
15861   tree_view->priv->row_separator_data = data;
15862   tree_view->priv->row_separator_destroy = destroy;
15863
15864   /* Have the tree recalculate heights */
15865   _gtk_rbtree_mark_invalid (tree_view->priv->tree);
15866   gtk_widget_queue_resize (GTK_WIDGET (tree_view));
15867 }
15868
15869
15870 static void
15871 gtk_tree_view_grab_notify (GtkWidget *widget,
15872                            gboolean   was_grabbed)
15873 {
15874   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
15875
15876   tree_view->priv->in_grab = !was_grabbed;
15877
15878   if (!was_grabbed)
15879     {
15880       tree_view->priv->pressed_button = -1;
15881
15882       if (tree_view->priv->rubber_band_status)
15883         gtk_tree_view_stop_rubber_band (tree_view);
15884     }
15885 }
15886
15887 static void
15888 gtk_tree_view_state_flags_changed (GtkWidget     *widget,
15889                                    GtkStateFlags  previous_state)
15890 {
15891   if (gtk_widget_get_realized (widget))
15892     gtk_tree_view_ensure_background (GTK_TREE_VIEW (widget));
15893
15894   gtk_widget_queue_draw (widget);
15895 }
15896
15897 /**
15898  * gtk_tree_view_get_grid_lines:
15899  * @tree_view: a #GtkTreeView
15900  *
15901  * Returns which grid lines are enabled in @tree_view.
15902  *
15903  * Return value: a #GtkTreeViewGridLines value indicating which grid lines
15904  * are enabled.
15905  *
15906  * Since: 2.10
15907  */
15908 GtkTreeViewGridLines
15909 gtk_tree_view_get_grid_lines (GtkTreeView *tree_view)
15910 {
15911   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), 0);
15912
15913   return tree_view->priv->grid_lines;
15914 }
15915
15916 /**
15917  * gtk_tree_view_set_grid_lines:
15918  * @tree_view: a #GtkTreeView
15919  * @grid_lines: a #GtkTreeViewGridLines value indicating which grid lines to
15920  * enable.
15921  *
15922  * Sets which grid lines to draw in @tree_view.
15923  *
15924  * Since: 2.10
15925  */
15926 void
15927 gtk_tree_view_set_grid_lines (GtkTreeView           *tree_view,
15928                               GtkTreeViewGridLines   grid_lines)
15929 {
15930   GtkTreeViewPrivate *priv;
15931   GtkWidget *widget;
15932   GtkTreeViewGridLines old_grid_lines;
15933
15934   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
15935
15936   priv = tree_view->priv;
15937   widget = GTK_WIDGET (tree_view);
15938
15939   old_grid_lines = priv->grid_lines;
15940   priv->grid_lines = grid_lines;
15941
15942   if (gtk_widget_get_realized (widget))
15943     {
15944       if (grid_lines == GTK_TREE_VIEW_GRID_LINES_NONE &&
15945           priv->grid_line_width)
15946         {
15947           priv->grid_line_width = 0;
15948         }
15949
15950       if (grid_lines != GTK_TREE_VIEW_GRID_LINES_NONE &&
15951           !priv->grid_line_width)
15952         {
15953           gint8 *dash_list;
15954
15955           gtk_widget_style_get (widget,
15956                                 "grid-line-width", &priv->grid_line_width,
15957                                 "grid-line-pattern", (gchar *)&dash_list,
15958                                 NULL);
15959
15960           if (dash_list)
15961             {
15962               priv->grid_line_dashes[0] = dash_list[0];
15963               if (dash_list[0])
15964                 priv->grid_line_dashes[1] = dash_list[1];
15965
15966               g_free (dash_list);
15967             }
15968           else
15969             {
15970               priv->grid_line_dashes[0] = 1;
15971               priv->grid_line_dashes[1] = 1;
15972             }
15973         }
15974     }
15975
15976   if (old_grid_lines != grid_lines)
15977     {
15978       gtk_widget_queue_draw (GTK_WIDGET (tree_view));
15979
15980       g_object_notify (G_OBJECT (tree_view), "enable-grid-lines");
15981     }
15982 }
15983
15984 /**
15985  * gtk_tree_view_get_enable_tree_lines:
15986  * @tree_view: a #GtkTreeView.
15987  *
15988  * Returns whether or not tree lines are drawn in @tree_view.
15989  *
15990  * Return value: %TRUE if tree lines are drawn in @tree_view, %FALSE
15991  * otherwise.
15992  *
15993  * Since: 2.10
15994  */
15995 gboolean
15996 gtk_tree_view_get_enable_tree_lines (GtkTreeView *tree_view)
15997 {
15998   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
15999
16000   return tree_view->priv->tree_lines_enabled;
16001 }
16002
16003 /**
16004  * gtk_tree_view_set_enable_tree_lines:
16005  * @tree_view: a #GtkTreeView
16006  * @enabled: %TRUE to enable tree line drawing, %FALSE otherwise.
16007  *
16008  * Sets whether to draw lines interconnecting the expanders in @tree_view.
16009  * This does not have any visible effects for lists.
16010  *
16011  * Since: 2.10
16012  */
16013 void
16014 gtk_tree_view_set_enable_tree_lines (GtkTreeView *tree_view,
16015                                      gboolean     enabled)
16016 {
16017   GtkTreeViewPrivate *priv;
16018   GtkWidget *widget;
16019   gboolean was_enabled;
16020
16021   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
16022
16023   enabled = enabled != FALSE;
16024
16025   priv = tree_view->priv;
16026   widget = GTK_WIDGET (tree_view);
16027
16028   was_enabled = priv->tree_lines_enabled;
16029
16030   priv->tree_lines_enabled = enabled;
16031
16032   if (gtk_widget_get_realized (widget))
16033     {
16034       if (!enabled && priv->tree_line_width)
16035         {
16036           priv->tree_line_width = 0;
16037         }
16038
16039       if (enabled && !priv->tree_line_width)
16040         {
16041           gint8 *dash_list;
16042           gtk_widget_style_get (widget,
16043                                 "tree-line-width", &priv->tree_line_width,
16044                                 "tree-line-pattern", (gchar *)&dash_list,
16045                                 NULL);
16046
16047           if (dash_list)
16048             {
16049               priv->tree_line_dashes[0] = dash_list[0];
16050               if (dash_list[0])
16051                 priv->tree_line_dashes[1] = dash_list[1];
16052
16053               g_free (dash_list);
16054             }
16055           else
16056             {
16057               priv->tree_line_dashes[0] = 1;
16058               priv->tree_line_dashes[1] = 1;
16059             }
16060         }
16061     }
16062
16063   if (was_enabled != enabled)
16064     {
16065       gtk_widget_queue_draw (GTK_WIDGET (tree_view));
16066
16067       g_object_notify (G_OBJECT (tree_view), "enable-tree-lines");
16068     }
16069 }
16070
16071
16072 /**
16073  * gtk_tree_view_set_show_expanders:
16074  * @tree_view: a #GtkTreeView
16075  * @enabled: %TRUE to enable expander drawing, %FALSE otherwise.
16076  *
16077  * Sets whether to draw and enable expanders and indent child rows in
16078  * @tree_view.  When disabled there will be no expanders visible in trees
16079  * and there will be no way to expand and collapse rows by default.  Also
16080  * note that hiding the expanders will disable the default indentation.  You
16081  * can set a custom indentation in this case using
16082  * gtk_tree_view_set_level_indentation().
16083  * This does not have any visible effects for lists.
16084  *
16085  * Since: 2.12
16086  */
16087 void
16088 gtk_tree_view_set_show_expanders (GtkTreeView *tree_view,
16089                                   gboolean     enabled)
16090 {
16091   gboolean was_enabled;
16092
16093   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
16094
16095   enabled = enabled != FALSE;
16096   was_enabled = tree_view->priv->show_expanders;
16097
16098   tree_view->priv->show_expanders = enabled == TRUE;
16099
16100   if (enabled != was_enabled)
16101     gtk_widget_queue_draw (GTK_WIDGET (tree_view));
16102 }
16103
16104 /**
16105  * gtk_tree_view_get_show_expanders:
16106  * @tree_view: a #GtkTreeView.
16107  *
16108  * Returns whether or not expanders are drawn in @tree_view.
16109  *
16110  * Return value: %TRUE if expanders are drawn in @tree_view, %FALSE
16111  * otherwise.
16112  *
16113  * Since: 2.12
16114  */
16115 gboolean
16116 gtk_tree_view_get_show_expanders (GtkTreeView *tree_view)
16117 {
16118   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
16119
16120   return tree_view->priv->show_expanders;
16121 }
16122
16123 /**
16124  * gtk_tree_view_set_level_indentation:
16125  * @tree_view: a #GtkTreeView
16126  * @indentation: the amount, in pixels, of extra indentation in @tree_view.
16127  *
16128  * Sets the amount of extra indentation for child levels to use in @tree_view
16129  * in addition to the default indentation.  The value should be specified in
16130  * pixels, a value of 0 disables this feature and in this case only the default
16131  * indentation will be used.
16132  * This does not have any visible effects for lists.
16133  *
16134  * Since: 2.12
16135  */
16136 void
16137 gtk_tree_view_set_level_indentation (GtkTreeView *tree_view,
16138                                      gint         indentation)
16139 {
16140   tree_view->priv->level_indentation = indentation;
16141
16142   gtk_widget_queue_draw (GTK_WIDGET (tree_view));
16143 }
16144
16145 /**
16146  * gtk_tree_view_get_level_indentation:
16147  * @tree_view: a #GtkTreeView.
16148  *
16149  * Returns the amount, in pixels, of extra indentation for child levels
16150  * in @tree_view.
16151  *
16152  * Return value: the amount of extra indentation for child levels in
16153  * @tree_view.  A return value of 0 means that this feature is disabled.
16154  *
16155  * Since: 2.12
16156  */
16157 gint
16158 gtk_tree_view_get_level_indentation (GtkTreeView *tree_view)
16159 {
16160   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), 0);
16161
16162   return tree_view->priv->level_indentation;
16163 }
16164
16165 /**
16166  * gtk_tree_view_set_tooltip_row:
16167  * @tree_view: a #GtkTreeView
16168  * @tooltip: a #GtkTooltip
16169  * @path: a #GtkTreePath
16170  *
16171  * Sets the tip area of @tooltip to be the area covered by the row at @path.
16172  * See also gtk_tree_view_set_tooltip_column() for a simpler alternative.
16173  * See also gtk_tooltip_set_tip_area().
16174  *
16175  * Since: 2.12
16176  */
16177 void
16178 gtk_tree_view_set_tooltip_row (GtkTreeView *tree_view,
16179                                GtkTooltip  *tooltip,
16180                                GtkTreePath *path)
16181 {
16182   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
16183   g_return_if_fail (GTK_IS_TOOLTIP (tooltip));
16184
16185   gtk_tree_view_set_tooltip_cell (tree_view, tooltip, path, NULL, NULL);
16186 }
16187
16188 /**
16189  * gtk_tree_view_set_tooltip_cell:
16190  * @tree_view: a #GtkTreeView
16191  * @tooltip: a #GtkTooltip
16192  * @path: (allow-none): a #GtkTreePath or %NULL
16193  * @column: (allow-none): a #GtkTreeViewColumn or %NULL
16194  * @cell: (allow-none): a #GtkCellRenderer or %NULL
16195  *
16196  * Sets the tip area of @tooltip to the area @path, @column and @cell have
16197  * in common.  For example if @path is %NULL and @column is set, the tip
16198  * area will be set to the full area covered by @column.  See also
16199  * gtk_tooltip_set_tip_area().
16200  *
16201  * Note that if @path is not specified and @cell is set and part of a column
16202  * containing the expander, the tooltip might not show and hide at the correct
16203  * position.  In such cases @path must be set to the current node under the
16204  * mouse cursor for this function to operate correctly.
16205  *
16206  * See also gtk_tree_view_set_tooltip_column() for a simpler alternative.
16207  *
16208  * Since: 2.12
16209  */
16210 void
16211 gtk_tree_view_set_tooltip_cell (GtkTreeView       *tree_view,
16212                                 GtkTooltip        *tooltip,
16213                                 GtkTreePath       *path,
16214                                 GtkTreeViewColumn *column,
16215                                 GtkCellRenderer   *cell)
16216 {
16217   GtkAllocation allocation;
16218   GdkRectangle rect;
16219
16220   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
16221   g_return_if_fail (GTK_IS_TOOLTIP (tooltip));
16222   g_return_if_fail (column == NULL || GTK_IS_TREE_VIEW_COLUMN (column));
16223   g_return_if_fail (cell == NULL || GTK_IS_CELL_RENDERER (cell));
16224
16225   /* Determine x values. */
16226   if (column && cell)
16227     {
16228       GdkRectangle tmp;
16229       gint start, width;
16230
16231       /* We always pass in path here, whether it is NULL or not.
16232        * For cells in expander columns path must be specified so that
16233        * we can correctly account for the indentation.  This also means
16234        * that the tooltip is constrained vertically by the "Determine y
16235        * values" code below; this is not a real problem since cells actually
16236        * don't stretch vertically in constrast to columns.
16237        */
16238       gtk_tree_view_get_cell_area (tree_view, path, column, &tmp);
16239       gtk_tree_view_column_cell_get_position (column, cell, &start, &width);
16240
16241       gtk_tree_view_convert_bin_window_to_widget_coords (tree_view,
16242                                                          tmp.x + start, 0,
16243                                                          &rect.x, NULL);
16244       rect.width = width;
16245     }
16246   else if (column)
16247     {
16248       GdkRectangle tmp;
16249
16250       gtk_tree_view_get_background_area (tree_view, NULL, column, &tmp);
16251       gtk_tree_view_convert_bin_window_to_widget_coords (tree_view,
16252                                                          tmp.x, 0,
16253                                                          &rect.x, NULL);
16254       rect.width = tmp.width;
16255     }
16256   else
16257     {
16258       gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
16259       rect.x = 0;
16260       rect.width = allocation.width;
16261     }
16262
16263   /* Determine y values. */
16264   if (path)
16265     {
16266       GdkRectangle tmp;
16267
16268       gtk_tree_view_get_background_area (tree_view, path, NULL, &tmp);
16269       gtk_tree_view_convert_bin_window_to_widget_coords (tree_view,
16270                                                          0, tmp.y,
16271                                                          NULL, &rect.y);
16272       rect.height = tmp.height;
16273     }
16274   else
16275     {
16276       rect.y = 0;
16277       rect.height = gtk_adjustment_get_page_size (tree_view->priv->vadjustment);
16278     }
16279
16280   gtk_tooltip_set_tip_area (tooltip, &rect);
16281 }
16282
16283 /**
16284  * gtk_tree_view_get_tooltip_context:
16285  * @tree_view: a #GtkTreeView
16286  * @x: (inout): the x coordinate (relative to widget coordinates)
16287  * @y: (inout): the y coordinate (relative to widget coordinates)
16288  * @keyboard_tip: whether this is a keyboard tooltip or not
16289  * @model: (out) (allow-none) (transfer none): a pointer to receive a
16290  *         #GtkTreeModel or %NULL
16291  * @path: (out) (allow-none): a pointer to receive a #GtkTreePath or %NULL
16292  * @iter: (out) (allow-none): a pointer to receive a #GtkTreeIter or %NULL
16293  *
16294  * This function is supposed to be used in a #GtkWidget::query-tooltip
16295  * signal handler for #GtkTreeView.  The @x, @y and @keyboard_tip values
16296  * which are received in the signal handler, should be passed to this
16297  * function without modification.
16298  *
16299  * The return value indicates whether there is a tree view row at the given
16300  * coordinates (%TRUE) or not (%FALSE) for mouse tooltips.  For keyboard
16301  * tooltips the row returned will be the cursor row.  When %TRUE, then any of
16302  * @model, @path and @iter which have been provided will be set to point to
16303  * that row and the corresponding model.  @x and @y will always be converted
16304  * to be relative to @tree_view's bin_window if @keyboard_tooltip is %FALSE.
16305  *
16306  * Return value: whether or not the given tooltip context points to a row.
16307  *
16308  * Since: 2.12
16309  */
16310 gboolean
16311 gtk_tree_view_get_tooltip_context (GtkTreeView   *tree_view,
16312                                    gint          *x,
16313                                    gint          *y,
16314                                    gboolean       keyboard_tip,
16315                                    GtkTreeModel **model,
16316                                    GtkTreePath  **path,
16317                                    GtkTreeIter   *iter)
16318 {
16319   GtkTreePath *tmppath = NULL;
16320
16321   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
16322   g_return_val_if_fail (x != NULL, FALSE);
16323   g_return_val_if_fail (y != NULL, FALSE);
16324
16325   if (keyboard_tip)
16326     {
16327       gtk_tree_view_get_cursor (tree_view, &tmppath, NULL);
16328
16329       if (!tmppath)
16330         return FALSE;
16331     }
16332   else
16333     {
16334       gtk_tree_view_convert_widget_to_bin_window_coords (tree_view, *x, *y,
16335                                                          x, y);
16336
16337       if (!gtk_tree_view_get_path_at_pos (tree_view, *x, *y,
16338                                           &tmppath, NULL, NULL, NULL))
16339         return FALSE;
16340     }
16341
16342   if (model)
16343     *model = gtk_tree_view_get_model (tree_view);
16344
16345   if (iter)
16346     gtk_tree_model_get_iter (gtk_tree_view_get_model (tree_view),
16347                              iter, tmppath);
16348
16349   if (path)
16350     *path = tmppath;
16351   else
16352     gtk_tree_path_free (tmppath);
16353
16354   return TRUE;
16355 }
16356
16357 static gboolean
16358 gtk_tree_view_set_tooltip_query_cb (GtkWidget  *widget,
16359                                     gint        x,
16360                                     gint        y,
16361                                     gboolean    keyboard_tip,
16362                                     GtkTooltip *tooltip,
16363                                     gpointer    data)
16364 {
16365   GValue value = G_VALUE_INIT;
16366   GValue transformed = G_VALUE_INIT;
16367   GtkTreeIter iter;
16368   GtkTreePath *path;
16369   GtkTreeModel *model;
16370   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
16371
16372   if (!gtk_tree_view_get_tooltip_context (GTK_TREE_VIEW (widget),
16373                                           &x, &y,
16374                                           keyboard_tip,
16375                                           &model, &path, &iter))
16376     return FALSE;
16377
16378   gtk_tree_model_get_value (model, &iter,
16379                             tree_view->priv->tooltip_column, &value);
16380
16381   g_value_init (&transformed, G_TYPE_STRING);
16382
16383   if (!g_value_transform (&value, &transformed))
16384     {
16385       g_value_unset (&value);
16386       gtk_tree_path_free (path);
16387
16388       return FALSE;
16389     }
16390
16391   g_value_unset (&value);
16392
16393   if (!g_value_get_string (&transformed))
16394     {
16395       g_value_unset (&transformed);
16396       gtk_tree_path_free (path);
16397
16398       return FALSE;
16399     }
16400
16401   gtk_tooltip_set_markup (tooltip, g_value_get_string (&transformed));
16402   gtk_tree_view_set_tooltip_row (tree_view, tooltip, path);
16403
16404   gtk_tree_path_free (path);
16405   g_value_unset (&transformed);
16406
16407   return TRUE;
16408 }
16409
16410 /**
16411  * gtk_tree_view_set_tooltip_column:
16412  * @tree_view: a #GtkTreeView
16413  * @column: an integer, which is a valid column number for @tree_view's model
16414  *
16415  * If you only plan to have simple (text-only) tooltips on full rows, you
16416  * can use this function to have #GtkTreeView handle these automatically
16417  * for you. @column should be set to the column in @tree_view's model
16418  * containing the tooltip texts, or -1 to disable this feature.
16419  *
16420  * When enabled, #GtkWidget:has-tooltip will be set to %TRUE and
16421  * @tree_view will connect a #GtkWidget::query-tooltip signal handler.
16422  *
16423  * Note that the signal handler sets the text with gtk_tooltip_set_markup(),
16424  * so &amp;, &lt;, etc have to be escaped in the text.
16425  *
16426  * Since: 2.12
16427  */
16428 void
16429 gtk_tree_view_set_tooltip_column (GtkTreeView *tree_view,
16430                                   gint         column)
16431 {
16432   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
16433
16434   if (column == tree_view->priv->tooltip_column)
16435     return;
16436
16437   if (column == -1)
16438     {
16439       g_signal_handlers_disconnect_by_func (tree_view,
16440                                             gtk_tree_view_set_tooltip_query_cb,
16441                                             NULL);
16442       gtk_widget_set_has_tooltip (GTK_WIDGET (tree_view), FALSE);
16443     }
16444   else
16445     {
16446       if (tree_view->priv->tooltip_column == -1)
16447         {
16448           g_signal_connect (tree_view, "query-tooltip",
16449                             G_CALLBACK (gtk_tree_view_set_tooltip_query_cb), NULL);
16450           gtk_widget_set_has_tooltip (GTK_WIDGET (tree_view), TRUE);
16451         }
16452     }
16453
16454   tree_view->priv->tooltip_column = column;
16455   g_object_notify (G_OBJECT (tree_view), "tooltip-column");
16456 }
16457
16458 /**
16459  * gtk_tree_view_get_tooltip_column:
16460  * @tree_view: a #GtkTreeView
16461  *
16462  * Returns the column of @tree_view's model which is being used for
16463  * displaying tooltips on @tree_view's rows.
16464  *
16465  * Return value: the index of the tooltip column that is currently being
16466  * used, or -1 if this is disabled.
16467  *
16468  * Since: 2.12
16469  */
16470 gint
16471 gtk_tree_view_get_tooltip_column (GtkTreeView *tree_view)
16472 {
16473   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), 0);
16474
16475   return tree_view->priv->tooltip_column;
16476 }