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, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20
  21 #include "config.h"
  22
  23 #include <math.h>
  24 #include <string.h>
  25
  26 #include "gtktreeview.h"
  27 #include "gtkrbtree.h"
  28 #include "gtktreednd.h"
  29 #include "gtktreeprivate.h"
  30 #include "gtkcellrenderer.h"
  31 #include "gtkmarshalers.h"
  32 #include "gtkbuildable.h"
  33 #include "gtkbutton.h"
  34 #include "gtklabel.h"
  35 #include "gtkbox.h"
  36 #include "gtkarrow.h"
  37 #include "gtkintl.h"
  38 #include "gtkbindings.h"
  39 #include "gtkcontainer.h"
  40 #include "gtkentry.h"
  41 #include "gtkframe.h"
  42 #include "gtkmain.h"
  43 #include "gtktreemodelsort.h"
  44 #include "gtktooltip.h"
  45 #include "gtkscrollable.h"
  46 #include "gtkcelllayout.h"
  47 #include "gtkprivate.h"
  48 #include "gtkwidgetprivate.h"
  49 #include "gtkentryprivate.h"
  50 #include "gtkstylecontextprivate.h"
  51 #include "gtktypebuiltins.h"
  52 #include "gtkmain.h"
  53 #include "a11y/gtktreeviewaccessible.h"
  54
  55
  56 /**
  57  * SECTION:gtktreeview
  58  * @Short_description: A widget for displaying both trees and lists
  59  * @Title: GtkTreeView
  60  * @See_also: #GtkTreeViewColumn, #GtkTreeSelection, #GtkTreeDnd, #GtkTreeMode,
  61  *   #GtkTreeSortable, #GtkTreeModelSort, #GtkListStore, #GtkTreeStore,
  62  *   #GtkCellRenderer, #GtkCellEditable, #GtkCellRendererPixbuf,
  63  *   #GtkCellRendererText, #GtkCellRendererToggle
  64  *
  65  * Widget that displays any object that implements the #GtkTreeModel interface.
  66  *
  67  * Please refer to the <link linkend="TreeWidget">tree widget conceptual
  68  * overview</link> for an overview of all the objects and data types related
  69  * to the tree widget and how they work together.
  70  *
  71  * Several different coordinate systems are exposed in the GtkTreeView API.
  72  * These are:
  73  *
  74  * <inlinegraphic fileref="tree-view-coordinates.png" format="PNG"></inlinegraphic>
  75  * <variablelist><title>Coordinate systems in GtkTreeView API</title>
  76  * <varlistentry><term>Widget coordinates</term>
  77  * <listitem>
  78  * <para>
  79  * Coordinates relative to the widget (usually <literal>widget->window</literal>).
  80  * </para>
  81  * </listitem>
  82  * </varlistentry>
  83  * <varlistentry><term>Bin window coordinates</term>
  84  * <listitem>
  85  * <para>
  86  * Coordinates relative to the window that GtkTreeView renders to.
  87  * </para>
  88  * </listitem>
  89  * </varlistentry>
  90  * <varlistentry><term>Tree coordinates</term>
  91  * <listitem>
  92  * <para>
  93  * Coordinates relative to the entire scrollable area of GtkTreeView. These
  94  * coordinates start at (0, 0) for row 0 of the tree.
  95  * </para>
  96  * </listitem>
  97  * </varlistentry>
  98  * </variablelist>
  99  *
 100  * Several functions are available for converting between the different
 101  * coordinate systems.  The most common translations are between widget and bin
 102  * window coordinates and between bin window and tree coordinates. For the
 103  * former you can use gtk_tree_view_convert_widget_to_bin_window_coords()
 104  * (and vice versa), for the latter gtk_tree_view_convert_bin_window_to_tree_coords()
 105  * (and vice versa).
 106  *
 107  * <refsect2 id="GtkTreeView-BUILDER-UI">
 108  * <title>GtkTreeView as GtkBuildable</title>
 109  * The GtkTreeView implementation of the GtkBuildable interface accepts
 110  * #GtkTreeViewColumn objects as &lt;child&gt; elements and exposes the
 111  * internal #GtkTreeSelection in UI definitions.
 112  * <example>
 113  * <title>A UI definition fragment with GtkTreeView</title>
 114  * <programlisting><![CDATA[
 115  * <object class="GtkTreeView" id="treeview">
 116  *   <property name="model">liststore1</property>
 117  *   <child>
 118  *     <object class="GtkTreeViewColumn" id="test-column">
 119  *       <property name="title">Test</property>
 120  *       <child>
 121  *         <object class="GtkCellRendererText" id="test-renderer"/>
 122  *         <attributes>
 123  *           <attribute name="text">1</attribute>
 124  *         </attributes>
 125  *       </child>
 126  *     </object>
 127  *   </child>
 128  *   <child internal-child="selection">
 129  *     <object class="GtkTreeSelection" id="selection">
 130  *       <signal name="changed" handler="on_treeview_selection_changed"/>
 131  *     </object>
 132  *   </child>
 133  * </object>
 134  * ]]></programlisting>
 135  * </example>
 136  * </refsect2>
 137  */
 138
 139 enum
 140 {
 141   DRAG_COLUMN_WINDOW_STATE_UNSET = 0,
 142   DRAG_COLUMN_WINDOW_STATE_ORIGINAL = 1,
 143   DRAG_COLUMN_WINDOW_STATE_ARROW = 2,
 144   DRAG_COLUMN_WINDOW_STATE_ARROW_LEFT = 3,
 145   DRAG_COLUMN_WINDOW_STATE_ARROW_RIGHT = 4
 146 };
 147
 148 enum
 149 {
 150   RUBBER_BAND_OFF = 0,
 151   RUBBER_BAND_MAYBE_START = 1,
 152   RUBBER_BAND_ACTIVE = 2
 153 };
 154
 155  /* This lovely little value is used to determine how far away from the title bar
 156   * you can move the mouse and still have a column drag work.
 157   */
 158 #define TREE_VIEW_COLUMN_DRAG_DEAD_MULTIPLIER(tree_view) (10*gtk_tree_view_get_effective_header_height(tree_view))
 159
 160 #ifdef __GNUC__
 161
 162 #define TREE_VIEW_INTERNAL_ASSERT(expr, ret)     G_STMT_START{          \
 163      if (!(expr))                                                       \
 164        {                                                                \
 165          g_log (G_LOG_DOMAIN,                                           \
 166                 G_LOG_LEVEL_CRITICAL,                                   \
 167                 "%s (%s): assertion `%s' failed.\n"                     \
 168                 "There is a disparity between the internal view of the GtkTreeView,\n"    \
 169                 "and the GtkTreeModel.  This generally means that the model has changed\n"\
 170                 "without letting the view know.  Any display from now on is likely to\n"  \
 171                 "be incorrect.\n",                                                        \
 172                 G_STRLOC,                                               \
 173                 G_STRFUNC,                                              \
 174                 #expr);                                                 \
 175          return ret;                                                    \
 176        };                               }G_STMT_END
 177
 178 #define TREE_VIEW_INTERNAL_ASSERT_VOID(expr)     G_STMT_START{          \
 179      if (!(expr))                                                       \
 180        {                                                                \
 181          g_log (G_LOG_DOMAIN,                                           \
 182                 G_LOG_LEVEL_CRITICAL,                                   \
 183                 "%s (%s): assertion `%s' failed.\n"                     \
 184                 "There is a disparity between the internal view of the GtkTreeView,\n"    \
 185                 "and the GtkTreeModel.  This generally means that the model has changed\n"\
 186                 "without letting the view know.  Any display from now on is likely to\n"  \
 187                 "be incorrect.\n",                                                        \
 188                 G_STRLOC,                                               \
 189                 G_STRFUNC,                                              \
 190                 #expr);                                                 \
 191          return;                                                        \
 192        };                               }G_STMT_END
 193
 194 #else
 195
 196 #define TREE_VIEW_INTERNAL_ASSERT(expr, ret)     G_STMT_START{          \
 197      if (!(expr))                                                       \
 198        {                                                                \
 199          g_log (G_LOG_DOMAIN,                                           \
 200                 G_LOG_LEVEL_CRITICAL,                                   \
 201                 "file %s: line %d: assertion `%s' failed.\n"       \
 202                 "There is a disparity between the internal view of the GtkTreeView,\n"    \
 203                 "and the GtkTreeModel.  This generally means that the model has changed\n"\
 204                 "without letting the view know.  Any display from now on is likely to\n"  \
 205                 "be incorrect.\n",                                                        \
 206                 __FILE__,                                               \
 207                 __LINE__,                                               \
 208                 #expr);                                                 \
 209          return ret;                                                    \
 210        };                               }G_STMT_END
 211
 212 #define TREE_VIEW_INTERNAL_ASSERT_VOID(expr)     G_STMT_START{          \
 213      if (!(expr))                                                       \
 214        {                                                                \
 215          g_log (G_LOG_DOMAIN,                                           \
 216                 G_LOG_LEVEL_CRITICAL,                                   \
 217                 "file %s: line %d: assertion '%s' failed.\n"            \
 218                 "There is a disparity between the internal view of the GtkTreeView,\n"    \
 219                 "and the GtkTreeModel.  This generally means that the model has changed\n"\
 220                 "without letting the view know.  Any display from now on is likely to\n"  \
 221                 "be incorrect.\n",                                                        \
 222                 __FILE__,                                               \
 223                 __LINE__,                                               \
 224                 #expr);                                                 \
 225          return;                                                        \
 226        };                               }G_STMT_END
 227 #endif
 228
 229 #define GTK_TREE_VIEW_PRIORITY_VALIDATE (GDK_PRIORITY_REDRAW + 5)
 230 #define GTK_TREE_VIEW_PRIORITY_SCROLL_SYNC (GTK_TREE_VIEW_PRIORITY_VALIDATE + 2)
 231 #define GTK_TREE_VIEW_TIME_MS_PER_IDLE 30
 232 #define SCROLL_EDGE_SIZE 15
 233 #define EXPANDER_EXTRA_PADDING 4
 234 #define GTK_TREE_VIEW_SEARCH_DIALOG_TIMEOUT 5000
 235 #define AUTO_EXPAND_TIMEOUT 500
 236
 237 /* Translate from bin_window coordinates to rbtree (tree coordinates) and
 238  * vice versa.
 239  */
 240 #define TREE_WINDOW_Y_TO_RBTREE_Y(tree_view,y) ((y) + tree_view->priv->dy)
 241 #define RBTREE_Y_TO_TREE_WINDOW_Y(tree_view,y) ((y) - tree_view->priv->dy)
 242
 243 typedef struct _GtkTreeViewColumnReorder GtkTreeViewColumnReorder;
 244 struct _GtkTreeViewColumnReorder
 245 {
 246   gint left_align;
 247   gint right_align;
 248   GtkTreeViewColumn *left_column;
 249   GtkTreeViewColumn *right_column;
 250 };
 251
 252 typedef struct _GtkTreeViewChild GtkTreeViewChild;
 253 struct _GtkTreeViewChild
 254 {
 255   GtkWidget *widget;
 256   gint x;
 257   gint y;
 258   gint width;
 259   gint height;
 260 };
 261
 262
 263 typedef struct _TreeViewDragInfo TreeViewDragInfo;
 264 struct _TreeViewDragInfo
 265 {
 266   GdkModifierType start_button_mask;
 267   GtkTargetList *_unused_source_target_list;
 268   GdkDragAction source_actions;
 269
 270   GtkTargetList *_unused_dest_target_list;
 271
 272   guint source_set : 1;
 273   guint dest_set : 1;
 274 };
 275
 276
 277 struct _GtkTreeViewPrivate
 278 {
 279   GtkTreeModel *model;
 280
 281   /* tree information */
 282   GtkRBTree *tree;
 283
 284   /* Container info */
 285   GList *children;
 286   gint width;
 287   gint height;
 288
 289   /* Adjustments */
 290   GtkAdjustment *hadjustment;
 291   GtkAdjustment *vadjustment;
 292   gint           min_display_width;
 293   gint           min_display_height;
 294
 295   /* Sub windows */
 296   GdkWindow *bin_window;
 297   GdkWindow *header_window;
 298
 299   /* Scroll position state keeping */
 300   GtkTreeRowReference *top_row;
 301   gint top_row_dy;
 302   /* dy == y pos of top_row + top_row_dy */
 303   /* we cache it for simplicity of the code */
 304   gint dy;
 305
 306   guint presize_handler_timer;
 307   guint validate_rows_timer;
 308   guint scroll_sync_timer;
 309
 310   /* Indentation and expander layout */
 311   gint expander_size;
 312   GtkTreeViewColumn *expander_column;
 313
 314   gint level_indentation;
 315
 316   /* Key navigation (focus), selection */
 317   gint cursor_offset;
 318
 319   GtkTreeRowReference *anchor;
 320   GtkTreeRowReference *cursor;
 321
 322   GtkTreeViewColumn *focus_column;
 323
 324   /* Current pressed node, previously pressed, prelight */
 325   GtkRBNode *button_pressed_node;
 326   GtkRBTree *button_pressed_tree;
 327
 328   gint pressed_button;
 329   gint press_start_x;
 330   gint press_start_y;
 331
 332   gint event_last_x;
 333   gint event_last_y;
 334
 335   guint last_button_time;
 336   gint last_button_x;
 337   gint last_button_y;
 338
 339   GtkRBNode *prelight_node;
 340   GtkRBTree *prelight_tree;
 341
 342   /* Cell Editing */
 343   GtkTreeViewColumn *edited_column;
 344
 345   /* The node that's currently being collapsed or expanded */
 346   GtkRBNode *expanded_collapsed_node;
 347   GtkRBTree *expanded_collapsed_tree;
 348   guint expand_collapse_timeout;
 349
 350   /* Auto expand/collapse timeout in hover mode */
 351   guint auto_expand_timeout;
 352
 353   /* Selection information */
 354   GtkTreeSelection *selection;
 355
 356   /* Header information */
 357   gint n_columns;
 358   GList *columns;
 359   gint header_height;
 360
 361   GtkTreeViewColumnDropFunc column_drop_func;
 362   gpointer column_drop_func_data;
 363   GDestroyNotify column_drop_func_data_destroy;
 364   GList *column_drag_info;
 365   GtkTreeViewColumnReorder *cur_reorder;
 366
 367   gint prev_width_before_expander;
 368
 369   /* Interactive Header reordering */
 370   GdkWindow *drag_window;
 371   GdkWindow *drag_highlight_window;
 372   GtkTreeViewColumn *drag_column;
 373   gint drag_column_x;
 374
 375   /* Interactive Header Resizing */
 376   gint drag_pos;
 377   gint x_drag;
 378
 379   /* Non-interactive Header Resizing, expand flag support */
 380   gint prev_width;
 381
 382   gint last_extra_space;
 383   gint last_extra_space_per_column;
 384   gint last_number_of_expand_columns;
 385
 386   /* ATK Hack */
 387   GtkTreeDestroyCountFunc destroy_count_func;
 388   gpointer destroy_count_data;
 389   GDestroyNotify destroy_count_destroy;
 390
 391   /* Scroll timeout (e.g. during dnd, rubber banding) */
 392   guint scroll_timeout;
 393
 394   /* Row drag-and-drop */
 395   GtkTreeRowReference *drag_dest_row;
 396   GtkTreeViewDropPosition drag_dest_pos;
 397   guint open_dest_timeout;
 398
 399   /* Rubber banding */
 400   gint rubber_band_status;
 401   gint rubber_band_x;
 402   gint rubber_band_y;
 403   gint rubber_band_extend;
 404   gint rubber_band_modify;
 405
 406   GtkRBNode *rubber_band_start_node;
 407   GtkRBTree *rubber_band_start_tree;
 408
 409   GtkRBNode *rubber_band_end_node;
 410   GtkRBTree *rubber_band_end_tree;
 411
 412   /* fixed height */
 413   gint fixed_height;
 414
 415   /* Scroll-to functionality when unrealized */
 416   GtkTreeRowReference *scroll_to_path;
 417   GtkTreeViewColumn *scroll_to_column;
 418   gfloat scroll_to_row_align;
 419   gfloat scroll_to_col_align;
 420
 421   /* Interactive search */
 422   gint selected_iter;
 423   gint search_column;
 424   GtkTreeViewSearchPositionFunc search_position_func;
 425   GtkTreeViewSearchEqualFunc search_equal_func;
 426   gpointer search_user_data;
 427   GDestroyNotify search_destroy;
 428   gpointer search_position_user_data;
 429   GDestroyNotify search_position_destroy;
 430   GtkWidget *search_window;
 431   GtkWidget *search_entry;
 432   gulong search_entry_changed_id;
 433   guint typeselect_flush_timeout;
 434
 435   /* Grid and tree lines */
 436   GtkTreeViewGridLines grid_lines;
 437   double grid_line_dashes[2];
 438   int grid_line_width;
 439
 440   gboolean tree_lines_enabled;
 441   double tree_line_dashes[2];
 442   int tree_line_width;
 443
 444   /* Row separators */
 445   GtkTreeViewRowSeparatorFunc row_separator_func;
 446   gpointer row_separator_data;
 447   GDestroyNotify row_separator_destroy;
 448
 449   /* Tooltip support */
 450   gint tooltip_column;
 451
 452   /* Here comes the bitfield */
 453   guint scroll_to_use_align : 1;
 454
 455   guint fixed_height_mode : 1;
 456   guint fixed_height_check : 1;
 457
 458   guint reorderable : 1;
 459   guint header_has_focus : 1;
 460   guint drag_column_window_state : 3;
 461   /* hint to display rows in alternating colors */
 462   guint has_rules : 1;
 463   guint mark_rows_col_dirty : 1;
 464
 465   /* for DnD */
 466   guint empty_view_drop : 1;
 467
 468   guint modify_selection_pressed : 1;
 469   guint extend_selection_pressed : 1;
 470
 471   guint init_hadjust_value : 1;
 472
 473   guint in_top_row_to_dy : 1;
 474
 475   /* interactive search */
 476   guint enable_search : 1;
 477   guint disable_popdown : 1;
 478   guint search_custom_entry_set : 1;
 479
 480   guint hover_selection : 1;
 481   guint hover_expand : 1;
 482   guint imcontext_changed : 1;
 483
 484   guint rubber_banding_enable : 1;
 485
 486   guint in_grab : 1;
 487
 488   guint post_validation_flag : 1;
 489
 490   /* Whether our key press handler is to avoid sending an unhandled binding to the search entry */
 491   guint search_entry_avoid_unhandled_binding : 1;
 492
 493   /* GtkScrollablePolicy needs to be checked when
 494    * driving the scrollable adjustment values */
 495   guint hscroll_policy : 1;
 496   guint vscroll_policy : 1;
 497
 498   /* GtkTreeView flags */
 499   guint is_list : 1;
 500   guint show_expanders : 1;
 501   guint in_column_resize : 1;
 502   guint arrow_prelit : 1;
 503   guint headers_visible : 1;
 504   guint draw_keyfocus : 1;
 505   guint model_setup : 1;
 506   guint in_column_drag : 1;
 507 };
 508
 509
 510 /* Signals */
 511 enum
 512 {
 513   ROW_ACTIVATED,
 514   TEST_EXPAND_ROW,
 515   TEST_COLLAPSE_ROW,
 516   ROW_EXPANDED,
 517   ROW_COLLAPSED,
 518   COLUMNS_CHANGED,
 519   CURSOR_CHANGED,
 520   MOVE_CURSOR,
 521   SELECT_ALL,
 522   UNSELECT_ALL,
 523   SELECT_CURSOR_ROW,
 524   TOGGLE_CURSOR_ROW,
 525   EXPAND_COLLAPSE_CURSOR_ROW,
 526   SELECT_CURSOR_PARENT,
 527   START_INTERACTIVE_SEARCH,
 528   LAST_SIGNAL
 529 };
 530
 531 /* Properties */
 532 enum {
 533   PROP_0,
 534   PROP_MODEL,
 535   PROP_HADJUSTMENT,
 536   PROP_VADJUSTMENT,
 537   PROP_HSCROLL_POLICY,
 538   PROP_VSCROLL_POLICY,
 539   PROP_HEADERS_VISIBLE,
 540   PROP_HEADERS_CLICKABLE,
 541   PROP_EXPANDER_COLUMN,
 542   PROP_REORDERABLE,
 543   PROP_RULES_HINT,
 544   PROP_ENABLE_SEARCH,
 545   PROP_SEARCH_COLUMN,
 546   PROP_FIXED_HEIGHT_MODE,
 547   PROP_HOVER_SELECTION,
 548   PROP_HOVER_EXPAND,
 549   PROP_SHOW_EXPANDERS,
 550   PROP_LEVEL_INDENTATION,
 551   PROP_RUBBER_BANDING,
 552   PROP_ENABLE_GRID_LINES,
 553   PROP_ENABLE_TREE_LINES,
 554   PROP_TOOLTIP_COLUMN
 555 };
 556
 557 /* object signals */
 558 static void     gtk_tree_view_finalize             (GObject          *object);
 559 static void     gtk_tree_view_set_property         (GObject         *object,
 560                                                     guint            prop_id,
 561                                                     const GValue    *value,
 562                                                     GParamSpec      *pspec);
 563 static void     gtk_tree_view_get_property         (GObject         *object,
 564                                                     guint            prop_id,
 565                                                     GValue          *value,
 566                                                     GParamSpec      *pspec);
 567
 568 /* gtkwidget signals */
 569 static void     gtk_tree_view_destroy              (GtkWidget        *widget);
 570 static void     gtk_tree_view_realize              (GtkWidget        *widget);
 571 static void     gtk_tree_view_unrealize            (GtkWidget        *widget);
 572 static void     gtk_tree_view_map                  (GtkWidget        *widget);
 573 static void     gtk_tree_view_get_preferred_width  (GtkWidget        *widget,
 574                                                     gint             *minimum,
 575                                                     gint             *natural);
 576 static void     gtk_tree_view_get_preferred_height (GtkWidget        *widget,
 577                                                     gint             *minimum,
 578                                                     gint             *natural);
 579 static void     gtk_tree_view_size_request         (GtkWidget        *widget,
 580                                                     GtkRequisition   *requisition,
 581                                                     gboolean          may_validate);
 582 static void     gtk_tree_view_size_allocate        (GtkWidget        *widget,
 583                                                     GtkAllocation    *allocation);
 584 static gboolean gtk_tree_view_draw                 (GtkWidget        *widget,
 585                                                     cairo_t          *cr);
 586 static gboolean gtk_tree_view_key_press            (GtkWidget        *widget,
 587                                                     GdkEventKey      *event);
 588 static gboolean gtk_tree_view_key_release          (GtkWidget        *widget,
 589                                                     GdkEventKey      *event);
 590 static gboolean gtk_tree_view_motion               (GtkWidget        *widget,
 591                                                     GdkEventMotion   *event);
 592 static gboolean gtk_tree_view_enter_notify         (GtkWidget        *widget,
 593                                                     GdkEventCrossing *event);
 594 static gboolean gtk_tree_view_leave_notify         (GtkWidget        *widget,
 595                                                     GdkEventCrossing *event);
 596 static gboolean gtk_tree_view_button_press         (GtkWidget        *widget,
 597                                                     GdkEventButton   *event);
 598 static gboolean gtk_tree_view_button_release       (GtkWidget        *widget,
 599                                                     GdkEventButton   *event);
 600 static gboolean gtk_tree_view_grab_broken          (GtkWidget          *widget,
 601                                                     GdkEventGrabBroken *event);
 602 #if 0
 603 static gboolean gtk_tree_view_configure            (GtkWidget         *widget,
 604                                                     GdkEventConfigure *event);
 605 #endif
 606
 607 static GtkWidgetPath * gtk_tree_view_get_path_for_child (GtkContainer *container,
 608                                                          GtkWidget    *child);
 609
 610 static void     gtk_tree_view_set_focus_child      (GtkContainer     *container,
 611                                                     GtkWidget        *child);
 612 static gint     gtk_tree_view_focus_out            (GtkWidget        *widget,
 613                                                     GdkEventFocus    *event);
 614 static gint     gtk_tree_view_focus                (GtkWidget        *widget,
 615                                                     GtkDirectionType  direction);
 616 static void     gtk_tree_view_grab_focus           (GtkWidget        *widget);
 617 static void     gtk_tree_view_style_updated        (GtkWidget        *widget);
 618 static void     gtk_tree_view_grab_notify          (GtkWidget        *widget,
 619                                                     gboolean          was_grabbed);
 620 static void     gtk_tree_view_state_flags_changed  (GtkWidget        *widget,
 621                                                     GtkStateFlags     previous_state);
 622
 623 /* container signals */
 624 static void     gtk_tree_view_remove               (GtkContainer     *container,
 625                                                     GtkWidget        *widget);
 626 static void     gtk_tree_view_forall               (GtkContainer     *container,
 627                                                     gboolean          include_internals,
 628                                                     GtkCallback       callback,
 629                                                     gpointer          callback_data);
 630
 631 /* Source side drag signals */
 632 static void gtk_tree_view_drag_begin       (GtkWidget        *widget,
 633                                             GdkDragContext   *context);
 634 static void gtk_tree_view_drag_end         (GtkWidget        *widget,
 635                                             GdkDragContext   *context);
 636 static void gtk_tree_view_drag_data_get    (GtkWidget        *widget,
 637                                             GdkDragContext   *context,
 638                                             GtkSelectionData *selection_data,
 639                                             guint             info,
 640                                             guint             time);
 641 static void gtk_tree_view_drag_data_delete (GtkWidget        *widget,
 642                                             GdkDragContext   *context);
 643
 644 /* Target side drag signals */
 645 static void     gtk_tree_view_drag_leave         (GtkWidget        *widget,
 646                                                   GdkDragContext   *context,
 647                                                   guint             time);
 648 static gboolean gtk_tree_view_drag_motion        (GtkWidget        *widget,
 649                                                   GdkDragContext   *context,
 650                                                   gint              x,
 651                                                   gint              y,
 652                                                   guint             time);
 653 static gboolean gtk_tree_view_drag_drop          (GtkWidget        *widget,
 654                                                   GdkDragContext   *context,
 655                                                   gint              x,
 656                                                   gint              y,
 657                                                   guint             time);
 658 static void     gtk_tree_view_drag_data_received (GtkWidget        *widget,
 659                                                   GdkDragContext   *context,
 660                                                   gint              x,
 661                                                   gint              y,
 662                                                   GtkSelectionData *selection_data,
 663                                                   guint             info,
 664                                                   guint             time);
 665
 666 /* tree_model signals */
 667 static gboolean gtk_tree_view_real_move_cursor            (GtkTreeView     *tree_view,
 668                                                            GtkMovementStep  step,
 669                                                            gint             count);
 670 static gboolean gtk_tree_view_real_select_all             (GtkTreeView     *tree_view);
 671 static gboolean gtk_tree_view_real_unselect_all           (GtkTreeView     *tree_view);
 672 static gboolean gtk_tree_view_real_select_cursor_row      (GtkTreeView     *tree_view,
 673                                                            gboolean         start_editing);
 674 static gboolean gtk_tree_view_real_toggle_cursor_row      (GtkTreeView     *tree_view);
 675 static gboolean gtk_tree_view_real_expand_collapse_cursor_row (GtkTreeView     *tree_view,
 676                                                                gboolean         logical,
 677                                                                gboolean         expand,
 678                                                                gboolean         open_all);
 679 static gboolean gtk_tree_view_real_select_cursor_parent   (GtkTreeView     *tree_view);
 680 static void gtk_tree_view_row_changed                     (GtkTreeModel    *model,
 681                                                            GtkTreePath     *path,
 682                                                            GtkTreeIter     *iter,
 683                                                            gpointer         data);
 684 static void gtk_tree_view_row_inserted                    (GtkTreeModel    *model,
 685                                                            GtkTreePath     *path,
 686                                                            GtkTreeIter     *iter,
 687                                                            gpointer         data);
 688 static void gtk_tree_view_row_has_child_toggled           (GtkTreeModel    *model,
 689                                                            GtkTreePath     *path,
 690                                                            GtkTreeIter     *iter,
 691                                                            gpointer         data);
 692 static void gtk_tree_view_row_deleted                     (GtkTreeModel    *model,
 693                                                            GtkTreePath     *path,
 694                                                            gpointer         data);
 695 static void gtk_tree_view_rows_reordered                  (GtkTreeModel    *model,
 696                                                            GtkTreePath     *parent,
 697                                                            GtkTreeIter     *iter,
 698                                                            gint            *new_order,
 699                                                            gpointer         data);
 700
 701 /* Incremental reflow */
 702 static gboolean validate_row             (GtkTreeView *tree_view,
 703                                           GtkRBTree   *tree,
 704                                           GtkRBNode   *node,
 705                                           GtkTreeIter *iter,
 706                                           GtkTreePath *path);
 707 static void     validate_visible_area    (GtkTreeView *tree_view);
 708 static gboolean validate_rows_handler    (GtkTreeView *tree_view);
 709 static gboolean do_validate_rows         (GtkTreeView *tree_view,
 710                                           gboolean     size_request);
 711 static gboolean validate_rows            (GtkTreeView *tree_view);
 712 static gboolean presize_handler_callback (gpointer     data);
 713 static void     install_presize_handler  (GtkTreeView *tree_view);
 714 static void     install_scroll_sync_handler (GtkTreeView *tree_view);
 715 static void     gtk_tree_view_set_top_row   (GtkTreeView *tree_view,
 716                                              GtkTreePath *path,
 717                                              gint         offset);
 718 static void     gtk_tree_view_dy_to_top_row (GtkTreeView *tree_view);
 719 static void     gtk_tree_view_top_row_to_dy (GtkTreeView *tree_view);
 720 static void     invalidate_empty_focus      (GtkTreeView *tree_view);
 721
 722 /* Internal functions */
 723 static gboolean gtk_tree_view_is_expander_column             (GtkTreeView        *tree_view,
 724                                                               GtkTreeViewColumn  *column);
 725 static inline gboolean gtk_tree_view_draw_expanders          (GtkTreeView        *tree_view);
 726 static void     gtk_tree_view_add_move_binding               (GtkBindingSet      *binding_set,
 727                                                               guint               keyval,
 728                                                               guint               modmask,
 729                                                               gboolean            add_shifted_binding,
 730                                                               GtkMovementStep     step,
 731                                                               gint                count);
 732 static gint     gtk_tree_view_unref_and_check_selection_tree (GtkTreeView        *tree_view,
 733                                                               GtkRBTree          *tree);
 734 static void     gtk_tree_view_queue_draw_path                (GtkTreeView        *tree_view,
 735                                                               GtkTreePath        *path,
 736                                                               const GdkRectangle *clip_rect);
 737 static void     gtk_tree_view_queue_draw_arrow               (GtkTreeView        *tree_view,
 738                                                               GtkRBTree          *tree,
 739                                                               GtkRBNode          *node);
 740 static void     gtk_tree_view_draw_arrow                     (GtkTreeView        *tree_view,
 741                                                               cairo_t            *cr,
 742                                                               GtkRBTree          *tree,
 743                                                               GtkRBNode          *node);
 744 static void     gtk_tree_view_get_arrow_xrange               (GtkTreeView        *tree_view,
 745                                                               GtkRBTree          *tree,
 746                                                               gint               *x1,
 747                                                               gint               *x2);
 748 static gint     gtk_tree_view_new_column_width               (GtkTreeView        *tree_view,
 749                                                               gint                i,
 750                                                               gint               *x);
 751 static void     gtk_tree_view_adjustment_changed             (GtkAdjustment      *adjustment,
 752                                                               GtkTreeView        *tree_view);
 753 static void     gtk_tree_view_build_tree                     (GtkTreeView        *tree_view,
 754                                                               GtkRBTree          *tree,
 755                                                               GtkTreeIter        *iter,
 756                                                               gint                depth,
 757                                                               gboolean            recurse);
 758 static void     gtk_tree_view_clamp_node_visible             (GtkTreeView        *tree_view,
 759                                                               GtkRBTree          *tree,
 760                                                               GtkRBNode          *node);
 761 static void     gtk_tree_view_clamp_column_visible           (GtkTreeView        *tree_view,
 762                                                               GtkTreeViewColumn  *column,
 763                                                               gboolean            focus_to_cell);
 764 static gboolean gtk_tree_view_maybe_begin_dragging_row       (GtkTreeView        *tree_view,
 765                                                               GdkEventMotion     *event);
 766 static void     gtk_tree_view_focus_to_cursor                (GtkTreeView        *tree_view);
 767 static void     gtk_tree_view_move_cursor_up_down            (GtkTreeView        *tree_view,
 768                                                               gint                count);
 769 static void     gtk_tree_view_move_cursor_page_up_down       (GtkTreeView        *tree_view,
 770                                                               gint                count);
 771 static void     gtk_tree_view_move_cursor_left_right         (GtkTreeView        *tree_view,
 772                                                               gint                count);
 773 static void     gtk_tree_view_move_cursor_start_end          (GtkTreeView        *tree_view,
 774                                                               gint                count);
 775 static gboolean gtk_tree_view_real_collapse_row              (GtkTreeView        *tree_view,
 776                                                               GtkTreePath        *path,
 777                                                               GtkRBTree          *tree,
 778                                                               GtkRBNode          *node,
 779                                                               gboolean            animate);
 780 static gboolean gtk_tree_view_real_expand_row                (GtkTreeView        *tree_view,
 781                                                               GtkTreePath        *path,
 782                                                               GtkRBTree          *tree,
 783                                                               GtkRBNode          *node,
 784                                                               gboolean            open_all,
 785                                                               gboolean            animate);
 786 static void     gtk_tree_view_real_set_cursor                (GtkTreeView        *tree_view,
 787                                                               GtkTreePath        *path,
 788                                                               gboolean            clear_and_select,
 789                                                               gboolean            clamp_node);
 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   /* Style properties */
1181 #define _TREE_VIEW_EXPANDER_SIZE 14
1182 #define _TREE_VIEW_VERTICAL_SEPARATOR 2
1183 #define _TREE_VIEW_HORIZONTAL_SEPARATOR 2
1184
1185   gtk_widget_class_install_style_property (widget_class,
1186                                            g_param_spec_int ("expander-size",
1187                                                              P_("Expander Size"),
1188                                                              P_("Size of the expander arrow"),
1189                                                              0,
1190                                                              G_MAXINT,
1191                                                              _TREE_VIEW_EXPANDER_SIZE,
1192                                                              GTK_PARAM_READABLE));
1193
1194   gtk_widget_class_install_style_property (widget_class,
1195                                            g_param_spec_int ("vertical-separator",
1196                                                              P_("Vertical Separator Width"),
1197                                                              P_("Vertical space between cells.  Must be an even number"),
1198                                                              0,
1199                                                              G_MAXINT,
1200                                                              _TREE_VIEW_VERTICAL_SEPARATOR,
1201                                                              GTK_PARAM_READABLE));
1202
1203   gtk_widget_class_install_style_property (widget_class,
1204                                            g_param_spec_int ("horizontal-separator",
1205                                                              P_("Horizontal Separator Width"),
1206                                                              P_("Horizontal space between cells.  Must be an even number"),
1207                                                              0,
1208                                                              G_MAXINT,
1209                                                              _TREE_VIEW_HORIZONTAL_SEPARATOR,
1210                                                              GTK_PARAM_READABLE));
1211
1212   gtk_widget_class_install_style_property (widget_class,
1213                                            g_param_spec_boolean ("allow-rules",
1214                                                                  P_("Allow Rules"),
1215                                                                  P_("Allow drawing of alternating color rows"),
1216                                                                  TRUE,
1217                                                                  GTK_PARAM_READABLE));
1218
1219   gtk_widget_class_install_style_property (widget_class,
1220                                            g_param_spec_boolean ("indent-expanders",
1221                                                                  P_("Indent Expanders"),
1222                                                                  P_("Make the expanders indented"),
1223                                                                  TRUE,
1224                                                                  GTK_PARAM_READABLE));
1225
1226   gtk_widget_class_install_style_property (widget_class,
1227                                            g_param_spec_boxed ("even-row-color",
1228                                                                P_("Even Row Color"),
1229                                                                P_("Color to use for even rows"),
1230                                                                GDK_TYPE_COLOR,
1231                                                                GTK_PARAM_READABLE));
1232
1233   gtk_widget_class_install_style_property (widget_class,
1234                                            g_param_spec_boxed ("odd-row-color",
1235                                                                P_("Odd Row Color"),
1236                                                                P_("Color to use for odd rows"),
1237                                                                GDK_TYPE_COLOR,
1238                                                                GTK_PARAM_READABLE));
1239
1240   gtk_widget_class_install_style_property (widget_class,
1241                                            g_param_spec_int ("grid-line-width",
1242                                                              P_("Grid line width"),
1243                                                              P_("Width, in pixels, of the tree view grid lines"),
1244                                                              0, G_MAXINT, 1,
1245                                                              GTK_PARAM_READABLE));
1246
1247   gtk_widget_class_install_style_property (widget_class,
1248                                            g_param_spec_int ("tree-line-width",
1249                                                              P_("Tree line width"),
1250                                                              P_("Width, in pixels, of the tree view lines"),
1251                                                              0, G_MAXINT, 1,
1252                                                              GTK_PARAM_READABLE));
1253
1254   gtk_widget_class_install_style_property (widget_class,
1255                                            g_param_spec_string ("grid-line-pattern",
1256                                                                 P_("Grid line pattern"),
1257                                                                 P_("Dash pattern used to draw the tree view grid lines"),
1258                                                                 "\1\1",
1259                                                                 GTK_PARAM_READABLE));
1260
1261   gtk_widget_class_install_style_property (widget_class,
1262                                            g_param_spec_string ("tree-line-pattern",
1263                                                                 P_("Tree line pattern"),
1264                                                                 P_("Dash pattern used to draw the tree view lines"),
1265                                                                 "\1\1",
1266                                                                 GTK_PARAM_READABLE));
1267
1268   /* Signals */
1269   /**
1270    * GtkTreeView::row-activated:
1271    * @tree_view: the object on which the signal is emitted
1272    * @path: the #GtkTreePath for the activated row
1273    * @column: the #GtkTreeViewColumn in which the activation occurred
1274    *
1275    * The "row-activated" signal is emitted when the method
1276    * gtk_tree_view_row_activated() is called or the user double clicks
1277    * a treeview row. It is also emitted when a non-editable row is
1278    * selected and one of the keys: Space, Shift+Space, Return or
1279    * Enter is pressed.
1280    *
1281    * For selection handling refer to the <link linkend="TreeWidget">tree
1282    * widget conceptual overview</link> as well as #GtkTreeSelection.
1283    */
1284   tree_view_signals[ROW_ACTIVATED] =
1285     g_signal_new (I_("row-activated"),
1286                   G_TYPE_FROM_CLASS (o_class),
1287                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1288                   G_STRUCT_OFFSET (GtkTreeViewClass, row_activated),
1289                   NULL, NULL,
1290                   _gtk_marshal_VOID__BOXED_OBJECT,
1291                   G_TYPE_NONE, 2,
1292                   GTK_TYPE_TREE_PATH,
1293                   GTK_TYPE_TREE_VIEW_COLUMN);
1294
1295   /**
1296    * GtkTreeView::test-expand-row:
1297    * @tree_view: the object on which the signal is emitted
1298    * @iter: the tree iter of the row to expand
1299    * @path: a tree path that points to the row
1300    *
1301    * The given row is about to be expanded (show its children nodes). Use this
1302    * signal if you need to control the expandability of individual rows.
1303    *
1304    * Returns: %FALSE to allow expansion, %TRUE to reject
1305    */
1306   tree_view_signals[TEST_EXPAND_ROW] =
1307     g_signal_new (I_("test-expand-row"),
1308                   G_TYPE_FROM_CLASS (o_class),
1309                   G_SIGNAL_RUN_LAST,
1310                   G_STRUCT_OFFSET (GtkTreeViewClass, test_expand_row),
1311                   _gtk_boolean_handled_accumulator, NULL,
1312                   _gtk_marshal_BOOLEAN__BOXED_BOXED,
1313                   G_TYPE_BOOLEAN, 2,
1314                   GTK_TYPE_TREE_ITER,
1315                   GTK_TYPE_TREE_PATH);
1316
1317   /**
1318    * GtkTreeView::test-collapse-row:
1319    * @tree_view: the object on which the signal is emitted
1320    * @iter: the tree iter of the row to collapse
1321    * @path: a tree path that points to the row
1322    *
1323    * The given row is about to be collapsed (hide its children nodes). Use this
1324    * signal if you need to control the collapsibility of individual rows.
1325    *
1326    * Returns: %FALSE to allow collapsing, %TRUE to reject
1327    */
1328   tree_view_signals[TEST_COLLAPSE_ROW] =
1329     g_signal_new (I_("test-collapse-row"),
1330                   G_TYPE_FROM_CLASS (o_class),
1331                   G_SIGNAL_RUN_LAST,
1332                   G_STRUCT_OFFSET (GtkTreeViewClass, test_collapse_row),
1333                   _gtk_boolean_handled_accumulator, NULL,
1334                   _gtk_marshal_BOOLEAN__BOXED_BOXED,
1335                   G_TYPE_BOOLEAN, 2,
1336                   GTK_TYPE_TREE_ITER,
1337                   GTK_TYPE_TREE_PATH);
1338
1339   /**
1340    * GtkTreeView::row-expanded:
1341    * @tree_view: the object on which the signal is emitted
1342    * @iter: the tree iter of the expanded row
1343    * @path: a tree path that points to the row
1344    *
1345    * The given row has been expanded (child nodes are shown).
1346    */
1347   tree_view_signals[ROW_EXPANDED] =
1348     g_signal_new (I_("row-expanded"),
1349                   G_TYPE_FROM_CLASS (o_class),
1350                   G_SIGNAL_RUN_LAST,
1351                   G_STRUCT_OFFSET (GtkTreeViewClass, row_expanded),
1352                   NULL, NULL,
1353                   _gtk_marshal_VOID__BOXED_BOXED,
1354                   G_TYPE_NONE, 2,
1355                   GTK_TYPE_TREE_ITER,
1356                   GTK_TYPE_TREE_PATH);
1357
1358   /**
1359    * GtkTreeView::row-collapsed:
1360    * @tree_view: the object on which the signal is emitted
1361    * @iter: the tree iter of the collapsed row
1362    * @path: a tree path that points to the row
1363    *
1364    * The given row has been collapsed (child nodes are hidden).
1365    */
1366   tree_view_signals[ROW_COLLAPSED] =
1367     g_signal_new (I_("row-collapsed"),
1368                   G_TYPE_FROM_CLASS (o_class),
1369                   G_SIGNAL_RUN_LAST,
1370                   G_STRUCT_OFFSET (GtkTreeViewClass, row_collapsed),
1371                   NULL, NULL,
1372                   _gtk_marshal_VOID__BOXED_BOXED,
1373                   G_TYPE_NONE, 2,
1374                   GTK_TYPE_TREE_ITER,
1375                   GTK_TYPE_TREE_PATH);
1376
1377   /**
1378    * GtkTreeView::columns-changed:
1379    * @tree_view: the object on which the signal is emitted
1380    *
1381    * The number of columns of the treeview has changed.
1382    */
1383   tree_view_signals[COLUMNS_CHANGED] =
1384     g_signal_new (I_("columns-changed"),
1385                   G_TYPE_FROM_CLASS (o_class),
1386                   G_SIGNAL_RUN_LAST,
1387                   G_STRUCT_OFFSET (GtkTreeViewClass, columns_changed),
1388                   NULL, NULL,
1389                   _gtk_marshal_VOID__VOID,
1390                   G_TYPE_NONE, 0);
1391
1392   /**
1393    * GtkTreeView::cursor-changed:
1394    * @tree_view: the object on which the signal is emitted
1395    *
1396    * The position of the cursor (focused cell) has changed.
1397    */
1398   tree_view_signals[CURSOR_CHANGED] =
1399     g_signal_new (I_("cursor-changed"),
1400                   G_TYPE_FROM_CLASS (o_class),
1401                   G_SIGNAL_RUN_LAST,
1402                   G_STRUCT_OFFSET (GtkTreeViewClass, cursor_changed),
1403                   NULL, NULL,
1404                   _gtk_marshal_VOID__VOID,
1405                   G_TYPE_NONE, 0);
1406
1407   tree_view_signals[MOVE_CURSOR] =
1408     g_signal_new (I_("move-cursor"),
1409                   G_TYPE_FROM_CLASS (o_class),
1410                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1411                   G_STRUCT_OFFSET (GtkTreeViewClass, move_cursor),
1412                   NULL, NULL,
1413                   _gtk_marshal_BOOLEAN__ENUM_INT,
1414                   G_TYPE_BOOLEAN, 2,
1415                   GTK_TYPE_MOVEMENT_STEP,
1416                   G_TYPE_INT);
1417
1418   tree_view_signals[SELECT_ALL] =
1419     g_signal_new (I_("select-all"),
1420                   G_TYPE_FROM_CLASS (o_class),
1421                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1422                   G_STRUCT_OFFSET (GtkTreeViewClass, select_all),
1423                   NULL, NULL,
1424                   _gtk_marshal_BOOLEAN__VOID,
1425                   G_TYPE_BOOLEAN, 0);
1426
1427   tree_view_signals[UNSELECT_ALL] =
1428     g_signal_new (I_("unselect-all"),
1429                   G_TYPE_FROM_CLASS (o_class),
1430                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1431                   G_STRUCT_OFFSET (GtkTreeViewClass, unselect_all),
1432                   NULL, NULL,
1433                   _gtk_marshal_BOOLEAN__VOID,
1434                   G_TYPE_BOOLEAN, 0);
1435
1436   tree_view_signals[SELECT_CURSOR_ROW] =
1437     g_signal_new (I_("select-cursor-row"),
1438                   G_TYPE_FROM_CLASS (o_class),
1439                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1440                   G_STRUCT_OFFSET (GtkTreeViewClass, select_cursor_row),
1441                   NULL, NULL,
1442                   _gtk_marshal_BOOLEAN__BOOLEAN,
1443                   G_TYPE_BOOLEAN, 1,
1444                   G_TYPE_BOOLEAN);
1445
1446   tree_view_signals[TOGGLE_CURSOR_ROW] =
1447     g_signal_new (I_("toggle-cursor-row"),
1448                   G_TYPE_FROM_CLASS (o_class),
1449                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1450                   G_STRUCT_OFFSET (GtkTreeViewClass, toggle_cursor_row),
1451                   NULL, NULL,
1452                   _gtk_marshal_BOOLEAN__VOID,
1453                   G_TYPE_BOOLEAN, 0);
1454
1455   tree_view_signals[EXPAND_COLLAPSE_CURSOR_ROW] =
1456     g_signal_new (I_("expand-collapse-cursor-row"),
1457                   G_TYPE_FROM_CLASS (o_class),
1458                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1459                   G_STRUCT_OFFSET (GtkTreeViewClass, expand_collapse_cursor_row),
1460                   NULL, NULL,
1461                   _gtk_marshal_BOOLEAN__BOOLEAN_BOOLEAN_BOOLEAN,
1462                   G_TYPE_BOOLEAN, 3,
1463                   G_TYPE_BOOLEAN,
1464                   G_TYPE_BOOLEAN,
1465                   G_TYPE_BOOLEAN);
1466
1467   tree_view_signals[SELECT_CURSOR_PARENT] =
1468     g_signal_new (I_("select-cursor-parent"),
1469                   G_TYPE_FROM_CLASS (o_class),
1470                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1471                   G_STRUCT_OFFSET (GtkTreeViewClass, select_cursor_parent),
1472                   NULL, NULL,
1473                   _gtk_marshal_BOOLEAN__VOID,
1474                   G_TYPE_BOOLEAN, 0);
1475
1476   tree_view_signals[START_INTERACTIVE_SEARCH] =
1477     g_signal_new (I_("start-interactive-search"),
1478                   G_TYPE_FROM_CLASS (o_class),
1479                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1480                   G_STRUCT_OFFSET (GtkTreeViewClass, start_interactive_search),
1481                   NULL, NULL,
1482                   _gtk_marshal_BOOLEAN__VOID,
1483                   G_TYPE_BOOLEAN, 0);
1484
1485   /* Key bindings */
1486   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_Up, 0, TRUE,
1487                                   GTK_MOVEMENT_DISPLAY_LINES, -1);
1488   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_KP_Up, 0, TRUE,
1489                                   GTK_MOVEMENT_DISPLAY_LINES, -1);
1490
1491   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_Down, 0, TRUE,
1492                                   GTK_MOVEMENT_DISPLAY_LINES, 1);
1493   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_KP_Down, 0, TRUE,
1494                                   GTK_MOVEMENT_DISPLAY_LINES, 1);
1495
1496   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_p, GDK_CONTROL_MASK, FALSE,
1497                                   GTK_MOVEMENT_DISPLAY_LINES, -1);
1498
1499   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_n, GDK_CONTROL_MASK, FALSE,
1500                                   GTK_MOVEMENT_DISPLAY_LINES, 1);
1501
1502   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_Home, 0, TRUE,
1503                                   GTK_MOVEMENT_BUFFER_ENDS, -1);
1504   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_KP_Home, 0, TRUE,
1505                                   GTK_MOVEMENT_BUFFER_ENDS, -1);
1506
1507   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_End, 0, TRUE,
1508                                   GTK_MOVEMENT_BUFFER_ENDS, 1);
1509   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_KP_End, 0, TRUE,
1510                                   GTK_MOVEMENT_BUFFER_ENDS, 1);
1511
1512   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_Page_Up, 0, TRUE,
1513                                   GTK_MOVEMENT_PAGES, -1);
1514   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_KP_Page_Up, 0, TRUE,
1515                                   GTK_MOVEMENT_PAGES, -1);
1516
1517   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_Page_Down, 0, TRUE,
1518                                   GTK_MOVEMENT_PAGES, 1);
1519   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_KP_Page_Down, 0, TRUE,
1520                                   GTK_MOVEMENT_PAGES, 1);
1521
1522
1523   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Right, 0, "move-cursor", 2,
1524                                 G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
1525                                 G_TYPE_INT, 1);
1526
1527   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Left, 0, "move-cursor", 2,
1528                                 G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
1529                                 G_TYPE_INT, -1);
1530
1531   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Right, 0, "move-cursor", 2,
1532                                 G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
1533                                 G_TYPE_INT, 1);
1534
1535   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Left, 0, "move-cursor", 2,
1536                                 G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
1537                                 G_TYPE_INT, -1);
1538
1539   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Right, GDK_CONTROL_MASK,
1540                                 "move-cursor", 2,
1541                                 G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
1542                                 G_TYPE_INT, 1);
1543
1544   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Left, GDK_CONTROL_MASK,
1545                                 "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, GDK_CONTROL_MASK,
1550                                 "move-cursor", 2,
1551                                 G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
1552                                 G_TYPE_INT, 1);
1553
1554   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Left, GDK_CONTROL_MASK,
1555                                 "move-cursor", 2,
1556                                 G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
1557                                 G_TYPE_INT, -1);
1558
1559   gtk_binding_entry_add_signal (binding_set, GDK_KEY_space, GDK_CONTROL_MASK, "toggle-cursor-row", 0);
1560   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Space, GDK_CONTROL_MASK, "toggle-cursor-row", 0);
1561
1562   gtk_binding_entry_add_signal (binding_set, GDK_KEY_a, GDK_CONTROL_MASK, "select-all", 0);
1563   gtk_binding_entry_add_signal (binding_set, GDK_KEY_slash, GDK_CONTROL_MASK, "select-all", 0);
1564
1565   gtk_binding_entry_add_signal (binding_set, GDK_KEY_A, GDK_CONTROL_MASK | GDK_SHIFT_MASK, "unselect-all", 0);
1566   gtk_binding_entry_add_signal (binding_set, GDK_KEY_backslash, GDK_CONTROL_MASK, "unselect-all", 0);
1567
1568   gtk_binding_entry_add_signal (binding_set, GDK_KEY_space, GDK_SHIFT_MASK, "select-cursor-row", 1,
1569                                 G_TYPE_BOOLEAN, TRUE);
1570   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Space, GDK_SHIFT_MASK, "select-cursor-row", 1,
1571                                 G_TYPE_BOOLEAN, TRUE);
1572
1573   gtk_binding_entry_add_signal (binding_set, GDK_KEY_space, 0, "select-cursor-row", 1,
1574                                 G_TYPE_BOOLEAN, TRUE);
1575   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Space, 0, "select-cursor-row", 1,
1576                                 G_TYPE_BOOLEAN, TRUE);
1577   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Return, 0, "select-cursor-row", 1,
1578                                 G_TYPE_BOOLEAN, TRUE);
1579   gtk_binding_entry_add_signal (binding_set, GDK_KEY_ISO_Enter, 0, "select-cursor-row", 1,
1580                                 G_TYPE_BOOLEAN, TRUE);
1581   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Enter, 0, "select-cursor-row", 1,
1582                                 G_TYPE_BOOLEAN, TRUE);
1583
1584   /* expand and collapse rows */
1585   gtk_binding_entry_add_signal (binding_set, GDK_KEY_plus, 0, "expand-collapse-cursor-row", 3,
1586                                 G_TYPE_BOOLEAN, TRUE,
1587                                 G_TYPE_BOOLEAN, TRUE,
1588                                 G_TYPE_BOOLEAN, FALSE);
1589
1590   gtk_binding_entry_add_signal (binding_set, GDK_KEY_asterisk, 0,
1591                                 "expand-collapse-cursor-row", 3,
1592                                 G_TYPE_BOOLEAN, TRUE,
1593                                 G_TYPE_BOOLEAN, TRUE,
1594                                 G_TYPE_BOOLEAN, TRUE);
1595   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Multiply, 0,
1596                                 "expand-collapse-cursor-row", 3,
1597                                 G_TYPE_BOOLEAN, TRUE,
1598                                 G_TYPE_BOOLEAN, TRUE,
1599                                 G_TYPE_BOOLEAN, TRUE);
1600
1601   gtk_binding_entry_add_signal (binding_set, GDK_KEY_slash, 0,
1602                                 "expand-collapse-cursor-row", 3,
1603                                 G_TYPE_BOOLEAN, TRUE,
1604                                 G_TYPE_BOOLEAN, FALSE,
1605                                 G_TYPE_BOOLEAN, FALSE);
1606   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Divide, 0,
1607                                 "expand-collapse-cursor-row", 3,
1608                                 G_TYPE_BOOLEAN, TRUE,
1609                                 G_TYPE_BOOLEAN, FALSE,
1610                                 G_TYPE_BOOLEAN, FALSE);
1611
1612   /* Not doable on US keyboards */
1613   gtk_binding_entry_add_signal (binding_set, GDK_KEY_plus, GDK_SHIFT_MASK, "expand-collapse-cursor-row", 3,
1614                                 G_TYPE_BOOLEAN, TRUE,
1615                                 G_TYPE_BOOLEAN, TRUE,
1616                                 G_TYPE_BOOLEAN, TRUE);
1617   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Add, 0, "expand-collapse-cursor-row", 3,
1618                                 G_TYPE_BOOLEAN, TRUE,
1619                                 G_TYPE_BOOLEAN, TRUE,
1620                                 G_TYPE_BOOLEAN, FALSE);
1621   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Add, GDK_SHIFT_MASK, "expand-collapse-cursor-row", 3,
1622                                 G_TYPE_BOOLEAN, TRUE,
1623                                 G_TYPE_BOOLEAN, TRUE,
1624                                 G_TYPE_BOOLEAN, TRUE);
1625   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Add, GDK_SHIFT_MASK, "expand-collapse-cursor-row", 3,
1626                                 G_TYPE_BOOLEAN, TRUE,
1627                                 G_TYPE_BOOLEAN, TRUE,
1628                                 G_TYPE_BOOLEAN, TRUE);
1629   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Right, GDK_SHIFT_MASK,
1630                                 "expand-collapse-cursor-row", 3,
1631                                 G_TYPE_BOOLEAN, FALSE,
1632                                 G_TYPE_BOOLEAN, TRUE,
1633                                 G_TYPE_BOOLEAN, TRUE);
1634   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Right, GDK_SHIFT_MASK,
1635                                 "expand-collapse-cursor-row", 3,
1636                                 G_TYPE_BOOLEAN, FALSE,
1637                                 G_TYPE_BOOLEAN, TRUE,
1638                                 G_TYPE_BOOLEAN, TRUE);
1639   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Right,
1640                                 GDK_CONTROL_MASK | GDK_SHIFT_MASK,
1641                                 "expand-collapse-cursor-row", 3,
1642                                 G_TYPE_BOOLEAN, FALSE,
1643                                 G_TYPE_BOOLEAN, TRUE,
1644                                 G_TYPE_BOOLEAN, TRUE);
1645   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Right,
1646                                 GDK_CONTROL_MASK | GDK_SHIFT_MASK,
1647                                 "expand-collapse-cursor-row", 3,
1648                                 G_TYPE_BOOLEAN, FALSE,
1649                                 G_TYPE_BOOLEAN, TRUE,
1650                                 G_TYPE_BOOLEAN, TRUE);
1651
1652   gtk_binding_entry_add_signal (binding_set, GDK_KEY_minus, 0, "expand-collapse-cursor-row", 3,
1653                                 G_TYPE_BOOLEAN, TRUE,
1654                                 G_TYPE_BOOLEAN, FALSE,
1655                                 G_TYPE_BOOLEAN, FALSE);
1656   gtk_binding_entry_add_signal (binding_set, GDK_KEY_minus, GDK_SHIFT_MASK, "expand-collapse-cursor-row", 3,
1657                                 G_TYPE_BOOLEAN, TRUE,
1658                                 G_TYPE_BOOLEAN, FALSE,
1659                                 G_TYPE_BOOLEAN, TRUE);
1660   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Subtract, 0, "expand-collapse-cursor-row", 3,
1661                                 G_TYPE_BOOLEAN, TRUE,
1662                                 G_TYPE_BOOLEAN, FALSE,
1663                                 G_TYPE_BOOLEAN, FALSE);
1664   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Subtract, GDK_SHIFT_MASK, "expand-collapse-cursor-row", 3,
1665                                 G_TYPE_BOOLEAN, TRUE,
1666                                 G_TYPE_BOOLEAN, FALSE,
1667                                 G_TYPE_BOOLEAN, TRUE);
1668   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Left, GDK_SHIFT_MASK,
1669                                 "expand-collapse-cursor-row", 3,
1670                                 G_TYPE_BOOLEAN, FALSE,
1671                                 G_TYPE_BOOLEAN, FALSE,
1672                                 G_TYPE_BOOLEAN, TRUE);
1673   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Left, GDK_SHIFT_MASK,
1674                                 "expand-collapse-cursor-row", 3,
1675                                 G_TYPE_BOOLEAN, FALSE,
1676                                 G_TYPE_BOOLEAN, FALSE,
1677                                 G_TYPE_BOOLEAN, TRUE);
1678   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Left,
1679                                 GDK_CONTROL_MASK | GDK_SHIFT_MASK,
1680                                 "expand-collapse-cursor-row", 3,
1681                                 G_TYPE_BOOLEAN, FALSE,
1682                                 G_TYPE_BOOLEAN, FALSE,
1683                                 G_TYPE_BOOLEAN, TRUE);
1684   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Left,
1685                                 GDK_CONTROL_MASK | GDK_SHIFT_MASK,
1686                                 "expand-collapse-cursor-row", 3,
1687                                 G_TYPE_BOOLEAN, FALSE,
1688                                 G_TYPE_BOOLEAN, FALSE,
1689                                 G_TYPE_BOOLEAN, TRUE);
1690
1691   gtk_binding_entry_add_signal (binding_set, GDK_KEY_BackSpace, 0, "select-cursor-parent", 0);
1692   gtk_binding_entry_add_signal (binding_set, GDK_KEY_BackSpace, GDK_CONTROL_MASK, "select-cursor-parent", 0);
1693
1694   gtk_binding_entry_add_signal (binding_set, GDK_KEY_f, GDK_CONTROL_MASK, "start-interactive-search", 0);
1695
1696   gtk_binding_entry_add_signal (binding_set, GDK_KEY_F, GDK_CONTROL_MASK, "start-interactive-search", 0);
1697
1698   g_type_class_add_private (o_class, sizeof (GtkTreeViewPrivate));
1699
1700   gtk_widget_class_set_accessible_type (widget_class, GTK_TYPE_TREE_VIEW_ACCESSIBLE);
1701 }
1702
1703 static void
1704 gtk_tree_view_init (GtkTreeView *tree_view)
1705 {
1706   tree_view->priv = G_TYPE_INSTANCE_GET_PRIVATE (tree_view, GTK_TYPE_TREE_VIEW, GtkTreeViewPrivate);
1707
1708   gtk_widget_set_can_focus (GTK_WIDGET (tree_view), TRUE);
1709   gtk_widget_set_redraw_on_allocate (GTK_WIDGET (tree_view), FALSE);
1710
1711   tree_view->priv->show_expanders = TRUE;
1712   tree_view->priv->draw_keyfocus = TRUE;
1713   tree_view->priv->headers_visible = TRUE;
1714
1715   /* We need some padding */
1716   tree_view->priv->dy = 0;
1717   tree_view->priv->cursor_offset = 0;
1718   tree_view->priv->n_columns = 0;
1719   tree_view->priv->header_height = 1;
1720   tree_view->priv->x_drag = 0;
1721   tree_view->priv->drag_pos = -1;
1722   tree_view->priv->header_has_focus = FALSE;
1723   tree_view->priv->pressed_button = -1;
1724   tree_view->priv->press_start_x = -1;
1725   tree_view->priv->press_start_y = -1;
1726   tree_view->priv->reorderable = FALSE;
1727   tree_view->priv->presize_handler_timer = 0;
1728   tree_view->priv->scroll_sync_timer = 0;
1729   tree_view->priv->fixed_height = -1;
1730   tree_view->priv->fixed_height_mode = FALSE;
1731   tree_view->priv->fixed_height_check = 0;
1732   tree_view->priv->selection = _gtk_tree_selection_new_with_tree_view (tree_view);
1733   tree_view->priv->enable_search = TRUE;
1734   tree_view->priv->search_column = -1;
1735   tree_view->priv->search_position_func = gtk_tree_view_search_position_func;
1736   tree_view->priv->search_equal_func = gtk_tree_view_search_equal_func;
1737   tree_view->priv->search_custom_entry_set = FALSE;
1738   tree_view->priv->typeselect_flush_timeout = 0;
1739   tree_view->priv->init_hadjust_value = TRUE;
1740   tree_view->priv->width = 0;
1741
1742   tree_view->priv->hover_selection = FALSE;
1743   tree_view->priv->hover_expand = FALSE;
1744
1745   tree_view->priv->level_indentation = 0;
1746
1747   tree_view->priv->rubber_banding_enable = FALSE;
1748
1749   tree_view->priv->grid_lines = GTK_TREE_VIEW_GRID_LINES_NONE;
1750   tree_view->priv->tree_lines_enabled = FALSE;
1751
1752   tree_view->priv->tooltip_column = -1;
1753
1754   tree_view->priv->post_validation_flag = FALSE;
1755
1756   tree_view->priv->last_button_x = -1;
1757   tree_view->priv->last_button_y = -1;
1758
1759   tree_view->priv->event_last_x = -10000;
1760   tree_view->priv->event_last_y = -10000;
1761
1762   gtk_tree_view_do_set_vadjustment (tree_view, NULL);
1763   gtk_tree_view_do_set_hadjustment (tree_view, NULL);
1764 }
1765
1766 \f
1767
1768 /* GObject Methods
1769  */
1770
1771 static void
1772 gtk_tree_view_set_property (GObject         *object,
1773                             guint            prop_id,
1774                             const GValue    *value,
1775                             GParamSpec      *pspec)
1776 {
1777   GtkTreeView *tree_view;
1778
1779   tree_view = GTK_TREE_VIEW (object);
1780
1781   switch (prop_id)
1782     {
1783     case PROP_MODEL:
1784       gtk_tree_view_set_model (tree_view, g_value_get_object (value));
1785       break;
1786     case PROP_HADJUSTMENT:
1787       gtk_tree_view_do_set_hadjustment (tree_view, g_value_get_object (value));
1788       break;
1789     case PROP_VADJUSTMENT:
1790       gtk_tree_view_do_set_vadjustment (tree_view, g_value_get_object (value));
1791       break;
1792     case PROP_HSCROLL_POLICY:
1793       tree_view->priv->hscroll_policy = g_value_get_enum (value);
1794       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
1795       break;
1796     case PROP_VSCROLL_POLICY:
1797       tree_view->priv->vscroll_policy = g_value_get_enum (value);
1798       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
1799       break;
1800     case PROP_HEADERS_VISIBLE:
1801       gtk_tree_view_set_headers_visible (tree_view, g_value_get_boolean (value));
1802       break;
1803     case PROP_HEADERS_CLICKABLE:
1804       gtk_tree_view_set_headers_clickable (tree_view, g_value_get_boolean (value));
1805       break;
1806     case PROP_EXPANDER_COLUMN:
1807       gtk_tree_view_set_expander_column (tree_view, g_value_get_object (value));
1808       break;
1809     case PROP_REORDERABLE:
1810       gtk_tree_view_set_reorderable (tree_view, g_value_get_boolean (value));
1811       break;
1812     case PROP_RULES_HINT:
1813       gtk_tree_view_set_rules_hint (tree_view, g_value_get_boolean (value));
1814       break;
1815     case PROP_ENABLE_SEARCH:
1816       gtk_tree_view_set_enable_search (tree_view, g_value_get_boolean (value));
1817       break;
1818     case PROP_SEARCH_COLUMN:
1819       gtk_tree_view_set_search_column (tree_view, g_value_get_int (value));
1820       break;
1821     case PROP_FIXED_HEIGHT_MODE:
1822       gtk_tree_view_set_fixed_height_mode (tree_view, g_value_get_boolean (value));
1823       break;
1824     case PROP_HOVER_SELECTION:
1825       tree_view->priv->hover_selection = g_value_get_boolean (value);
1826       break;
1827     case PROP_HOVER_EXPAND:
1828       tree_view->priv->hover_expand = g_value_get_boolean (value);
1829       break;
1830     case PROP_SHOW_EXPANDERS:
1831       gtk_tree_view_set_show_expanders (tree_view, g_value_get_boolean (value));
1832       break;
1833     case PROP_LEVEL_INDENTATION:
1834       tree_view->priv->level_indentation = g_value_get_int (value);
1835       break;
1836     case PROP_RUBBER_BANDING:
1837       tree_view->priv->rubber_banding_enable = g_value_get_boolean (value);
1838       break;
1839     case PROP_ENABLE_GRID_LINES:
1840       gtk_tree_view_set_grid_lines (tree_view, g_value_get_enum (value));
1841       break;
1842     case PROP_ENABLE_TREE_LINES:
1843       gtk_tree_view_set_enable_tree_lines (tree_view, g_value_get_boolean (value));
1844       break;
1845     case PROP_TOOLTIP_COLUMN:
1846       gtk_tree_view_set_tooltip_column (tree_view, g_value_get_int (value));
1847       break;
1848     default:
1849       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1850       break;
1851     }
1852 }
1853
1854 static void
1855 gtk_tree_view_get_property (GObject    *object,
1856                             guint       prop_id,
1857                             GValue     *value,
1858                             GParamSpec *pspec)
1859 {
1860   GtkTreeView *tree_view;
1861
1862   tree_view = GTK_TREE_VIEW (object);
1863
1864   switch (prop_id)
1865     {
1866     case PROP_MODEL:
1867       g_value_set_object (value, tree_view->priv->model);
1868       break;
1869     case PROP_HADJUSTMENT:
1870       g_value_set_object (value, tree_view->priv->hadjustment);
1871       break;
1872     case PROP_VADJUSTMENT:
1873       g_value_set_object (value, tree_view->priv->vadjustment);
1874       break;
1875     case PROP_HSCROLL_POLICY:
1876       g_value_set_enum (value, tree_view->priv->hscroll_policy);
1877       break;
1878     case PROP_VSCROLL_POLICY:
1879       g_value_set_enum (value, tree_view->priv->vscroll_policy);
1880       break;
1881     case PROP_HEADERS_VISIBLE:
1882       g_value_set_boolean (value, gtk_tree_view_get_headers_visible (tree_view));
1883       break;
1884     case PROP_HEADERS_CLICKABLE:
1885       g_value_set_boolean (value, gtk_tree_view_get_headers_clickable (tree_view));
1886       break;
1887     case PROP_EXPANDER_COLUMN:
1888       g_value_set_object (value, tree_view->priv->expander_column);
1889       break;
1890     case PROP_REORDERABLE:
1891       g_value_set_boolean (value, tree_view->priv->reorderable);
1892       break;
1893     case PROP_RULES_HINT:
1894       g_value_set_boolean (value, tree_view->priv->has_rules);
1895       break;
1896     case PROP_ENABLE_SEARCH:
1897       g_value_set_boolean (value, tree_view->priv->enable_search);
1898       break;
1899     case PROP_SEARCH_COLUMN:
1900       g_value_set_int (value, tree_view->priv->search_column);
1901       break;
1902     case PROP_FIXED_HEIGHT_MODE:
1903       g_value_set_boolean (value, tree_view->priv->fixed_height_mode);
1904       break;
1905     case PROP_HOVER_SELECTION:
1906       g_value_set_boolean (value, tree_view->priv->hover_selection);
1907       break;
1908     case PROP_HOVER_EXPAND:
1909       g_value_set_boolean (value, tree_view->priv->hover_expand);
1910       break;
1911     case PROP_SHOW_EXPANDERS:
1912       g_value_set_boolean (value, tree_view->priv->show_expanders);
1913       break;
1914     case PROP_LEVEL_INDENTATION:
1915       g_value_set_int (value, tree_view->priv->level_indentation);
1916       break;
1917     case PROP_RUBBER_BANDING:
1918       g_value_set_boolean (value, tree_view->priv->rubber_banding_enable);
1919       break;
1920     case PROP_ENABLE_GRID_LINES:
1921       g_value_set_enum (value, tree_view->priv->grid_lines);
1922       break;
1923     case PROP_ENABLE_TREE_LINES:
1924       g_value_set_boolean (value, tree_view->priv->tree_lines_enabled);
1925       break;
1926     case PROP_TOOLTIP_COLUMN:
1927       g_value_set_int (value, tree_view->priv->tooltip_column);
1928       break;
1929     default:
1930       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1931       break;
1932     }
1933 }
1934
1935 static void
1936 gtk_tree_view_finalize (GObject *object)
1937 {
1938   G_OBJECT_CLASS (gtk_tree_view_parent_class)->finalize (object);
1939 }
1940
1941
1942 static GtkBuildableIface *parent_buildable_iface;
1943
1944 static void
1945 gtk_tree_view_buildable_init (GtkBuildableIface *iface)
1946 {
1947   parent_buildable_iface = g_type_interface_peek_parent (iface);
1948   iface->add_child = gtk_tree_view_buildable_add_child;
1949   iface->get_internal_child = gtk_tree_view_buildable_get_internal_child;
1950 }
1951
1952 static void
1953 gtk_tree_view_buildable_add_child (GtkBuildable *tree_view,
1954                                    GtkBuilder  *builder,
1955                                    GObject     *child,
1956                                    const gchar *type)
1957 {
1958   gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), GTK_TREE_VIEW_COLUMN (child));
1959 }
1960
1961 static GObject *
1962 gtk_tree_view_buildable_get_internal_child (GtkBuildable      *buildable,
1963                                             GtkBuilder        *builder,
1964                                             const gchar       *childname)
1965 {
1966     if (strcmp (childname, "selection") == 0)
1967       return G_OBJECT (GTK_TREE_VIEW (buildable)->priv->selection);
1968
1969     return parent_buildable_iface->get_internal_child (buildable,
1970                                                        builder,
1971                                                        childname);
1972 }
1973
1974 /* GtkWidget Methods
1975  */
1976
1977 static void
1978 gtk_tree_view_free_rbtree (GtkTreeView *tree_view)
1979 {
1980   _gtk_rbtree_free (tree_view->priv->tree);
1981
1982   tree_view->priv->tree = NULL;
1983   tree_view->priv->button_pressed_node = NULL;
1984   tree_view->priv->button_pressed_tree = NULL;
1985   tree_view->priv->prelight_tree = NULL;
1986   tree_view->priv->prelight_node = NULL;
1987   tree_view->priv->expanded_collapsed_node = NULL;
1988   tree_view->priv->expanded_collapsed_tree = NULL;
1989 }
1990
1991 static void
1992 gtk_tree_view_destroy (GtkWidget *widget)
1993 {
1994   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
1995   GList *list;
1996
1997   gtk_tree_view_stop_editing (tree_view, TRUE);
1998
1999   if (tree_view->priv->columns != NULL)
2000     {
2001       list = tree_view->priv->columns;
2002       while (list)
2003         {
2004           GtkTreeViewColumn *column;
2005           column = GTK_TREE_VIEW_COLUMN (list->data);
2006           list = list->next;
2007           gtk_tree_view_remove_column (tree_view, column);
2008         }
2009       tree_view->priv->columns = NULL;
2010     }
2011
2012   if (tree_view->priv->tree != NULL)
2013     {
2014       gtk_tree_view_unref_and_check_selection_tree (tree_view, tree_view->priv->tree);
2015
2016       gtk_tree_view_free_rbtree (tree_view);
2017     }
2018
2019   if (tree_view->priv->selection != NULL)
2020     {
2021       _gtk_tree_selection_set_tree_view (tree_view->priv->selection, NULL);
2022       g_object_unref (tree_view->priv->selection);
2023       tree_view->priv->selection = NULL;
2024     }
2025
2026   if (tree_view->priv->scroll_to_path != NULL)
2027     {
2028       gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
2029       tree_view->priv->scroll_to_path = NULL;
2030     }
2031
2032   if (tree_view->priv->drag_dest_row != NULL)
2033     {
2034       gtk_tree_row_reference_free (tree_view->priv->drag_dest_row);
2035       tree_view->priv->drag_dest_row = NULL;
2036     }
2037
2038   if (tree_view->priv->top_row != NULL)
2039     {
2040       gtk_tree_row_reference_free (tree_view->priv->top_row);
2041       tree_view->priv->top_row = NULL;
2042     }
2043
2044   if (tree_view->priv->column_drop_func_data &&
2045       tree_view->priv->column_drop_func_data_destroy)
2046     {
2047       tree_view->priv->column_drop_func_data_destroy (tree_view->priv->column_drop_func_data);
2048       tree_view->priv->column_drop_func_data = NULL;
2049     }
2050
2051   if (tree_view->priv->destroy_count_destroy &&
2052       tree_view->priv->destroy_count_data)
2053     {
2054       tree_view->priv->destroy_count_destroy (tree_view->priv->destroy_count_data);
2055       tree_view->priv->destroy_count_data = NULL;
2056     }
2057
2058   gtk_tree_row_reference_free (tree_view->priv->cursor);
2059   tree_view->priv->cursor = NULL;
2060
2061   gtk_tree_row_reference_free (tree_view->priv->anchor);
2062   tree_view->priv->anchor = NULL;
2063
2064   /* destroy interactive search dialog */
2065   if (tree_view->priv->search_window)
2066     {
2067       gtk_widget_destroy (tree_view->priv->search_window);
2068       tree_view->priv->search_window = NULL;
2069       tree_view->priv->search_entry = NULL;
2070       if (tree_view->priv->typeselect_flush_timeout)
2071         {
2072           g_source_remove (tree_view->priv->typeselect_flush_timeout);
2073           tree_view->priv->typeselect_flush_timeout = 0;
2074         }
2075     }
2076
2077   if (tree_view->priv->search_destroy && tree_view->priv->search_user_data)
2078     {
2079       tree_view->priv->search_destroy (tree_view->priv->search_user_data);
2080       tree_view->priv->search_user_data = NULL;
2081     }
2082
2083   if (tree_view->priv->search_position_destroy && tree_view->priv->search_position_user_data)
2084     {
2085       tree_view->priv->search_position_destroy (tree_view->priv->search_position_user_data);
2086       tree_view->priv->search_position_user_data = NULL;
2087     }
2088
2089   if (tree_view->priv->row_separator_destroy && tree_view->priv->row_separator_data)
2090     {
2091       tree_view->priv->row_separator_destroy (tree_view->priv->row_separator_data);
2092       tree_view->priv->row_separator_data = NULL;
2093     }
2094
2095   gtk_tree_view_set_model (tree_view, NULL);
2096
2097   if (tree_view->priv->hadjustment)
2098     {
2099       g_object_unref (tree_view->priv->hadjustment);
2100       tree_view->priv->hadjustment = NULL;
2101     }
2102   if (tree_view->priv->vadjustment)
2103     {
2104       g_object_unref (tree_view->priv->vadjustment);
2105       tree_view->priv->vadjustment = NULL;
2106     }
2107
2108   GTK_WIDGET_CLASS (gtk_tree_view_parent_class)->destroy (widget);
2109 }
2110
2111 /* GtkWidget::map helper */
2112 static void
2113 gtk_tree_view_map_buttons (GtkTreeView *tree_view)
2114 {
2115   GList *list;
2116
2117   g_return_if_fail (gtk_widget_get_mapped (GTK_WIDGET (tree_view)));
2118
2119   if (tree_view->priv->headers_visible)
2120     {
2121       GtkTreeViewColumn *column;
2122       GtkWidget         *button;
2123       GdkWindow         *window;
2124
2125       for (list = tree_view->priv->columns; list; list = list->next)
2126         {
2127           column = list->data;
2128           button = gtk_tree_view_column_get_button (column);
2129
2130           if (gtk_tree_view_column_get_visible (column) && button)
2131             gtk_widget_show_now (button);
2132
2133           if (gtk_widget_get_visible (button) &&
2134               !gtk_widget_get_mapped (button))
2135             gtk_widget_map (button);
2136         }
2137       for (list = tree_view->priv->columns; list; list = list->next)
2138         {
2139           column = list->data;
2140           if (gtk_tree_view_column_get_visible (column) == FALSE)
2141             continue;
2142
2143           window = _gtk_tree_view_column_get_window (column);
2144           if (gtk_tree_view_column_get_resizable (column))
2145             {
2146               gdk_window_raise (window);
2147               gdk_window_show (window);
2148             }
2149           else
2150             gdk_window_hide (window);
2151         }
2152       gdk_window_show (tree_view->priv->header_window);
2153     }
2154 }
2155
2156 static void
2157 gtk_tree_view_map (GtkWidget *widget)
2158 {
2159   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
2160   GList *tmp_list;
2161
2162   gtk_widget_set_mapped (widget, TRUE);
2163
2164   tmp_list = tree_view->priv->children;
2165   while (tmp_list)
2166     {
2167       GtkTreeViewChild *child = tmp_list->data;
2168       tmp_list = tmp_list->next;
2169
2170       if (gtk_widget_get_visible (child->widget))
2171         {
2172           if (!gtk_widget_get_mapped (child->widget))
2173             gtk_widget_map (child->widget);
2174         }
2175     }
2176   gdk_window_show (tree_view->priv->bin_window);
2177
2178   gtk_tree_view_map_buttons (tree_view);
2179
2180   gdk_window_show (gtk_widget_get_window (widget));
2181 }
2182
2183 static void
2184 gtk_tree_view_ensure_background (GtkTreeView *tree_view)
2185 {
2186   GtkStyleContext *context;
2187
2188   context = gtk_widget_get_style_context (GTK_WIDGET (tree_view));
2189
2190   gtk_style_context_save (context);
2191   gtk_style_context_add_class (context, GTK_STYLE_CLASS_VIEW);
2192   gtk_style_context_set_background (context, tree_view->priv->bin_window);
2193   gtk_style_context_restore (context);
2194
2195   gtk_style_context_set_background (context, tree_view->priv->header_window);
2196 }
2197
2198 static void
2199 gtk_tree_view_realize (GtkWidget *widget)
2200 {
2201   GtkAllocation allocation;
2202   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
2203   GdkWindow *window;
2204   GdkWindowAttr attributes;
2205   GList *tmp_list;
2206   gint attributes_mask;
2207
2208   gtk_widget_set_realized (widget, TRUE);
2209
2210   gtk_widget_get_allocation (widget, &allocation);
2211
2212   /* Make the main, clipping window */
2213   attributes.window_type = GDK_WINDOW_CHILD;
2214   attributes.x = allocation.x;
2215   attributes.y = allocation.y;
2216   attributes.width = allocation.width;
2217   attributes.height = allocation.height;
2218   attributes.wclass = GDK_INPUT_OUTPUT;
2219   attributes.visual = gtk_widget_get_visual (widget);
2220   attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK;
2221
2222   attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
2223
2224   window = gdk_window_new (gtk_widget_get_parent_window (widget),
2225                            &attributes, attributes_mask);
2226   gtk_widget_set_window (widget, window);
2227   gdk_window_set_user_data (window, widget);
2228
2229   gtk_widget_get_allocation (widget, &allocation);
2230
2231   /* Make the window for the tree */
2232   attributes.x = 0;
2233   attributes.y = gtk_tree_view_get_effective_header_height (tree_view);
2234   attributes.width = MAX (tree_view->priv->width, allocation.width);
2235   attributes.height = allocation.height;
2236   attributes.event_mask = (GDK_EXPOSURE_MASK |
2237                            GDK_SCROLL_MASK |
2238                            GDK_POINTER_MOTION_MASK |
2239                            GDK_ENTER_NOTIFY_MASK |
2240                            GDK_LEAVE_NOTIFY_MASK |
2241                            GDK_BUTTON_PRESS_MASK |
2242                            GDK_BUTTON_RELEASE_MASK |
2243                            gtk_widget_get_events (widget));
2244
2245   tree_view->priv->bin_window = gdk_window_new (window,
2246                                                 &attributes, attributes_mask);
2247   gdk_window_set_user_data (tree_view->priv->bin_window, widget);
2248
2249   gtk_widget_get_allocation (widget, &allocation);
2250
2251   /* Make the column header window */
2252   attributes.x = 0;
2253   attributes.y = 0;
2254   attributes.width = MAX (tree_view->priv->width, allocation.width);
2255   attributes.height = tree_view->priv->header_height;
2256   attributes.event_mask = (GDK_EXPOSURE_MASK |
2257                            GDK_SCROLL_MASK |
2258                            GDK_ENTER_NOTIFY_MASK |
2259                            GDK_LEAVE_NOTIFY_MASK |
2260                            GDK_BUTTON_PRESS_MASK |
2261                            GDK_BUTTON_RELEASE_MASK |
2262                            GDK_KEY_PRESS_MASK |
2263                            GDK_KEY_RELEASE_MASK |
2264                            gtk_widget_get_events (widget));
2265
2266   tree_view->priv->header_window = gdk_window_new (window,
2267                                                    &attributes, attributes_mask);
2268   gdk_window_set_user_data (tree_view->priv->header_window, widget);
2269
2270   gtk_tree_view_ensure_background (tree_view);
2271
2272   tmp_list = tree_view->priv->children;
2273   while (tmp_list)
2274     {
2275       GtkTreeViewChild *child = tmp_list->data;
2276       tmp_list = tmp_list->next;
2277
2278       gtk_widget_set_parent_window (child->widget, tree_view->priv->bin_window);
2279     }
2280
2281   for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list = tmp_list->next)
2282     _gtk_tree_view_column_realize_button (GTK_TREE_VIEW_COLUMN (tmp_list->data));
2283
2284   /* Need to call those here, since they create GCs */
2285   gtk_tree_view_set_grid_lines (tree_view, tree_view->priv->grid_lines);
2286   gtk_tree_view_set_enable_tree_lines (tree_view, tree_view->priv->tree_lines_enabled);
2287
2288   install_presize_handler (tree_view);
2289 }
2290
2291 static void
2292 gtk_tree_view_unrealize (GtkWidget *widget)
2293 {
2294   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
2295   GtkTreeViewPrivate *priv = tree_view->priv;
2296   GtkStyleContext *context;
2297   GList *list;
2298
2299   if (priv->scroll_timeout != 0)
2300     {
2301       g_source_remove (priv->scroll_timeout);
2302       priv->scroll_timeout = 0;
2303     }
2304
2305   if (priv->auto_expand_timeout != 0)
2306     {
2307       g_source_remove (priv->auto_expand_timeout);
2308       priv->auto_expand_timeout = 0;
2309     }
2310
2311   if (priv->open_dest_timeout != 0)
2312     {
2313       g_source_remove (priv->open_dest_timeout);
2314       priv->open_dest_timeout = 0;
2315     }
2316
2317   context = gtk_widget_get_style_context (widget);
2318   gtk_style_context_cancel_animations (context, NULL);
2319
2320   if (priv->presize_handler_timer != 0)
2321     {
2322       g_source_remove (priv->presize_handler_timer);
2323       priv->presize_handler_timer = 0;
2324     }
2325
2326   if (priv->validate_rows_timer != 0)
2327     {
2328       g_source_remove (priv->validate_rows_timer);
2329       priv->validate_rows_timer = 0;
2330     }
2331
2332   if (priv->scroll_sync_timer != 0)
2333     {
2334       g_source_remove (priv->scroll_sync_timer);
2335       priv->scroll_sync_timer = 0;
2336     }
2337
2338   if (priv->typeselect_flush_timeout)
2339     {
2340       g_source_remove (priv->typeselect_flush_timeout);
2341       priv->typeselect_flush_timeout = 0;
2342     }
2343
2344   for (list = priv->columns; list; list = list->next)
2345     _gtk_tree_view_column_unrealize_button (GTK_TREE_VIEW_COLUMN (list->data));
2346
2347   gdk_window_set_user_data (priv->bin_window, NULL);
2348   gdk_window_destroy (priv->bin_window);
2349   priv->bin_window = NULL;
2350
2351   gdk_window_set_user_data (priv->header_window, NULL);
2352   gdk_window_destroy (priv->header_window);
2353   priv->header_window = NULL;
2354
2355   if (priv->drag_window)
2356     {
2357       gdk_window_set_user_data (priv->drag_window, NULL);
2358       gdk_window_destroy (priv->drag_window);
2359       priv->drag_window = NULL;
2360     }
2361
2362   if (priv->drag_highlight_window)
2363     {
2364       gdk_window_set_user_data (priv->drag_highlight_window, NULL);
2365       gdk_window_destroy (priv->drag_highlight_window);
2366       priv->drag_highlight_window = NULL;
2367     }
2368
2369   GTK_WIDGET_CLASS (gtk_tree_view_parent_class)->unrealize (widget);
2370 }
2371
2372 /* GtkWidget::size_request helper */
2373 static void
2374 gtk_tree_view_size_request_columns (GtkTreeView *tree_view)
2375 {
2376   GList *list;
2377
2378   tree_view->priv->header_height = 0;
2379
2380   for (list = tree_view->priv->columns; list; list = list->next)
2381     {
2382       GtkRequisition     requisition;
2383       GtkTreeViewColumn *column = list->data;
2384       GtkWidget         *button = gtk_tree_view_column_get_button (column);
2385
2386       if (button == NULL)
2387         continue;
2388
2389       gtk_widget_get_preferred_size (button, &requisition, NULL);
2390       tree_view->priv->header_height = MAX (tree_view->priv->header_height, requisition.height);
2391     }
2392 }
2393
2394
2395 /* Called only by ::size_request */
2396 static void
2397 gtk_tree_view_update_size (GtkTreeView *tree_view)
2398 {
2399   GList *list;
2400   GtkTreeViewColumn *column;
2401   gint i;
2402
2403   if (tree_view->priv->model == NULL)
2404     {
2405       tree_view->priv->width = 0;
2406       tree_view->priv->prev_width = 0;
2407       tree_view->priv->height = 0;
2408       return;
2409     }
2410
2411   tree_view->priv->prev_width = tree_view->priv->width;
2412   tree_view->priv->width = 0;
2413
2414   /* keep this in sync with size_allocate below */
2415   for (list = tree_view->priv->columns, i = 0; list; list = list->next, i++)
2416     {
2417       column = list->data;
2418       if (!gtk_tree_view_column_get_visible (column))
2419         continue;
2420
2421       tree_view->priv->width += _gtk_tree_view_column_request_width (column);
2422     }
2423
2424   if (tree_view->priv->tree == NULL)
2425     tree_view->priv->height = 0;
2426   else
2427     tree_view->priv->height = tree_view->priv->tree->root->offset;
2428 }
2429
2430 static void
2431 gtk_tree_view_size_request (GtkWidget      *widget,
2432                             GtkRequisition *requisition,
2433                             gboolean        may_validate)
2434 {
2435   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
2436
2437   if (may_validate)
2438     {
2439       /* we validate some rows initially just to make sure we have some size.
2440        * In practice, with a lot of static lists, this should get a good width.
2441        */
2442       do_validate_rows (tree_view, FALSE);
2443     }
2444
2445   gtk_tree_view_size_request_columns (tree_view);
2446   gtk_tree_view_update_size (GTK_TREE_VIEW (widget));
2447
2448   requisition->width = tree_view->priv->width;
2449   requisition->height = tree_view->priv->height + gtk_tree_view_get_effective_header_height (tree_view);
2450 }
2451
2452 static void
2453 gtk_tree_view_get_preferred_width (GtkWidget *widget,
2454                                    gint      *minimum,
2455                                    gint      *natural)
2456 {
2457   GtkRequisition requisition;
2458
2459   gtk_tree_view_size_request (widget, &requisition, TRUE);
2460
2461   *minimum = *natural = requisition.width;
2462 }
2463
2464 static void
2465 gtk_tree_view_get_preferred_height (GtkWidget *widget,
2466                                     gint      *minimum,
2467                                     gint      *natural)
2468 {
2469   GtkRequisition requisition;
2470
2471   gtk_tree_view_size_request (widget, &requisition, TRUE);
2472
2473   *minimum = *natural = requisition.height;
2474 }
2475
2476 static int
2477 gtk_tree_view_calculate_width_before_expander (GtkTreeView *tree_view)
2478 {
2479   int width = 0;
2480   GList *list;
2481   gboolean rtl;
2482
2483   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
2484   for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
2485        list->data != tree_view->priv->expander_column;
2486        list = (rtl ? list->prev : list->next))
2487     {
2488       GtkTreeViewColumn *column = list->data;
2489
2490       width += gtk_tree_view_column_get_width (column);
2491     }
2492
2493   return width;
2494 }
2495
2496 /* GtkWidget::size_allocate helper */
2497 static void
2498 gtk_tree_view_size_allocate_columns (GtkWidget *widget,
2499                                      gboolean  *width_changed)
2500 {
2501   GtkTreeView *tree_view;
2502   GList *list, *first_column, *last_column;
2503   GtkTreeViewColumn *column;
2504   GtkAllocation widget_allocation;
2505   gint width = 0;
2506   gint extra, extra_per_column, extra_for_last;
2507   gint full_requested_width = 0;
2508   gint number_of_expand_columns = 0;
2509   gboolean rtl;
2510   gboolean update_expand;
2511
2512   tree_view = GTK_TREE_VIEW (widget);
2513
2514   for (last_column = g_list_last (tree_view->priv->columns);
2515        last_column &&
2516        !(gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (last_column->data)));
2517        last_column = last_column->prev)
2518     ;
2519   if (last_column == NULL)
2520     return;
2521
2522   for (first_column = g_list_first (tree_view->priv->columns);
2523        first_column &&
2524        !(gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (first_column->data)));
2525        first_column = first_column->next)
2526     ;
2527
2528   rtl = (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL);
2529
2530   /* find out how many extra space and expandable columns we have */
2531   for (list = tree_view->priv->columns; list != last_column->next; list = list->next)
2532     {
2533       column = (GtkTreeViewColumn *)list->data;
2534
2535       if (!gtk_tree_view_column_get_visible (column))
2536         continue;
2537
2538       full_requested_width += _gtk_tree_view_column_request_width (column);
2539
2540       if (gtk_tree_view_column_get_expand (column))
2541         number_of_expand_columns++;
2542     }
2543
2544   /* Only update the expand value if the width of the widget has changed,
2545    * or the number of expand columns has changed, or if there are no expand
2546    * columns, or if we didn't have an size-allocation yet after the
2547    * last validated node.
2548    */
2549   update_expand = (width_changed && *width_changed == TRUE)
2550       || number_of_expand_columns != tree_view->priv->last_number_of_expand_columns
2551       || number_of_expand_columns == 0
2552       || tree_view->priv->post_validation_flag == TRUE;
2553
2554   tree_view->priv->post_validation_flag = FALSE;
2555
2556   gtk_widget_get_allocation (widget, &widget_allocation);
2557   if (!update_expand)
2558     {
2559       extra = tree_view->priv->last_extra_space;
2560       extra_for_last = MAX (widget_allocation.width - full_requested_width - extra, 0);
2561     }
2562   else
2563     {
2564       extra = MAX (widget_allocation.width - full_requested_width, 0);
2565       extra_for_last = 0;
2566
2567       tree_view->priv->last_extra_space = extra;
2568     }
2569
2570   if (number_of_expand_columns > 0)
2571     extra_per_column = extra/number_of_expand_columns;
2572   else
2573     extra_per_column = 0;
2574
2575   if (update_expand)
2576     {
2577       tree_view->priv->last_extra_space_per_column = extra_per_column;
2578       tree_view->priv->last_number_of_expand_columns = number_of_expand_columns;
2579     }
2580
2581   for (list = (rtl ? last_column : first_column);
2582        list != (rtl ? first_column->prev : last_column->next);
2583        list = (rtl ? list->prev : list->next))
2584     {
2585       gint column_width;
2586
2587       column = list->data;
2588
2589       if (!gtk_tree_view_column_get_visible (column))
2590         continue;
2591
2592       /* We need to handle the dragged button specially.
2593        */
2594       if (column == tree_view->priv->drag_column)
2595         {
2596           GtkAllocation drag_allocation;
2597           GtkWidget    *button;
2598
2599           button = gtk_tree_view_column_get_button (tree_view->priv->drag_column);
2600
2601           drag_allocation.x = 0;
2602           drag_allocation.y = 0;
2603           drag_allocation.width = gdk_window_get_width (tree_view->priv->drag_window);
2604           drag_allocation.height = gdk_window_get_height (tree_view->priv->drag_window);
2605           gtk_widget_size_allocate (button, &drag_allocation);
2606           width += drag_allocation.width;
2607           continue;
2608         }
2609
2610       column_width = _gtk_tree_view_column_request_width (column);
2611
2612       if (gtk_tree_view_column_get_expand (column))
2613         {
2614           if (number_of_expand_columns == 1)
2615             {
2616               /* We add the remander to the last column as
2617                * */
2618               column_width += extra;
2619             }
2620           else
2621             {
2622               column_width += extra_per_column;
2623               extra -= extra_per_column;
2624               number_of_expand_columns --;
2625             }
2626         }
2627       else if (number_of_expand_columns == 0 &&
2628                list == last_column)
2629         {
2630           column_width += extra;
2631         }
2632
2633       /* In addition to expand, the last column can get even more
2634        * extra space so all available space is filled up.
2635        */
2636       if (extra_for_last > 0 && list == last_column)
2637         column_width += extra_for_last;
2638
2639       _gtk_tree_view_column_allocate (column, width, column_width);
2640
2641       width += column_width;
2642     }
2643
2644   /* We change the width here.  The user might have been resizing columns,
2645    * which changes the total width of the tree view.  This is of
2646    * importance for getting the horizontal scroll bar right.
2647    */
2648   if (tree_view->priv->width != width)
2649     {
2650       tree_view->priv->width = width;
2651       if (width_changed)
2652         *width_changed = TRUE;
2653     }
2654 }
2655
2656
2657 static void
2658 gtk_tree_view_size_allocate (GtkWidget     *widget,
2659                              GtkAllocation *allocation)
2660 {
2661   GtkAllocation widget_allocation;
2662   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
2663   GList *tmp_list;
2664   gboolean width_changed = FALSE;
2665   gint old_width;
2666
2667   gtk_widget_get_allocation (widget, &widget_allocation);
2668   old_width = widget_allocation.width;
2669   if (allocation->width != widget_allocation.width)
2670     width_changed = TRUE;
2671
2672   gtk_widget_set_allocation (widget, allocation);
2673
2674   tmp_list = tree_view->priv->children;
2675
2676   while (tmp_list)
2677     {
2678       GtkAllocation allocation;
2679
2680       GtkTreeViewChild *child = tmp_list->data;
2681       tmp_list = tmp_list->next;
2682
2683       /* totally ignore our child's requisition */
2684       allocation.x = child->x;
2685       allocation.y = child->y;
2686       allocation.width = child->width;
2687       allocation.height = child->height;
2688       gtk_widget_size_allocate (child->widget, &allocation);
2689     }
2690
2691   /* We size-allocate the columns first because the width of the
2692    * tree view (used in updating the adjustments below) might change.
2693    */
2694   gtk_tree_view_size_allocate_columns (widget, &width_changed);
2695
2696   g_object_freeze_notify (G_OBJECT (tree_view->priv->hadjustment));
2697   gtk_adjustment_set_page_size (tree_view->priv->hadjustment,
2698                                 allocation->width);
2699   gtk_adjustment_set_page_increment (tree_view->priv->hadjustment,
2700                                      allocation->width * 0.9);
2701   gtk_adjustment_set_step_increment (tree_view->priv->hadjustment,
2702                                      allocation->width * 0.1);
2703   gtk_adjustment_set_lower (tree_view->priv->hadjustment, 0);
2704   gtk_adjustment_set_upper (tree_view->priv->hadjustment,
2705                             MAX (gtk_adjustment_get_page_size (tree_view->priv->hadjustment),
2706                                  tree_view->priv->width));
2707   g_object_thaw_notify (G_OBJECT (tree_view->priv->hadjustment));
2708
2709   if (gtk_widget_get_direction(widget) == GTK_TEXT_DIR_RTL)
2710     {
2711       if (allocation->width < tree_view->priv->width)
2712         {
2713           if (tree_view->priv->init_hadjust_value)
2714             {
2715               gtk_adjustment_set_value (tree_view->priv->hadjustment,
2716                                         MAX (tree_view->priv->width -
2717                                              allocation->width, 0));
2718               tree_view->priv->init_hadjust_value = FALSE;
2719             }
2720           else if (allocation->width != old_width)
2721             {
2722               gtk_adjustment_set_value (tree_view->priv->hadjustment,
2723                                         CLAMP (gtk_adjustment_get_value (tree_view->priv->hadjustment) - allocation->width + old_width,
2724                                                0,
2725                                                tree_view->priv->width - allocation->width));
2726             }
2727           else
2728             gtk_adjustment_set_value (tree_view->priv->hadjustment,
2729                                       CLAMP (tree_view->priv->width - (tree_view->priv->prev_width - gtk_adjustment_get_value (tree_view->priv->hadjustment)),
2730                                              0,
2731                                              tree_view->priv->width - allocation->width));
2732         }
2733       else
2734         {
2735           gtk_adjustment_set_value (tree_view->priv->hadjustment, 0);
2736           tree_view->priv->init_hadjust_value = TRUE;
2737         }
2738     }
2739   else
2740     if (gtk_adjustment_get_value (tree_view->priv->hadjustment) + allocation->width > tree_view->priv->width)
2741       gtk_adjustment_set_value (tree_view->priv->hadjustment,
2742                                 MAX (tree_view->priv->width -
2743                                      allocation->width, 0));
2744
2745   g_object_freeze_notify (G_OBJECT (tree_view->priv->vadjustment));
2746   gtk_adjustment_set_page_size (tree_view->priv->vadjustment,
2747                                 allocation->height -
2748                                 gtk_tree_view_get_effective_header_height (tree_view));
2749   gtk_adjustment_set_step_increment (tree_view->priv->vadjustment,
2750                                      gtk_adjustment_get_page_size (tree_view->priv->vadjustment) * 0.1);
2751   gtk_adjustment_set_page_increment (tree_view->priv->vadjustment,
2752                                      gtk_adjustment_get_page_size (tree_view->priv->vadjustment) * 0.9);
2753   gtk_adjustment_set_lower (tree_view->priv->vadjustment, 0);
2754   gtk_adjustment_set_upper (tree_view->priv->vadjustment,
2755                             MAX (gtk_adjustment_get_page_size (tree_view->priv->vadjustment),
2756                                  tree_view->priv->height));
2757   g_object_thaw_notify (G_OBJECT (tree_view->priv->vadjustment));
2758
2759   /* now the adjustments and window sizes are in sync, we can sync toprow/dy again */
2760   if (tree_view->priv->height <= gtk_adjustment_get_page_size (tree_view->priv->vadjustment))
2761     gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment), 0);
2762   else if (gtk_adjustment_get_value (tree_view->priv->vadjustment) + gtk_adjustment_get_page_size (tree_view->priv->vadjustment) > tree_view->priv->height)
2763     gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment),
2764                               tree_view->priv->height - gtk_adjustment_get_page_size (tree_view->priv->vadjustment));
2765   else if (gtk_tree_row_reference_valid (tree_view->priv->top_row))
2766     gtk_tree_view_top_row_to_dy (tree_view);
2767   else
2768     gtk_tree_view_dy_to_top_row (tree_view);
2769
2770   if (gtk_widget_get_realized (widget))
2771     {
2772       gdk_window_move_resize (gtk_widget_get_window (widget),
2773                               allocation->x, allocation->y,
2774                               allocation->width, allocation->height);
2775       gdk_window_move_resize (tree_view->priv->header_window,
2776                               - (gint) gtk_adjustment_get_value (tree_view->priv->hadjustment),
2777                               0,
2778                               MAX (tree_view->priv->width, allocation->width),
2779                               tree_view->priv->header_height);
2780       gdk_window_move_resize (tree_view->priv->bin_window,
2781                               - (gint) gtk_adjustment_get_value (tree_view->priv->hadjustment),
2782                               gtk_tree_view_get_effective_header_height (tree_view),
2783                               MAX (tree_view->priv->width, allocation->width),
2784                               allocation->height - gtk_tree_view_get_effective_header_height (tree_view));
2785
2786       if (tree_view->priv->tree == NULL)
2787         invalidate_empty_focus (tree_view);
2788
2789       if (width_changed && tree_view->priv->expander_column)
2790         {
2791           /* Might seem awkward, but is the best heuristic I could come up
2792            * with.  Only if the width of the columns before the expander
2793            * changes, we will update the prelight status.  It is this
2794            * width that makes the expander move vertically.  Always updating
2795            * prelight status causes trouble with hover selections.
2796            */
2797           gint width_before_expander;
2798
2799           width_before_expander = gtk_tree_view_calculate_width_before_expander (tree_view);
2800
2801           if (tree_view->priv->prev_width_before_expander
2802               != width_before_expander)
2803               update_prelight (tree_view,
2804                                tree_view->priv->event_last_x,
2805                                tree_view->priv->event_last_y);
2806
2807           tree_view->priv->prev_width_before_expander = width_before_expander;
2808         }
2809     }
2810 }
2811
2812 /* Grabs the focus and unsets the GTK_TREE_VIEW_DRAW_KEYFOCUS flag */
2813 static void
2814 grab_focus_and_unset_draw_keyfocus (GtkTreeView *tree_view)
2815 {
2816   GtkWidget *widget = GTK_WIDGET (tree_view);
2817
2818   if (gtk_widget_get_can_focus (widget) && !gtk_widget_has_focus (widget))
2819     gtk_widget_grab_focus (widget);
2820   tree_view->priv->draw_keyfocus = 0;
2821 }
2822
2823 static inline gboolean
2824 row_is_separator (GtkTreeView *tree_view,
2825                   GtkTreeIter *iter,
2826                   GtkTreePath *path)
2827 {
2828   gboolean is_separator = FALSE;
2829
2830   if (tree_view->priv->row_separator_func)
2831     {
2832       GtkTreeIter tmpiter;
2833
2834       if (iter)
2835         tmpiter = *iter;
2836       else
2837         {
2838           if (!gtk_tree_model_get_iter (tree_view->priv->model, &tmpiter, path))
2839             return FALSE;
2840         }
2841
2842       is_separator = tree_view->priv->row_separator_func (tree_view->priv->model,
2843                                                           &tmpiter,
2844                                                           tree_view->priv->row_separator_data);
2845     }
2846
2847   return is_separator;
2848 }
2849
2850 static gboolean
2851 gtk_tree_view_button_press (GtkWidget      *widget,
2852                             GdkEventButton *event)
2853 {
2854   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
2855   GList *list;
2856   GtkTreeViewColumn *column = NULL;
2857   gint i;
2858   GdkRectangle background_area;
2859   GdkRectangle cell_area;
2860   gint vertical_separator;
2861   gint horizontal_separator;
2862   gboolean path_is_selectable;
2863   gboolean rtl;
2864
2865   rtl = (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL);
2866   gtk_tree_view_stop_editing (tree_view, FALSE);
2867   gtk_widget_style_get (widget,
2868                         "vertical-separator", &vertical_separator,
2869                         "horizontal-separator", &horizontal_separator,
2870                         NULL);
2871
2872   /* Because grab_focus can cause reentrancy, we delay grab_focus until after
2873    * we're done handling the button press.
2874    */
2875
2876   if (event->window == tree_view->priv->bin_window)
2877     {
2878       GtkRBNode *node;
2879       GtkRBTree *tree;
2880       GtkTreePath *path;
2881       gint depth;
2882       gint new_y;
2883       gint y_offset;
2884       gint dval;
2885       gint pre_val, aft_val;
2886       GtkTreeViewColumn *column = NULL;
2887       gint column_handled_click = FALSE;
2888       gboolean row_double_click = FALSE;
2889       gboolean rtl;
2890       gboolean node_selected;
2891       GdkModifierType extend_mod_mask;
2892       GdkModifierType modify_mod_mask;
2893
2894       /* Empty tree? */
2895       if (tree_view->priv->tree == NULL)
2896         {
2897           grab_focus_and_unset_draw_keyfocus (tree_view);
2898           return TRUE;
2899         }
2900
2901       /* are we in an arrow? */
2902       if (tree_view->priv->prelight_node &&
2903           tree_view->priv->arrow_prelit &&
2904           gtk_tree_view_draw_expanders (tree_view))
2905         {
2906           if (event->button == 1)
2907             {
2908               gtk_grab_add (widget);
2909               tree_view->priv->button_pressed_node = tree_view->priv->prelight_node;
2910               tree_view->priv->button_pressed_tree = tree_view->priv->prelight_tree;
2911               gtk_tree_view_queue_draw_arrow (GTK_TREE_VIEW (widget),
2912                                               tree_view->priv->prelight_tree,
2913                                               tree_view->priv->prelight_node);
2914             }
2915
2916           grab_focus_and_unset_draw_keyfocus (tree_view);
2917           return TRUE;
2918         }
2919
2920       /* find the node that was clicked */
2921       new_y = TREE_WINDOW_Y_TO_RBTREE_Y(tree_view, event->y);
2922       if (new_y < 0)
2923         new_y = 0;
2924       y_offset = -_gtk_rbtree_find_offset (tree_view->priv->tree, new_y, &tree, &node);
2925
2926       if (node == NULL)
2927         {
2928           /* We clicked in dead space */
2929           grab_focus_and_unset_draw_keyfocus (tree_view);
2930           return TRUE;
2931         }
2932
2933       /* Get the path and the node */
2934       path = _gtk_tree_view_find_path (tree_view, tree, node);
2935       path_is_selectable = !row_is_separator (tree_view, NULL, path);
2936
2937       if (!path_is_selectable)
2938         {
2939           gtk_tree_path_free (path);
2940           grab_focus_and_unset_draw_keyfocus (tree_view);
2941           return TRUE;
2942         }
2943
2944       depth = gtk_tree_path_get_depth (path);
2945       background_area.y = y_offset + event->y;
2946       background_area.height = gtk_tree_view_get_row_height (tree_view, node);
2947       background_area.x = 0;
2948
2949
2950       /* Let the column have a chance at selecting it. */
2951       rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
2952       for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
2953            list; list = (rtl ? list->prev : list->next))
2954         {
2955           GtkTreeViewColumn *candidate = list->data;
2956
2957           if (!gtk_tree_view_column_get_visible (candidate))
2958             continue;
2959
2960           background_area.width = gtk_tree_view_column_get_width (candidate);
2961           if ((background_area.x > (gint) event->x) ||
2962               (background_area.x + background_area.width <= (gint) event->x))
2963             {
2964               background_area.x += background_area.width;
2965               continue;
2966             }
2967
2968           /* we found the focus column */
2969           column = candidate;
2970           cell_area = background_area;
2971           cell_area.width -= horizontal_separator;
2972           cell_area.height -= vertical_separator;
2973           cell_area.x += horizontal_separator/2;
2974           cell_area.y += vertical_separator/2;
2975           if (gtk_tree_view_is_expander_column (tree_view, column))
2976             {
2977               if (!rtl)
2978                 cell_area.x += (depth - 1) * tree_view->priv->level_indentation;
2979               cell_area.width -= (depth - 1) * tree_view->priv->level_indentation;
2980
2981               if (gtk_tree_view_draw_expanders (tree_view))
2982                 {
2983                   if (!rtl)
2984                     cell_area.x += depth * tree_view->priv->expander_size;
2985                   cell_area.width -= depth * tree_view->priv->expander_size;
2986                 }
2987             }
2988           break;
2989         }
2990
2991       if (column == NULL)
2992         {
2993           gtk_tree_path_free (path);
2994           grab_focus_and_unset_draw_keyfocus (tree_view);
2995           return FALSE;
2996         }
2997
2998       tree_view->priv->focus_column = column;
2999
3000       /* decide if we edit */
3001       if (event->type == GDK_BUTTON_PRESS && event->button == 1 &&
3002           !(event->state & gtk_accelerator_get_default_mod_mask ()))
3003         {
3004           GtkTreePath *anchor;
3005           GtkTreeIter iter;
3006
3007           gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
3008           gtk_tree_view_column_cell_set_cell_data (column,
3009                                                    tree_view->priv->model,
3010                                                    &iter,
3011                                                    GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT),
3012                                                    node->children?TRUE:FALSE);
3013
3014           if (tree_view->priv->anchor)
3015             anchor = gtk_tree_row_reference_get_path (tree_view->priv->anchor);
3016           else
3017             anchor = NULL;
3018
3019           if ((anchor && !gtk_tree_path_compare (anchor, path))
3020               || !_gtk_tree_view_column_has_editable_cell (column))
3021             {
3022               GtkCellEditable *cell_editable = NULL;
3023
3024               /* FIXME: get the right flags */
3025               guint flags = 0;
3026
3027               if (_gtk_tree_view_column_cell_event (column,
3028                                                     (GdkEvent *)event,
3029                                                     &cell_area, flags))
3030                 {
3031                   GtkCellArea *area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (column));
3032                   cell_editable = gtk_cell_area_get_edit_widget (area);
3033
3034                   if (cell_editable != NULL)
3035                     {
3036                       gtk_tree_path_free (path);
3037                       gtk_tree_path_free (anchor);
3038                       return TRUE;
3039                     }
3040                   column_handled_click = TRUE;
3041                 }
3042             }
3043           if (anchor)
3044             gtk_tree_path_free (anchor);
3045         }
3046
3047       extend_mod_mask =
3048         gtk_widget_get_modifier_mask (widget, GDK_MODIFIER_INTENT_EXTEND_SELECTION);
3049
3050       modify_mod_mask =
3051         gtk_widget_get_modifier_mask (widget, GDK_MODIFIER_INTENT_MODIFY_SELECTION);
3052
3053       /* select */
3054       node_selected = GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED);
3055       pre_val = gtk_adjustment_get_value (tree_view->priv->vadjustment);
3056
3057       /* we only handle selection modifications on the first button press
3058        */
3059       if (event->type == GDK_BUTTON_PRESS)
3060         {
3061           GtkCellRenderer *focus_cell;
3062
3063           if ((event->state & modify_mod_mask) == modify_mod_mask)
3064             tree_view->priv->modify_selection_pressed = TRUE;
3065           if ((event->state & extend_mod_mask) == extend_mod_mask)
3066             tree_view->priv->extend_selection_pressed = TRUE;
3067
3068           /* We update the focus cell here, this is also needed if the
3069            * column does not contain an editable cell.  In this case,
3070            * GtkCellArea did not receive the event for processing (and
3071            * could not update the focus cell).
3072            */
3073           focus_cell = _gtk_tree_view_column_get_cell_at_pos (column,
3074                                                               &cell_area,
3075                                                               &background_area,
3076                                                               event->x,
3077                                                               event->y);
3078
3079           if (focus_cell)
3080             gtk_tree_view_column_focus_cell (column, focus_cell);
3081
3082           if (event->state & modify_mod_mask)
3083             {
3084               gtk_tree_view_real_set_cursor (tree_view, path, FALSE, TRUE);
3085               gtk_tree_view_real_toggle_cursor_row (tree_view);
3086             }
3087           else if (event->state & extend_mod_mask)
3088             {
3089               gtk_tree_view_real_set_cursor (tree_view, path, FALSE, TRUE);
3090               gtk_tree_view_real_select_cursor_row (tree_view, FALSE);
3091             }
3092           else
3093             {
3094               gtk_tree_view_real_set_cursor (tree_view, path, TRUE, TRUE);
3095             }
3096
3097           tree_view->priv->modify_selection_pressed = FALSE;
3098           tree_view->priv->extend_selection_pressed = FALSE;
3099         }
3100
3101       /* the treeview may have been scrolled because of _set_cursor,
3102        * correct here
3103        */
3104
3105       aft_val = gtk_adjustment_get_value (tree_view->priv->vadjustment);
3106       dval = pre_val - aft_val;
3107
3108       cell_area.y += dval;
3109       background_area.y += dval;
3110
3111       /* Save press to possibly begin a drag
3112        */
3113       if (!column_handled_click &&
3114           !tree_view->priv->in_grab &&
3115           tree_view->priv->pressed_button < 0)
3116         {
3117           tree_view->priv->pressed_button = event->button;
3118           tree_view->priv->press_start_x = event->x;
3119           tree_view->priv->press_start_y = event->y;
3120
3121           if (tree_view->priv->rubber_banding_enable
3122               && !node_selected
3123               && gtk_tree_selection_get_mode (tree_view->priv->selection) == GTK_SELECTION_MULTIPLE)
3124             {
3125               tree_view->priv->press_start_y += tree_view->priv->dy;
3126               tree_view->priv->rubber_band_x = event->x;
3127               tree_view->priv->rubber_band_y = event->y + tree_view->priv->dy;
3128               tree_view->priv->rubber_band_status = RUBBER_BAND_MAYBE_START;
3129
3130               if ((event->state & modify_mod_mask) == modify_mod_mask)
3131                 tree_view->priv->rubber_band_modify = TRUE;
3132               if ((event->state & extend_mod_mask) == extend_mod_mask)
3133                 tree_view->priv->rubber_band_extend = TRUE;
3134             }
3135         }
3136
3137       /* Test if a double click happened on the same row. */
3138       if (event->button == 1 && event->type == GDK_BUTTON_PRESS)
3139         {
3140           int double_click_time, double_click_distance;
3141
3142           g_object_get (gtk_settings_get_default (),
3143                         "gtk-double-click-time", &double_click_time,
3144                         "gtk-double-click-distance", &double_click_distance,
3145                         NULL);
3146
3147           /* Same conditions as _gdk_event_button_generate */
3148           if (tree_view->priv->last_button_x != -1 &&
3149               (event->time < tree_view->priv->last_button_time + double_click_time) &&
3150               (ABS (event->x - tree_view->priv->last_button_x) <= double_click_distance) &&
3151               (ABS (event->y - tree_view->priv->last_button_y) <= double_click_distance))
3152             {
3153               /* We do no longer compare paths of this row and the
3154                * row clicked previously.  We use the double click
3155                * distance to decide whether this is a valid click,
3156                * allowing the mouse to slightly move over another row.
3157                */
3158               row_double_click = TRUE;
3159
3160               tree_view->priv->last_button_time = 0;
3161               tree_view->priv->last_button_x = -1;
3162               tree_view->priv->last_button_y = -1;
3163             }
3164           else
3165             {
3166               tree_view->priv->last_button_time = event->time;
3167               tree_view->priv->last_button_x = event->x;
3168               tree_view->priv->last_button_y = event->y;
3169             }
3170         }
3171
3172       if (row_double_click)
3173         {
3174           gtk_grab_remove (widget);
3175           gtk_tree_view_row_activated (tree_view, path, column);
3176
3177           if (tree_view->priv->pressed_button == event->button)
3178             tree_view->priv->pressed_button = -1;
3179         }
3180
3181       gtk_tree_path_free (path);
3182
3183       /* If we activated the row through a double click we don't want to grab
3184        * focus back, as moving focus to another widget is pretty common.
3185        */
3186       if (!row_double_click)
3187         grab_focus_and_unset_draw_keyfocus (tree_view);
3188
3189       return TRUE;
3190     }
3191
3192   /* We didn't click in the window.  Let's check to see if we clicked on a column resize window.
3193    */
3194   for (i = 0, list = tree_view->priv->columns; list; list = list->next, i++)
3195     {
3196       column = list->data;
3197       if (event->window == _gtk_tree_view_column_get_window (column) &&
3198           gtk_tree_view_column_get_resizable (column) &&
3199           _gtk_tree_view_column_get_window (column))
3200         {
3201           gpointer drag_data;
3202
3203           if (event->type == GDK_2BUTTON_PRESS &&
3204               gtk_tree_view_column_get_sizing (column) != GTK_TREE_VIEW_COLUMN_AUTOSIZE)
3205             {
3206               _gtk_tree_view_column_set_use_resized_width (column, FALSE);
3207               _gtk_tree_view_column_autosize (tree_view, column);
3208               return TRUE;
3209             }
3210
3211           if (gdk_device_grab (gdk_event_get_device ((GdkEvent*)event),
3212                                _gtk_tree_view_column_get_window (column),
3213                                GDK_OWNERSHIP_NONE,
3214                                FALSE,
3215                                GDK_POINTER_MOTION_HINT_MASK
3216                                 | GDK_BUTTON1_MOTION_MASK
3217                                 | GDK_BUTTON_RELEASE_MASK,
3218                                NULL,
3219                                event->time) != GDK_GRAB_SUCCESS)
3220             return FALSE;
3221
3222           gtk_grab_add (widget);
3223           tree_view->priv->in_column_resize = TRUE;
3224
3225           _gtk_tree_view_column_set_resized_width (column, gtk_tree_view_column_get_width (column) -
3226                                                    tree_view->priv->last_extra_space_per_column);
3227
3228           /* block attached dnd signal handler */
3229           drag_data = g_object_get_data (G_OBJECT (widget), "gtk-site-data");
3230           if (drag_data)
3231             g_signal_handlers_block_matched (widget,
3232                                              G_SIGNAL_MATCH_DATA,
3233                                              0, 0, NULL, NULL,
3234                                              drag_data);
3235
3236           tree_view->priv->drag_pos = i;
3237           tree_view->priv->x_drag = gtk_tree_view_column_get_x_offset (column) + (rtl ? 0 : gtk_tree_view_column_get_width (column));
3238
3239           if (!gtk_widget_has_focus (widget))
3240             gtk_widget_grab_focus (widget);
3241
3242           return TRUE;
3243         }
3244     }
3245   return FALSE;
3246 }
3247
3248 /* GtkWidget::button_release_event helper */
3249 static gboolean
3250 gtk_tree_view_button_release_drag_column (GtkWidget      *widget,
3251                                           GdkEventButton *event)
3252 {
3253   GtkTreeView *tree_view;
3254   GtkWidget *button;
3255   GList *l;
3256   gboolean rtl;
3257   GdkDevice *device, *other;
3258
3259   tree_view = GTK_TREE_VIEW (widget);
3260
3261   rtl = (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL);
3262   device = gdk_event_get_device ((GdkEvent*)event);
3263   other = gdk_device_get_associated_device (device);
3264   gdk_device_ungrab (device, event->time);
3265   gdk_device_ungrab (other, event->time);
3266
3267   /* Move the button back */
3268   button = gtk_tree_view_column_get_button (tree_view->priv->drag_column);
3269   g_object_ref (button);
3270   gtk_container_remove (GTK_CONTAINER (tree_view), button);
3271   gtk_widget_set_parent_window (button, tree_view->priv->header_window);
3272   gtk_widget_set_parent (button, GTK_WIDGET (tree_view));
3273   g_object_unref (button);
3274   gtk_widget_queue_resize (widget);
3275   if (gtk_tree_view_column_get_resizable (tree_view->priv->drag_column))
3276     {
3277       gdk_window_raise (_gtk_tree_view_column_get_window (tree_view->priv->drag_column));
3278       gdk_window_show (_gtk_tree_view_column_get_window (tree_view->priv->drag_column));
3279     }
3280   else
3281     gdk_window_hide (_gtk_tree_view_column_get_window (tree_view->priv->drag_column));
3282
3283   gtk_widget_grab_focus (button);
3284
3285   if (rtl)
3286     {
3287       if (tree_view->priv->cur_reorder &&
3288           tree_view->priv->cur_reorder->right_column != tree_view->priv->drag_column)
3289         gtk_tree_view_move_column_after (tree_view, tree_view->priv->drag_column,
3290                                          tree_view->priv->cur_reorder->right_column);
3291     }
3292   else
3293     {
3294       if (tree_view->priv->cur_reorder &&
3295           tree_view->priv->cur_reorder->left_column != tree_view->priv->drag_column)
3296         gtk_tree_view_move_column_after (tree_view, tree_view->priv->drag_column,
3297                                          tree_view->priv->cur_reorder->left_column);
3298     }
3299   tree_view->priv->drag_column = NULL;
3300   gdk_window_hide (tree_view->priv->drag_window);
3301
3302   for (l = tree_view->priv->column_drag_info; l != NULL; l = l->next)
3303     g_slice_free (GtkTreeViewColumnReorder, l->data);
3304   g_list_free (tree_view->priv->column_drag_info);
3305   tree_view->priv->column_drag_info = NULL;
3306   tree_view->priv->cur_reorder = NULL;
3307
3308   if (tree_view->priv->drag_highlight_window)
3309     gdk_window_hide (tree_view->priv->drag_highlight_window);
3310
3311   /* Reset our flags */
3312   tree_view->priv->drag_column_window_state = DRAG_COLUMN_WINDOW_STATE_UNSET;
3313   tree_view->priv->in_column_drag = FALSE;
3314
3315   return TRUE;
3316 }
3317
3318 /* GtkWidget::button_release_event helper */
3319 static gboolean
3320 gtk_tree_view_button_release_column_resize (GtkWidget      *widget,
3321                                             GdkEventButton *event)
3322 {
3323   GtkTreeView *tree_view;
3324   gpointer drag_data;
3325
3326   tree_view = GTK_TREE_VIEW (widget);
3327
3328   tree_view->priv->drag_pos = -1;
3329
3330   /* unblock attached dnd signal handler */
3331   drag_data = g_object_get_data (G_OBJECT (widget), "gtk-site-data");
3332   if (drag_data)
3333     g_signal_handlers_unblock_matched (widget,
3334                                        G_SIGNAL_MATCH_DATA,
3335                                        0, 0, NULL, NULL,
3336                                        drag_data);
3337
3338   tree_view->priv->in_column_resize = FALSE;
3339   gtk_grab_remove (widget);
3340   gdk_device_ungrab (gdk_event_get_device ((GdkEvent*)event), event->time);
3341   return TRUE;
3342 }
3343
3344 static gboolean
3345 gtk_tree_view_button_release (GtkWidget      *widget,
3346                               GdkEventButton *event)
3347 {
3348   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
3349
3350   if (tree_view->priv->in_column_drag)
3351     return gtk_tree_view_button_release_drag_column (widget, event);
3352
3353   if (tree_view->priv->rubber_band_status)
3354     gtk_tree_view_stop_rubber_band (tree_view);
3355
3356   if (tree_view->priv->pressed_button == event->button)
3357     tree_view->priv->pressed_button = -1;
3358
3359   if (tree_view->priv->in_column_resize)
3360     return gtk_tree_view_button_release_column_resize (widget, event);
3361
3362   if (tree_view->priv->button_pressed_node == NULL)
3363     return FALSE;
3364
3365   if (event->button == 1)
3366     {
3367       if (tree_view->priv->button_pressed_node == tree_view->priv->prelight_node &&
3368           tree_view->priv->arrow_prelit)
3369         {
3370           GtkTreePath *path = NULL;
3371
3372           path = _gtk_tree_view_find_path (tree_view,
3373                                            tree_view->priv->button_pressed_tree,
3374                                            tree_view->priv->button_pressed_node);
3375           /* Actually activate the node */
3376           if (tree_view->priv->button_pressed_node->children == NULL)
3377             gtk_tree_view_real_expand_row (tree_view, path,
3378                                            tree_view->priv->button_pressed_tree,
3379                                            tree_view->priv->button_pressed_node,
3380                                            FALSE, TRUE);
3381           else
3382             gtk_tree_view_real_collapse_row (GTK_TREE_VIEW (widget), path,
3383                                              tree_view->priv->button_pressed_tree,
3384                                              tree_view->priv->button_pressed_node, TRUE);
3385           gtk_tree_path_free (path);
3386         }
3387
3388       gtk_grab_remove (widget);
3389       tree_view->priv->button_pressed_tree = NULL;
3390       tree_view->priv->button_pressed_node = NULL;
3391     }
3392
3393   return TRUE;
3394 }
3395
3396 static gboolean
3397 gtk_tree_view_grab_broken (GtkWidget          *widget,
3398                            GdkEventGrabBroken *event)
3399 {
3400   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
3401
3402   if (tree_view->priv->in_column_drag)
3403     gtk_tree_view_button_release_drag_column (widget, (GdkEventButton *)event);
3404
3405   if (tree_view->priv->in_column_resize)
3406     gtk_tree_view_button_release_column_resize (widget, (GdkEventButton *)event);
3407
3408   return TRUE;
3409 }
3410
3411 #if 0
3412 static gboolean
3413 gtk_tree_view_configure (GtkWidget *widget,
3414                          GdkEventConfigure *event)
3415 {
3416   GtkTreeView *tree_view;
3417
3418   tree_view = GTK_TREE_VIEW (widget);
3419   tree_view->priv->search_position_func (tree_view, tree_view->priv->search_window);
3420
3421   return FALSE;
3422 }
3423 #endif
3424
3425 /* GtkWidget::motion_event function set.
3426  */
3427
3428 static gboolean
3429 coords_are_over_arrow (GtkTreeView *tree_view,
3430                        GtkRBTree   *tree,
3431                        GtkRBNode   *node,
3432                        /* these are in bin window coords */
3433                        gint         x,
3434                        gint         y)
3435 {
3436   GdkRectangle arrow;
3437   gint x2;
3438
3439   if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
3440     return FALSE;
3441
3442   if ((node->flags & GTK_RBNODE_IS_PARENT) == 0)
3443     return FALSE;
3444
3445   arrow.y = gtk_tree_view_get_row_y_offset (tree_view, tree, node);
3446   arrow.height = gtk_tree_view_get_row_height (tree_view, node);
3447
3448   gtk_tree_view_get_arrow_xrange (tree_view, tree, &arrow.x, &x2);
3449
3450   arrow.width = x2 - arrow.x;
3451
3452   return (x >= arrow.x &&
3453           x < (arrow.x + arrow.width) &&
3454           y >= arrow.y &&
3455           y < (arrow.y + arrow.height));
3456 }
3457
3458 static gboolean
3459 auto_expand_timeout (gpointer data)
3460 {
3461   GtkTreeView *tree_view = GTK_TREE_VIEW (data);
3462   GtkTreePath *path;
3463
3464   if (tree_view->priv->prelight_node)
3465     {
3466       path = _gtk_tree_view_find_path (tree_view,
3467                                        tree_view->priv->prelight_tree,
3468                                        tree_view->priv->prelight_node);
3469
3470       if (tree_view->priv->prelight_node->children)
3471         gtk_tree_view_collapse_row (tree_view, path);
3472       else
3473         gtk_tree_view_expand_row (tree_view, path, FALSE);
3474
3475       gtk_tree_path_free (path);
3476     }
3477
3478   tree_view->priv->auto_expand_timeout = 0;
3479
3480   return FALSE;
3481 }
3482
3483 static void
3484 remove_auto_expand_timeout (GtkTreeView *tree_view)
3485 {
3486   if (tree_view->priv->auto_expand_timeout != 0)
3487     {
3488       g_source_remove (tree_view->priv->auto_expand_timeout);
3489       tree_view->priv->auto_expand_timeout = 0;
3490     }
3491 }
3492
3493 static void
3494 do_prelight (GtkTreeView *tree_view,
3495              GtkRBTree   *tree,
3496              GtkRBNode   *node,
3497              /* these are in bin_window coords */
3498              gint         x,
3499              gint         y)
3500 {
3501   if (tree_view->priv->prelight_tree == tree &&
3502       tree_view->priv->prelight_node == node)
3503     {
3504       /*  We are still on the same node,
3505           but we might need to take care of the arrow  */
3506
3507       if (tree && node && gtk_tree_view_draw_expanders (tree_view))
3508         {
3509           gboolean over_arrow;
3510
3511           over_arrow = coords_are_over_arrow (tree_view, tree, node, x, y);
3512
3513           if (over_arrow != tree_view->priv->arrow_prelit)
3514             {
3515               if (over_arrow)
3516                 tree_view->priv->arrow_prelit = TRUE;
3517               else
3518                 tree_view->priv->arrow_prelit = FALSE;
3519
3520               gtk_tree_view_queue_draw_arrow (tree_view, tree, node);
3521             }
3522         }
3523
3524       return;
3525     }
3526
3527   if (tree_view->priv->prelight_tree && tree_view->priv->prelight_node)
3528     {
3529       /*  Unprelight the old node and arrow  */
3530
3531       GTK_RBNODE_UNSET_FLAG (tree_view->priv->prelight_node,
3532                              GTK_RBNODE_IS_PRELIT);
3533
3534       if (tree_view->priv->arrow_prelit
3535           && gtk_tree_view_draw_expanders (tree_view))
3536         {
3537           tree_view->priv->arrow_prelit = FALSE;
3538
3539           gtk_tree_view_queue_draw_arrow (tree_view,
3540                                           tree_view->priv->prelight_tree,
3541                                           tree_view->priv->prelight_node);
3542         }
3543
3544       _gtk_tree_view_queue_draw_node (tree_view,
3545                                       tree_view->priv->prelight_tree,
3546                                       tree_view->priv->prelight_node,
3547                                       NULL);
3548     }
3549
3550
3551   if (tree_view->priv->hover_expand)
3552     remove_auto_expand_timeout (tree_view);
3553
3554   /*  Set the new prelight values  */
3555   tree_view->priv->prelight_node = node;
3556   tree_view->priv->prelight_tree = tree;
3557
3558   if (!node || !tree)
3559     return;
3560
3561   /*  Prelight the new node and arrow  */
3562
3563   if (gtk_tree_view_draw_expanders (tree_view)
3564       && coords_are_over_arrow (tree_view, tree, node, x, y))
3565     {
3566       tree_view->priv->arrow_prelit = TRUE;
3567
3568       gtk_tree_view_queue_draw_arrow (tree_view, tree, node);
3569     }
3570
3571   GTK_RBNODE_SET_FLAG (node, GTK_RBNODE_IS_PRELIT);
3572
3573   _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
3574
3575   if (tree_view->priv->hover_expand)
3576     {
3577       tree_view->priv->auto_expand_timeout =
3578         gdk_threads_add_timeout (AUTO_EXPAND_TIMEOUT, auto_expand_timeout, tree_view);
3579     }
3580 }
3581
3582 static void
3583 prelight_or_select (GtkTreeView *tree_view,
3584                     GtkRBTree   *tree,
3585                     GtkRBNode   *node,
3586                     /* these are in bin_window coords */
3587                     gint         x,
3588                     gint         y)
3589 {
3590   GtkSelectionMode mode = gtk_tree_selection_get_mode (tree_view->priv->selection);
3591
3592   if (tree_view->priv->hover_selection &&
3593       (mode == GTK_SELECTION_SINGLE || mode == GTK_SELECTION_BROWSE) &&
3594       !(tree_view->priv->edited_column &&
3595         gtk_cell_area_get_edit_widget
3596         (gtk_cell_layout_get_area (GTK_CELL_LAYOUT (tree_view->priv->edited_column)))))
3597     {
3598       if (node)
3599         {
3600           if (!GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
3601             {
3602               GtkTreePath *path;
3603
3604               path = _gtk_tree_view_find_path (tree_view, tree, node);
3605               gtk_tree_selection_select_path (tree_view->priv->selection, path);
3606               if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
3607                 {
3608                   tree_view->priv->draw_keyfocus = FALSE;
3609                   gtk_tree_view_real_set_cursor (tree_view, path, FALSE, FALSE);
3610                 }
3611               gtk_tree_path_free (path);
3612             }
3613         }
3614
3615       else if (mode == GTK_SELECTION_SINGLE)
3616         gtk_tree_selection_unselect_all (tree_view->priv->selection);
3617     }
3618
3619     do_prelight (tree_view, tree, node, x, y);
3620 }
3621
3622 static void
3623 ensure_unprelighted (GtkTreeView *tree_view)
3624 {
3625   do_prelight (tree_view,
3626                NULL, NULL,
3627                -1000, -1000); /* coords not possibly over an arrow */
3628
3629   g_assert (tree_view->priv->prelight_node == NULL);
3630 }
3631
3632 static void
3633 update_prelight (GtkTreeView *tree_view,
3634                  gint         x,
3635                  gint         y)
3636 {
3637   int new_y;
3638   GtkRBTree *tree;
3639   GtkRBNode *node;
3640
3641   if (tree_view->priv->tree == NULL)
3642     return;
3643
3644   if (x == -10000)
3645     {
3646       ensure_unprelighted (tree_view);
3647       return;
3648     }
3649
3650   new_y = TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, y);
3651   if (new_y < 0)
3652     new_y = 0;
3653
3654   _gtk_rbtree_find_offset (tree_view->priv->tree,
3655                            new_y, &tree, &node);
3656
3657   if (node)
3658     prelight_or_select (tree_view, tree, node, x, y);
3659 }
3660
3661
3662
3663
3664 /* Our motion arrow is either a box (in the case of the original spot)
3665  * or an arrow.  It is expander_size wide.
3666  */
3667 /*
3668  * 11111111111111
3669  * 01111111111110
3670  * 00111111111100
3671  * 00011111111000
3672  * 00001111110000
3673  * 00000111100000
3674  * 00000111100000
3675  * 00000111100000
3676  * ~ ~ ~ ~ ~ ~ ~
3677  * 00000111100000
3678  * 00000111100000
3679  * 00000111100000
3680  * 00001111110000
3681  * 00011111111000
3682  * 00111111111100
3683  * 01111111111110
3684  * 11111111111111
3685  */
3686
3687 static void
3688 gtk_tree_view_motion_draw_column_motion_arrow (GtkTreeView *tree_view)
3689 {
3690   GtkTreeViewColumnReorder *reorder = tree_view->priv->cur_reorder;
3691   GtkWidget *widget = GTK_WIDGET (tree_view);
3692   cairo_surface_t *mask_image;
3693   cairo_region_t *mask_region;
3694   gint x;
3695   gint y;
3696   gint width;
3697   gint height;
3698   gint arrow_type = DRAG_COLUMN_WINDOW_STATE_UNSET;
3699   GdkWindowAttr attributes;
3700   guint attributes_mask;
3701   cairo_t *cr;
3702
3703   if (!reorder ||
3704       reorder->left_column == tree_view->priv->drag_column ||
3705       reorder->right_column == tree_view->priv->drag_column)
3706     arrow_type = DRAG_COLUMN_WINDOW_STATE_ORIGINAL;
3707   else if (reorder->left_column || reorder->right_column)
3708     {
3709       GtkAllocation left_allocation, right_allocation;
3710       GdkRectangle visible_rect;
3711       GtkWidget *button;
3712
3713       gtk_tree_view_get_visible_rect (tree_view, &visible_rect);
3714       if (reorder->left_column)
3715         {
3716           button = gtk_tree_view_column_get_button (reorder->left_column);
3717           gtk_widget_get_allocation (button, &left_allocation);
3718           x = left_allocation.x + left_allocation.width;
3719         }
3720       else
3721         {
3722           button = gtk_tree_view_column_get_button (reorder->right_column);
3723           gtk_widget_get_allocation (button, &right_allocation);
3724           x = right_allocation.x;
3725         }
3726
3727       if (x < visible_rect.x)
3728         arrow_type = DRAG_COLUMN_WINDOW_STATE_ARROW_LEFT;
3729       else if (x > visible_rect.x + visible_rect.width)
3730         arrow_type = DRAG_COLUMN_WINDOW_STATE_ARROW_RIGHT;
3731       else
3732         arrow_type = DRAG_COLUMN_WINDOW_STATE_ARROW;
3733     }
3734
3735   /* We want to draw the rectangle over the initial location. */
3736   if (arrow_type == DRAG_COLUMN_WINDOW_STATE_ORIGINAL)
3737     {
3738       if (tree_view->priv->drag_column_window_state != DRAG_COLUMN_WINDOW_STATE_ORIGINAL)
3739         {
3740           GtkAllocation drag_allocation;
3741           GtkWidget    *button;
3742
3743           if (tree_view->priv->drag_highlight_window)
3744             {
3745               gdk_window_set_user_data (tree_view->priv->drag_highlight_window,
3746                                         NULL);
3747               gdk_window_destroy (tree_view->priv->drag_highlight_window);
3748             }
3749
3750           button = gtk_tree_view_column_get_button (tree_view->priv->drag_column);
3751           attributes.window_type = GDK_WINDOW_CHILD;
3752           attributes.wclass = GDK_INPUT_OUTPUT;
3753           attributes.x = tree_view->priv->drag_column_x;
3754           attributes.y = 0;
3755           gtk_widget_get_allocation (button, &drag_allocation);
3756           width = attributes.width = drag_allocation.width;
3757           height = attributes.height = drag_allocation.height;
3758           attributes.visual = gtk_widget_get_visual (GTK_WIDGET (tree_view));
3759           attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK;
3760           attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
3761           tree_view->priv->drag_highlight_window = gdk_window_new (tree_view->priv->header_window, &attributes, attributes_mask);
3762           gdk_window_set_user_data (tree_view->priv->drag_highlight_window, GTK_WIDGET (tree_view));
3763
3764           mask_image = cairo_image_surface_create (CAIRO_FORMAT_A1, width, height);
3765           cr = cairo_create (mask_image);
3766
3767           cairo_rectangle (cr, 1, 1, width - 2, height - 2);
3768           cairo_stroke (cr);
3769           cairo_destroy (cr);
3770
3771           mask_region = gdk_cairo_region_create_from_surface (mask_image);
3772           gdk_window_shape_combine_region (tree_view->priv->drag_highlight_window,
3773                                            mask_region, 0, 0);
3774
3775           cairo_region_destroy (mask_region);
3776           cairo_surface_destroy (mask_image);
3777
3778           tree_view->priv->drag_column_window_state = DRAG_COLUMN_WINDOW_STATE_ORIGINAL;
3779         }
3780     }
3781   else if (arrow_type == DRAG_COLUMN_WINDOW_STATE_ARROW)
3782     {
3783       GtkAllocation button_allocation;
3784       GtkWidget    *button;
3785
3786       width = tree_view->priv->expander_size;
3787
3788       /* Get x, y, width, height of arrow */
3789       gdk_window_get_origin (tree_view->priv->header_window, &x, &y);
3790       if (reorder->left_column)
3791         {
3792           button = gtk_tree_view_column_get_button (reorder->left_column);
3793           gtk_widget_get_allocation (button, &button_allocation);
3794           x += button_allocation.x + button_allocation.width - width/2;
3795           height = button_allocation.height;
3796         }
3797       else
3798         {
3799           button = gtk_tree_view_column_get_button (reorder->right_column);
3800           gtk_widget_get_allocation (button, &button_allocation);
3801           x += button_allocation.x - width/2;
3802           height = button_allocation.height;
3803         }
3804       y -= tree_view->priv->expander_size/2; /* The arrow takes up only half the space */
3805       height += tree_view->priv->expander_size;
3806
3807       /* Create the new window */
3808       if (tree_view->priv->drag_column_window_state != DRAG_COLUMN_WINDOW_STATE_ARROW)
3809         {
3810           if (tree_view->priv->drag_highlight_window)
3811             {
3812               gdk_window_set_user_data (tree_view->priv->drag_highlight_window,
3813                                         NULL);
3814               gdk_window_destroy (tree_view->priv->drag_highlight_window);
3815             }
3816
3817           attributes.window_type = GDK_WINDOW_TEMP;
3818           attributes.wclass = GDK_INPUT_OUTPUT;
3819           attributes.visual = gtk_widget_get_visual (GTK_WIDGET (tree_view));
3820           attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK;
3821           attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
3822           attributes.x = x;
3823           attributes.y = y;
3824           attributes.width = width;
3825           attributes.height = height;
3826           tree_view->priv->drag_highlight_window = gdk_window_new (gtk_widget_get_root_window (widget),
3827                                                                    &attributes, attributes_mask);
3828           gdk_window_set_user_data (tree_view->priv->drag_highlight_window, GTK_WIDGET (tree_view));
3829
3830           mask_image = cairo_image_surface_create (CAIRO_FORMAT_A1, width, height);
3831
3832           cr = cairo_create (mask_image);
3833           cairo_move_to (cr, 0, 0);
3834           cairo_line_to (cr, width, 0);
3835           cairo_line_to (cr, width / 2., width / 2);
3836           cairo_move_to (cr, 0, height);
3837           cairo_line_to (cr, width, height);
3838           cairo_line_to (cr, width / 2., height - width / 2.);
3839           cairo_fill (cr);
3840           cairo_destroy (cr);
3841
3842           mask_region = gdk_cairo_region_create_from_surface (mask_image);
3843           gdk_window_shape_combine_region (tree_view->priv->drag_highlight_window,
3844                                            mask_region, 0, 0);
3845
3846           cairo_region_destroy (mask_region);
3847           cairo_surface_destroy (mask_image);
3848         }
3849
3850       tree_view->priv->drag_column_window_state = DRAG_COLUMN_WINDOW_STATE_ARROW;
3851       gdk_window_move (tree_view->priv->drag_highlight_window, x, y);
3852     }
3853   else if (arrow_type == DRAG_COLUMN_WINDOW_STATE_ARROW_LEFT ||
3854            arrow_type == DRAG_COLUMN_WINDOW_STATE_ARROW_RIGHT)
3855     {
3856       GtkAllocation allocation;
3857       GtkWidget    *button;
3858
3859       width = tree_view->priv->expander_size;
3860
3861       /* Get x, y, width, height of arrow */
3862       width = width/2; /* remember, the arrow only takes half the available width */
3863       gdk_window_get_origin (gtk_widget_get_window (widget),
3864                              &x, &y);
3865       if (arrow_type == DRAG_COLUMN_WINDOW_STATE_ARROW_RIGHT)
3866         {
3867           gtk_widget_get_allocation (widget, &allocation);
3868           x += allocation.width - width;
3869         }
3870
3871       if (reorder->left_column)
3872         {
3873           button = gtk_tree_view_column_get_button (reorder->left_column);
3874           gtk_widget_get_allocation (button, &allocation);
3875           height = allocation.height;
3876         }
3877       else
3878         {
3879           button = gtk_tree_view_column_get_button (reorder->right_column);
3880           gtk_widget_get_allocation (button, &allocation);
3881           height = allocation.height;
3882         }
3883
3884       y -= tree_view->priv->expander_size;
3885       height += 2*tree_view->priv->expander_size;
3886
3887       /* Create the new window */
3888       if (tree_view->priv->drag_column_window_state != DRAG_COLUMN_WINDOW_STATE_ARROW_LEFT &&
3889           tree_view->priv->drag_column_window_state != DRAG_COLUMN_WINDOW_STATE_ARROW_RIGHT)
3890         {
3891           if (tree_view->priv->drag_highlight_window)
3892             {
3893               gdk_window_set_user_data (tree_view->priv->drag_highlight_window,
3894                                         NULL);
3895               gdk_window_destroy (tree_view->priv->drag_highlight_window);
3896             }
3897
3898           attributes.window_type = GDK_WINDOW_TEMP;
3899           attributes.wclass = GDK_INPUT_OUTPUT;
3900           attributes.visual = gtk_widget_get_visual (GTK_WIDGET (tree_view));
3901           attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK;
3902           attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
3903           attributes.x = x;
3904           attributes.y = y;
3905           attributes.width = width;
3906           attributes.height = height;
3907           tree_view->priv->drag_highlight_window = gdk_window_new (NULL, &attributes, attributes_mask);
3908           gdk_window_set_user_data (tree_view->priv->drag_highlight_window, GTK_WIDGET (tree_view));
3909
3910           mask_image = cairo_image_surface_create (CAIRO_FORMAT_A1, width, height);
3911
3912           cr = cairo_create (mask_image);
3913           /* mirror if we're on the left */
3914           if (arrow_type == DRAG_COLUMN_WINDOW_STATE_ARROW_LEFT)
3915             {
3916               cairo_translate (cr, width, 0);
3917               cairo_scale (cr, -1, 1);
3918             }
3919           cairo_move_to (cr, 0, 0);
3920           cairo_line_to (cr, width, width);
3921           cairo_line_to (cr, 0, tree_view->priv->expander_size);
3922           cairo_move_to (cr, 0, height);
3923           cairo_line_to (cr, width, height - width);
3924           cairo_line_to (cr, 0, height - tree_view->priv->expander_size);
3925           cairo_fill (cr);
3926           cairo_destroy (cr);
3927
3928           mask_region = gdk_cairo_region_create_from_surface (mask_image);
3929           gdk_window_shape_combine_region (tree_view->priv->drag_highlight_window,
3930                                            mask_region, 0, 0);
3931
3932           cairo_region_destroy (mask_region);
3933           cairo_surface_destroy (mask_image);
3934         }
3935
3936       tree_view->priv->drag_column_window_state = arrow_type;
3937       gdk_window_move (tree_view->priv->drag_highlight_window, x, y);
3938    }
3939   else
3940     {
3941       g_warning (G_STRLOC"Invalid GtkTreeViewColumnReorder struct");
3942       gdk_window_hide (tree_view->priv->drag_highlight_window);
3943       return;
3944     }
3945
3946   gdk_window_show (tree_view->priv->drag_highlight_window);
3947   gdk_window_raise (tree_view->priv->drag_highlight_window);
3948 }
3949
3950 static gboolean
3951 gtk_tree_view_motion_resize_column (GtkWidget      *widget,
3952                                     GdkEventMotion *event)
3953 {
3954   gint x;
3955   gint new_width;
3956   GtkTreeViewColumn *column;
3957   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
3958
3959   column = gtk_tree_view_get_column (tree_view, tree_view->priv->drag_pos);
3960
3961   if (event->is_hint || event->window != gtk_widget_get_window (widget))
3962     gdk_window_get_device_position (gtk_widget_get_window (widget),
3963                                     gdk_event_get_device ((GdkEvent *) event),
3964                                     &x, NULL, NULL);
3965   else
3966     x = event->x;
3967
3968   if (tree_view->priv->hadjustment)
3969     x += gtk_adjustment_get_value (tree_view->priv->hadjustment);
3970
3971   new_width = gtk_tree_view_new_column_width (tree_view,
3972                                               tree_view->priv->drag_pos, &x);
3973   if (x != tree_view->priv->x_drag &&
3974       (new_width != gtk_tree_view_column_get_fixed_width (column)))
3975     {
3976       _gtk_tree_view_column_set_use_resized_width (column, TRUE);
3977
3978       if (gtk_tree_view_column_get_expand (column))
3979         new_width -= tree_view->priv->last_extra_space_per_column;
3980
3981       _gtk_tree_view_column_set_resized_width (column, new_width);
3982
3983
3984       gtk_widget_queue_resize (widget);
3985     }
3986
3987   return FALSE;
3988 }
3989
3990
3991 static void
3992 gtk_tree_view_update_current_reorder (GtkTreeView *tree_view,
3993                                       GdkEvent    *event)
3994 {
3995   GtkTreeViewColumnReorder *reorder = NULL;
3996   GList *list;
3997   gint mouse_x;
3998
3999   gdk_window_get_device_position (tree_view->priv->header_window,
4000                                   gdk_event_get_device (event),
4001                                   &mouse_x, NULL, NULL);
4002   for (list = tree_view->priv->column_drag_info; list; list = list->next)
4003     {
4004       reorder = (GtkTreeViewColumnReorder *) list->data;
4005       if (mouse_x >= reorder->left_align && mouse_x < reorder->right_align)
4006         break;
4007       reorder = NULL;
4008     }
4009
4010   /*  if (reorder && reorder == tree_view->priv->cur_reorder)
4011       return;*/
4012
4013   tree_view->priv->cur_reorder = reorder;
4014   gtk_tree_view_motion_draw_column_motion_arrow (tree_view);
4015 }
4016
4017 static void
4018 gtk_tree_view_vertical_autoscroll (GtkTreeView *tree_view)
4019 {
4020   GdkRectangle visible_rect;
4021   gint y;
4022   gint offset;
4023
4024   gdk_window_get_device_position (tree_view->priv->bin_window,
4025                                   gdk_device_manager_get_client_pointer (
4026                                     gdk_display_get_device_manager (
4027                                       gtk_widget_get_display (GTK_WIDGET (tree_view)))),
4028                                   NULL, &y, NULL);
4029   y += tree_view->priv->dy;
4030
4031   gtk_tree_view_get_visible_rect (tree_view, &visible_rect);
4032
4033   /* see if we are near the edge. */
4034   offset = y - (visible_rect.y + 2 * SCROLL_EDGE_SIZE);
4035   if (offset > 0)
4036     {
4037       offset = y - (visible_rect.y + visible_rect.height - 2 * SCROLL_EDGE_SIZE);
4038       if (offset < 0)
4039         return;
4040     }
4041
4042   gtk_adjustment_set_value (tree_view->priv->vadjustment,
4043                             MAX (gtk_adjustment_get_value (tree_view->priv->vadjustment) + offset, 0.0));
4044 }
4045
4046 static gboolean
4047 gtk_tree_view_horizontal_autoscroll (GtkTreeView *tree_view,
4048                                      GdkEvent    *event)
4049 {
4050   GdkRectangle visible_rect;
4051   gint x;
4052   gint offset;
4053
4054   gdk_window_get_device_position (tree_view->priv->bin_window,
4055                                   gdk_event_get_device (event),
4056                                   &x, NULL, NULL);
4057
4058   gtk_tree_view_get_visible_rect (tree_view, &visible_rect);
4059
4060   /* See if we are near the edge. */
4061   offset = x - (visible_rect.x + SCROLL_EDGE_SIZE);
4062   if (offset > 0)
4063     {
4064       offset = x - (visible_rect.x + visible_rect.width - SCROLL_EDGE_SIZE);
4065       if (offset < 0)
4066         return TRUE;
4067     }
4068   offset = offset/3;
4069
4070   gtk_adjustment_set_value (tree_view->priv->hadjustment,
4071                             MAX (gtk_adjustment_get_value (tree_view->priv->hadjustment) + offset, 0.0));
4072
4073   return TRUE;
4074
4075 }
4076
4077 static gboolean
4078 gtk_tree_view_motion_drag_column (GtkWidget      *widget,
4079                                   GdkEventMotion *event)
4080 {
4081   GtkAllocation allocation, button_allocation;
4082   GtkTreeView *tree_view = (GtkTreeView *) widget;
4083   GtkTreeViewColumn *column = tree_view->priv->drag_column;
4084   GtkWidget *button;
4085   gint x, y;
4086
4087   /* Sanity Check */
4088   if ((column == NULL) ||
4089       (event->window != tree_view->priv->drag_window))
4090     return FALSE;
4091
4092   button = gtk_tree_view_column_get_button (column);
4093
4094   /* Handle moving the header */
4095   gdk_window_get_position (tree_view->priv->drag_window, &x, &y);
4096   gtk_widget_get_allocation (widget, &allocation);
4097   gtk_widget_get_allocation (button, &button_allocation);
4098   x = CLAMP (x + (gint)event->x - _gtk_tree_view_column_get_drag_x (column), 0,
4099              MAX (tree_view->priv->width, allocation.width) - button_allocation.width);
4100   gdk_window_move (tree_view->priv->drag_window, x, y);
4101
4102   /* autoscroll, if needed */
4103   gtk_tree_view_horizontal_autoscroll (tree_view, (GdkEvent *) event);
4104   /* Update the current reorder position and arrow; */
4105   gtk_tree_view_update_current_reorder (tree_view, (GdkEvent *) event);
4106
4107   return TRUE;
4108 }
4109
4110 static void
4111 gtk_tree_view_stop_rubber_band (GtkTreeView *tree_view)
4112 {
4113   remove_scroll_timeout (tree_view);
4114   gtk_grab_remove (GTK_WIDGET (tree_view));
4115
4116   if (tree_view->priv->rubber_band_status == RUBBER_BAND_ACTIVE)
4117     {
4118       GtkTreePath *tmp_path;
4119
4120       gtk_widget_queue_draw (GTK_WIDGET (tree_view));
4121
4122       /* The anchor path should be set to the start path */
4123       tmp_path = _gtk_tree_view_find_path (tree_view,
4124                                            tree_view->priv->rubber_band_start_tree,
4125                                            tree_view->priv->rubber_band_start_node);
4126
4127       if (tree_view->priv->anchor)
4128         gtk_tree_row_reference_free (tree_view->priv->anchor);
4129
4130       tree_view->priv->anchor =
4131         gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view),
4132                                           tree_view->priv->model,
4133                                           tmp_path);
4134
4135       gtk_tree_path_free (tmp_path);
4136
4137       /* ... and the cursor to the end path */
4138       tmp_path = _gtk_tree_view_find_path (tree_view,
4139                                            tree_view->priv->rubber_band_end_tree,
4140                                            tree_view->priv->rubber_band_end_node);
4141       gtk_tree_view_real_set_cursor (GTK_TREE_VIEW (tree_view), tmp_path, FALSE, FALSE);
4142       gtk_tree_path_free (tmp_path);
4143
4144       _gtk_tree_selection_emit_changed (tree_view->priv->selection);
4145     }
4146
4147   /* Clear status variables */
4148   tree_view->priv->rubber_band_status = RUBBER_BAND_OFF;
4149   tree_view->priv->rubber_band_extend = FALSE;
4150   tree_view->priv->rubber_band_modify = FALSE;
4151
4152   tree_view->priv->rubber_band_start_node = NULL;
4153   tree_view->priv->rubber_band_start_tree = NULL;
4154   tree_view->priv->rubber_band_end_node = NULL;
4155   tree_view->priv->rubber_band_end_tree = NULL;
4156 }
4157
4158 static void
4159 gtk_tree_view_update_rubber_band_selection_range (GtkTreeView *tree_view,
4160                                                  GtkRBTree   *start_tree,
4161                                                  GtkRBNode   *start_node,
4162                                                  GtkRBTree   *end_tree,
4163                                                  GtkRBNode   *end_node,
4164                                                  gboolean     select,
4165                                                  gboolean     skip_start,
4166                                                  gboolean     skip_end)
4167 {
4168   if (start_node == end_node)
4169     return;
4170
4171   /* We skip the first node and jump inside the loop */
4172   if (skip_start)
4173     goto skip_first;
4174
4175   do
4176     {
4177       /* Small optimization by assuming insensitive nodes are never
4178        * selected.
4179        */
4180       if (!GTK_RBNODE_FLAG_SET (start_node, GTK_RBNODE_IS_SELECTED))
4181         {
4182           GtkTreePath *path;
4183           gboolean selectable;
4184
4185           path = _gtk_tree_view_find_path (tree_view, start_tree, start_node);
4186           selectable = _gtk_tree_selection_row_is_selectable (tree_view->priv->selection, start_node, path);
4187           gtk_tree_path_free (path);
4188
4189           if (!selectable)
4190             goto node_not_selectable;
4191         }
4192
4193       if (select)
4194         {
4195           if (tree_view->priv->rubber_band_extend)
4196             GTK_RBNODE_SET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
4197           else if (tree_view->priv->rubber_band_modify)
4198             {
4199               /* Toggle the selection state */
4200               if (GTK_RBNODE_FLAG_SET (start_node, GTK_RBNODE_IS_SELECTED))
4201                 GTK_RBNODE_UNSET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
4202               else
4203                 GTK_RBNODE_SET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
4204             }
4205           else
4206             GTK_RBNODE_SET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
4207         }
4208       else
4209         {
4210           /* Mirror the above */
4211           if (tree_view->priv->rubber_band_extend)
4212             GTK_RBNODE_UNSET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
4213           else if (tree_view->priv->rubber_band_modify)
4214             {
4215               /* Toggle the selection state */
4216               if (GTK_RBNODE_FLAG_SET (start_node, GTK_RBNODE_IS_SELECTED))
4217                 GTK_RBNODE_UNSET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
4218               else
4219                 GTK_RBNODE_SET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
4220             }
4221           else
4222             GTK_RBNODE_UNSET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
4223         }
4224
4225       _gtk_tree_view_queue_draw_node (tree_view, start_tree, start_node, NULL);
4226
4227 node_not_selectable:
4228       if (start_node == end_node)
4229         break;
4230
4231 skip_first:
4232
4233       if (start_node->children)
4234         {
4235           start_tree = start_node->children;
4236           start_node = _gtk_rbtree_first (start_tree);
4237         }
4238       else
4239         {
4240           _gtk_rbtree_next_full (start_tree, start_node, &start_tree, &start_node);
4241
4242           if (!start_tree)
4243             /* Ran out of tree */
4244             break;
4245         }
4246
4247       if (skip_end && start_node == end_node)
4248         break;
4249     }
4250   while (TRUE);
4251 }
4252
4253 static void
4254 gtk_tree_view_update_rubber_band_selection (GtkTreeView *tree_view)
4255 {
4256   GtkRBTree *start_tree, *end_tree;
4257   GtkRBNode *start_node, *end_node;
4258
4259   _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);
4260   _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);
4261
4262   /* Handle the start area first */
4263   if (!tree_view->priv->rubber_band_start_node)
4264     {
4265       gtk_tree_view_update_rubber_band_selection_range (tree_view,
4266                                                        start_tree,
4267                                                        start_node,
4268                                                        end_tree,
4269                                                        end_node,
4270                                                        TRUE,
4271                                                        FALSE,
4272                                                        FALSE);
4273     }
4274   else if (_gtk_rbtree_node_find_offset (start_tree, start_node) <
4275            _gtk_rbtree_node_find_offset (tree_view->priv->rubber_band_start_tree, tree_view->priv->rubber_band_start_node))
4276     {
4277       /* New node is above the old one; selection became bigger */
4278       gtk_tree_view_update_rubber_band_selection_range (tree_view,
4279                                                        start_tree,
4280                                                        start_node,
4281                                                        tree_view->priv->rubber_band_start_tree,
4282                                                        tree_view->priv->rubber_band_start_node,
4283                                                        TRUE,
4284                                                        FALSE,
4285                                                        TRUE);
4286     }
4287   else if (_gtk_rbtree_node_find_offset (start_tree, start_node) >
4288            _gtk_rbtree_node_find_offset (tree_view->priv->rubber_band_start_tree, tree_view->priv->rubber_band_start_node))
4289     {
4290       /* New node is below the old one; selection became smaller */
4291       gtk_tree_view_update_rubber_band_selection_range (tree_view,
4292                                                        tree_view->priv->rubber_band_start_tree,
4293                                                        tree_view->priv->rubber_band_start_node,
4294                                                        start_tree,
4295                                                        start_node,
4296                                                        FALSE,
4297                                                        FALSE,
4298                                                        TRUE);
4299     }
4300
4301   tree_view->priv->rubber_band_start_tree = start_tree;
4302   tree_view->priv->rubber_band_start_node = start_node;
4303
4304   /* Next, handle the end area */
4305   if (!tree_view->priv->rubber_band_end_node)
4306     {
4307       /* In the event this happens, start_node was also NULL; this case is
4308        * handled above.
4309        */
4310     }
4311   else if (!end_node)
4312     {
4313       /* Find the last node in the tree */
4314       _gtk_rbtree_find_offset (tree_view->priv->tree, tree_view->priv->height - 1,
4315                                &end_tree, &end_node);
4316
4317       /* Selection reached end of the tree */
4318       gtk_tree_view_update_rubber_band_selection_range (tree_view,
4319                                                        tree_view->priv->rubber_band_end_tree,
4320                                                        tree_view->priv->rubber_band_end_node,
4321                                                        end_tree,
4322                                                        end_node,
4323                                                        TRUE,
4324                                                        TRUE,
4325                                                        FALSE);
4326     }
4327   else if (_gtk_rbtree_node_find_offset (end_tree, end_node) >
4328            _gtk_rbtree_node_find_offset (tree_view->priv->rubber_band_end_tree, tree_view->priv->rubber_band_end_node))
4329     {
4330       /* New node is below the old one; selection became bigger */
4331       gtk_tree_view_update_rubber_band_selection_range (tree_view,
4332                                                        tree_view->priv->rubber_band_end_tree,
4333                                                        tree_view->priv->rubber_band_end_node,
4334                                                        end_tree,
4335                                                        end_node,
4336                                                        TRUE,
4337                                                        TRUE,
4338                                                        FALSE);
4339     }
4340   else if (_gtk_rbtree_node_find_offset (end_tree, end_node) <
4341            _gtk_rbtree_node_find_offset (tree_view->priv->rubber_band_end_tree, tree_view->priv->rubber_band_end_node))
4342     {
4343       /* New node is above the old one; selection became smaller */
4344       gtk_tree_view_update_rubber_band_selection_range (tree_view,
4345                                                        end_tree,
4346                                                        end_node,
4347                                                        tree_view->priv->rubber_band_end_tree,
4348                                                        tree_view->priv->rubber_band_end_node,
4349                                                        FALSE,
4350                                                        TRUE,
4351                                                        FALSE);
4352     }
4353
4354   tree_view->priv->rubber_band_end_tree = end_tree;
4355   tree_view->priv->rubber_band_end_node = end_node;
4356 }
4357
4358 static void
4359 gtk_tree_view_update_rubber_band (GtkTreeView *tree_view)
4360 {
4361   gint x, y;
4362   GdkRectangle old_area;
4363   GdkRectangle new_area;
4364   GdkRectangle common;
4365   cairo_region_t *invalid_region;
4366
4367   old_area.x = MIN (tree_view->priv->press_start_x, tree_view->priv->rubber_band_x);
4368   old_area.y = MIN (tree_view->priv->press_start_y, tree_view->priv->rubber_band_y) - tree_view->priv->dy;
4369   old_area.width = ABS (tree_view->priv->rubber_band_x - tree_view->priv->press_start_x) + 1;
4370   old_area.height = ABS (tree_view->priv->rubber_band_y - tree_view->priv->press_start_y) + 1;
4371
4372   gdk_window_get_device_position (tree_view->priv->bin_window,
4373                                   gdk_device_manager_get_client_pointer (
4374                                     gdk_display_get_device_manager (
4375                                       gtk_widget_get_display (GTK_WIDGET (tree_view)))),
4376                                   &x, &y, NULL);
4377
4378   x = MAX (x, 0);
4379   y = MAX (y, 0) + tree_view->priv->dy;
4380
4381   new_area.x = MIN (tree_view->priv->press_start_x, x);
4382   new_area.y = MIN (tree_view->priv->press_start_y, y) - tree_view->priv->dy;
4383   new_area.width = ABS (x - tree_view->priv->press_start_x) + 1;
4384   new_area.height = ABS (y - tree_view->priv->press_start_y) + 1;
4385
4386   invalid_region = cairo_region_create_rectangle (&old_area);
4387   cairo_region_union_rectangle (invalid_region, &new_area);
4388
4389   gdk_rectangle_intersect (&old_area, &new_area, &common);
4390   if (common.width > 2 && common.height > 2)
4391     {
4392       cairo_region_t *common_region;
4393
4394       /* make sure the border is invalidated */
4395       common.x += 1;
4396       common.y += 1;
4397       common.width -= 2;
4398       common.height -= 2;
4399
4400       common_region = cairo_region_create_rectangle (&common);
4401
4402       cairo_region_subtract (invalid_region, common_region);
4403       cairo_region_destroy (common_region);
4404     }
4405
4406   gdk_window_invalidate_region (tree_view->priv->bin_window, invalid_region, TRUE);
4407
4408   cairo_region_destroy (invalid_region);
4409
4410   tree_view->priv->rubber_band_x = x;
4411   tree_view->priv->rubber_band_y = y;
4412
4413   gtk_tree_view_update_rubber_band_selection (tree_view);
4414 }
4415
4416 static void
4417 gtk_tree_view_paint_rubber_band (GtkTreeView  *tree_view,
4418                                  cairo_t      *cr)
4419 {
4420   GdkRectangle rect;
4421   GtkStyleContext *context;
4422
4423   cairo_save (cr);
4424
4425   context = gtk_widget_get_style_context (GTK_WIDGET (tree_view));
4426
4427   gtk_style_context_save (context);
4428   gtk_style_context_add_class (context, GTK_STYLE_CLASS_RUBBERBAND);
4429
4430   rect.x = MIN (tree_view->priv->press_start_x, tree_view->priv->rubber_band_x);
4431   rect.y = MIN (tree_view->priv->press_start_y, tree_view->priv->rubber_band_y) - tree_view->priv->dy;
4432   rect.width = ABS (tree_view->priv->press_start_x - tree_view->priv->rubber_band_x) + 1;
4433   rect.height = ABS (tree_view->priv->press_start_y - tree_view->priv->rubber_band_y) + 1;
4434
4435   gdk_cairo_rectangle (cr, &rect);
4436   cairo_clip (cr);
4437
4438   gtk_render_background (context, cr,
4439                          rect.x, rect.y,
4440                          rect.width, rect.height);
4441   gtk_render_frame (context, cr,
4442                     rect.x, rect.y,
4443                     rect.width, rect.height);
4444
4445   gtk_style_context_restore (context);
4446   cairo_restore (cr);
4447 }
4448
4449 static gboolean
4450 gtk_tree_view_motion_bin_window (GtkWidget      *widget,
4451                                  GdkEventMotion *event)
4452 {
4453   GtkTreeView *tree_view;
4454   GtkRBTree *tree;
4455   GtkRBNode *node;
4456   gint new_y;
4457
4458   tree_view = (GtkTreeView *) widget;
4459
4460   if (tree_view->priv->tree == NULL)
4461     return FALSE;
4462
4463   if (tree_view->priv->rubber_band_status == RUBBER_BAND_MAYBE_START)
4464     {
4465       gtk_grab_add (GTK_WIDGET (tree_view));
4466       gtk_tree_view_update_rubber_band (tree_view);
4467
4468       tree_view->priv->rubber_band_status = RUBBER_BAND_ACTIVE;
4469     }
4470   else if (tree_view->priv->rubber_band_status == RUBBER_BAND_ACTIVE)
4471     {
4472       gtk_tree_view_update_rubber_band (tree_view);
4473
4474       add_scroll_timeout (tree_view);
4475     }
4476
4477   /* only check for an initiated drag when a button is pressed */
4478   if (tree_view->priv->pressed_button >= 0
4479       && !tree_view->priv->rubber_band_status)
4480     gtk_tree_view_maybe_begin_dragging_row (tree_view, event);
4481
4482   new_y = TREE_WINDOW_Y_TO_RBTREE_Y(tree_view, event->y);
4483   if (new_y < 0)
4484     new_y = 0;
4485
4486   _gtk_rbtree_find_offset (tree_view->priv->tree, new_y, &tree, &node);
4487
4488   /* If we are currently pressing down a button, we don't want to prelight anything else. */
4489   if ((tree_view->priv->button_pressed_node != NULL) &&
4490       (tree_view->priv->button_pressed_node != node))
4491     node = NULL;
4492
4493   tree_view->priv->event_last_x = event->x;
4494   tree_view->priv->event_last_y = event->y;
4495
4496   prelight_or_select (tree_view, tree, node, event->x, event->y);
4497
4498   return TRUE;
4499 }
4500
4501 static gboolean
4502 gtk_tree_view_motion (GtkWidget      *widget,
4503                       GdkEventMotion *event)
4504 {
4505   GtkTreeView *tree_view;
4506
4507   tree_view = (GtkTreeView *) widget;
4508
4509   /* Resizing a column */
4510   if (tree_view->priv->in_column_resize)
4511     return gtk_tree_view_motion_resize_column (widget, event);
4512
4513   /* Drag column */
4514   if (tree_view->priv->in_column_drag)
4515     return gtk_tree_view_motion_drag_column (widget, event);
4516
4517   /* Sanity check it */
4518   if (event->window == tree_view->priv->bin_window)
4519     return gtk_tree_view_motion_bin_window (widget, event);
4520
4521   return FALSE;
4522 }
4523
4524 /* Invalidate the focus rectangle near the edge of the bin_window; used when
4525  * the tree is empty.
4526  */
4527 static void
4528 invalidate_empty_focus (GtkTreeView *tree_view)
4529 {
4530   GdkRectangle area;
4531
4532   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
4533     return;
4534
4535   area.x = 0;
4536   area.y = 0;
4537   area.width = gdk_window_get_width (tree_view->priv->bin_window);
4538   area.height = gdk_window_get_height (tree_view->priv->bin_window);
4539   gdk_window_invalidate_rect (tree_view->priv->bin_window, &area, FALSE);
4540 }
4541
4542 /* Draws a focus rectangle near the edge of the bin_window; used when the tree
4543  * is empty.
4544  */
4545 static void
4546 draw_empty_focus (GtkTreeView *tree_view, cairo_t *cr)
4547 {
4548   GtkWidget *widget = GTK_WIDGET (tree_view);
4549   gint w, h;
4550
4551   if (!gtk_widget_has_visible_focus (widget))
4552     return;
4553
4554   w = gdk_window_get_width (tree_view->priv->bin_window) - 2;
4555   h = gdk_window_get_height (tree_view->priv->bin_window) - 2;
4556
4557   if (w > 0 && h > 0)
4558     {
4559       GtkStyleContext *context;
4560       GtkStateFlags state;
4561
4562       context = gtk_widget_get_style_context (widget);
4563       state = gtk_widget_get_state_flags (widget);
4564
4565       gtk_style_context_save (context);
4566       gtk_style_context_set_state (context, state);
4567
4568       gtk_render_focus (context, cr, 1, 1, w, h);
4569
4570       gtk_style_context_restore (context);
4571     }
4572 }
4573
4574 typedef enum {
4575   GTK_TREE_VIEW_GRID_LINE,
4576   GTK_TREE_VIEW_TREE_LINE,
4577   GTK_TREE_VIEW_FOREGROUND_LINE
4578 } GtkTreeViewLineType;
4579
4580 static void
4581 gtk_tree_view_draw_line (GtkTreeView         *tree_view,
4582                          cairo_t             *cr,
4583                          GtkTreeViewLineType  type,
4584                          int                  x1,
4585                          int                  y1,
4586                          int                  x2,
4587                          int                  y2)
4588 {
4589   cairo_save (cr);
4590
4591   switch (type)
4592     {
4593     case GTK_TREE_VIEW_TREE_LINE:
4594       cairo_set_source_rgb (cr, 0, 0, 0);
4595       cairo_set_line_width (cr, tree_view->priv->tree_line_width);
4596       if (tree_view->priv->tree_line_dashes[0])
4597         cairo_set_dash (cr,
4598                         tree_view->priv->tree_line_dashes,
4599                         2, 0.5);
4600       break;
4601     case GTK_TREE_VIEW_GRID_LINE:
4602       cairo_set_source_rgb (cr, 0, 0, 0);
4603       cairo_set_line_width (cr, tree_view->priv->grid_line_width);
4604       if (tree_view->priv->grid_line_dashes[0])
4605         cairo_set_dash (cr,
4606                         tree_view->priv->grid_line_dashes,
4607                         2, 0.5);
4608       break;
4609     default:
4610       g_assert_not_reached ();
4611       /* fall through */
4612     case GTK_TREE_VIEW_FOREGROUND_LINE:
4613       {
4614         GtkStyleContext *context;
4615         GtkStateFlags state;
4616         GdkRGBA color;
4617
4618         context = gtk_widget_get_style_context (GTK_WIDGET (tree_view));
4619         state = gtk_widget_get_state_flags (GTK_WIDGET (tree_view));
4620
4621         cairo_set_line_width (cr, 1.0);
4622         gtk_style_context_get_color (context, state, &color);
4623         gdk_cairo_set_source_rgba (cr, &color);
4624       }
4625
4626       break;
4627     }
4628
4629   cairo_move_to (cr, x1 + 0.5, y1 + 0.5);
4630   cairo_line_to (cr, x2 + 0.5, y2 + 0.5);
4631   cairo_stroke (cr);
4632
4633   cairo_restore (cr);
4634 }
4635
4636 static void
4637 gtk_tree_view_draw_grid_lines (GtkTreeView    *tree_view,
4638                                cairo_t        *cr,
4639                                gint            n_visible_columns)
4640 {
4641   GList *list = tree_view->priv->columns;
4642   gint i = 0;
4643   gint current_x = 0;
4644
4645   if (tree_view->priv->grid_lines != GTK_TREE_VIEW_GRID_LINES_VERTICAL
4646       && tree_view->priv->grid_lines != GTK_TREE_VIEW_GRID_LINES_BOTH)
4647     return;
4648
4649   /* Only draw the lines for visible rows and columns */
4650   for (list = tree_view->priv->columns; list; list = list->next, i++)
4651     {
4652       GtkTreeViewColumn *column = list->data;
4653
4654       /* We don't want a line for the last column */
4655       if (i == n_visible_columns - 1)
4656         break;
4657
4658       if (!gtk_tree_view_column_get_visible (column))
4659         continue;
4660
4661       current_x += gtk_tree_view_column_get_width (column);
4662
4663       gtk_tree_view_draw_line (tree_view, cr,
4664                                GTK_TREE_VIEW_GRID_LINE,
4665                                current_x - 1, 0,
4666                                current_x - 1, tree_view->priv->height);
4667     }
4668 }
4669
4670 /* Warning: Very scary function.
4671  * Modify at your own risk
4672  *
4673  * KEEP IN SYNC WITH gtk_tree_view_create_row_drag_icon()!
4674  * FIXME: It's not...
4675  */
4676 static gboolean
4677 gtk_tree_view_bin_draw (GtkWidget      *widget,
4678                         cairo_t        *cr)
4679 {
4680   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
4681   GtkTreePath *path;
4682   GtkRBTree *tree;
4683   GList *list;
4684   GtkRBNode *node;
4685   GtkRBNode *cursor = NULL;
4686   GtkRBTree *cursor_tree = NULL;
4687   GtkRBNode *drag_highlight = NULL;
4688   GtkRBTree *drag_highlight_tree = NULL;
4689   GtkTreeIter iter;
4690   gint new_y;
4691   gint y_offset, cell_offset;
4692   gint max_height;
4693   gint depth;
4694   GdkRectangle background_area;
4695   GdkRectangle cell_area;
4696   GdkRectangle clip;
4697   guint flags;
4698   gint highlight_x;
4699   gint expander_cell_width;
4700   gint bin_window_width;
4701   gint bin_window_height;
4702   GtkTreePath *cursor_path;
4703   GtkTreePath *drag_dest_path;
4704   GList *first_column, *last_column;
4705   gint vertical_separator;
4706   gint horizontal_separator;
4707   gint focus_line_width;
4708   gboolean allow_rules;
4709   gboolean has_can_focus_cell;
4710   gboolean rtl;
4711   gint n_visible_columns;
4712   gint grid_line_width;
4713   gboolean draw_vgrid_lines, draw_hgrid_lines;
4714   GtkStyleContext *context;
4715   GtkStateFlags state;
4716   gboolean parity;
4717
4718   rtl = (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL);
4719   context = gtk_widget_get_style_context (widget);
4720   state = gtk_widget_get_state_flags (widget);
4721
4722   gtk_widget_style_get (widget,
4723                         "horizontal-separator", &horizontal_separator,
4724                         "vertical-separator", &vertical_separator,
4725                         "allow-rules", &allow_rules,
4726                         "focus-line-width", &focus_line_width,
4727                         NULL);
4728
4729   if (tree_view->priv->tree == NULL)
4730     {
4731       draw_empty_focus (tree_view, cr);
4732       return TRUE;
4733     }
4734
4735   bin_window_width = gdk_window_get_width (tree_view->priv->bin_window);
4736   bin_window_height = gdk_window_get_height (tree_view->priv->bin_window);
4737   cairo_rectangle (cr, 0, 0, bin_window_width, bin_window_height);
4738   cairo_clip (cr);
4739   if (!gdk_cairo_get_clip_rectangle (cr, &clip))
4740     return TRUE;
4741
4742   new_y = TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, clip.y);
4743
4744   if (new_y < 0)
4745     new_y = 0;
4746   y_offset = -_gtk_rbtree_find_offset (tree_view->priv->tree, new_y, &tree, &node);
4747
4748   if (tree_view->priv->height < bin_window_height)
4749     {
4750       gtk_style_context_save (context);
4751       gtk_style_context_set_state (context, state);
4752       gtk_style_context_add_class (context, GTK_STYLE_CLASS_CELL);
4753
4754       gtk_render_background (context, cr,
4755                              0, tree_view->priv->height,
4756                              bin_window_width,
4757                              bin_window_height - tree_view->priv->height);
4758
4759       gtk_style_context_restore (context);
4760     }
4761
4762   if (node == NULL)
4763     return TRUE;
4764
4765   /* find the path for the node */
4766   path = _gtk_tree_view_find_path ((GtkTreeView *)widget,
4767                                    tree,
4768                                    node);
4769   gtk_tree_model_get_iter (tree_view->priv->model,
4770                            &iter,
4771                            path);
4772   depth = gtk_tree_path_get_depth (path);
4773   gtk_tree_path_free (path);
4774
4775   cursor_path = NULL;
4776   drag_dest_path = NULL;
4777
4778   if (tree_view->priv->cursor)
4779     cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
4780
4781   if (cursor_path)
4782     _gtk_tree_view_find_node (tree_view, cursor_path,
4783                               &cursor_tree, &cursor);
4784
4785   if (tree_view->priv->drag_dest_row)
4786     drag_dest_path = gtk_tree_row_reference_get_path (tree_view->priv->drag_dest_row);
4787
4788   if (drag_dest_path)
4789     _gtk_tree_view_find_node (tree_view, drag_dest_path,
4790                               &drag_highlight_tree, &drag_highlight);
4791
4792   draw_vgrid_lines =
4793     tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_VERTICAL
4794     || tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_BOTH;
4795   draw_hgrid_lines =
4796     tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_HORIZONTAL
4797     || tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_BOTH;
4798
4799   if (draw_vgrid_lines || draw_hgrid_lines)
4800     gtk_widget_style_get (widget, "grid-line-width", &grid_line_width, NULL);
4801
4802   n_visible_columns = 0;
4803   for (list = tree_view->priv->columns; list; list = list->next)
4804     {
4805       if (!gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (list->data)))
4806         continue;
4807       n_visible_columns ++;
4808     }
4809
4810   /* Find the last column */
4811   for (last_column = g_list_last (tree_view->priv->columns);
4812        last_column &&
4813        !(gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (last_column->data)));
4814        last_column = last_column->prev)
4815     ;
4816
4817   /* and the first */
4818   for (first_column = g_list_first (tree_view->priv->columns);
4819        first_column &&
4820        !(gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (first_column->data)));
4821        first_column = first_column->next)
4822     ;
4823
4824   /* Actually process the expose event.  To do this, we want to
4825    * start at the first node of the event, and walk the tree in
4826    * order, drawing each successive node.
4827    */
4828
4829   parity = !(_gtk_rbtree_node_get_index (tree, node) % 2);
4830
4831   do
4832     {
4833       gboolean is_separator = FALSE;
4834       gboolean is_first = FALSE;
4835       gboolean is_last = FALSE;
4836       gint n_col = 0;
4837
4838       parity = !parity;
4839       is_separator = row_is_separator (tree_view, &iter, NULL);
4840
4841       max_height = gtk_tree_view_get_row_height (tree_view, node);
4842
4843       cell_offset = 0;
4844       highlight_x = 0; /* should match x coord of first cell */
4845       expander_cell_width = 0;
4846
4847       background_area.y = y_offset + clip.y;
4848       background_area.height = max_height;
4849
4850       flags = 0;
4851
4852       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PRELIT))
4853         flags |= GTK_CELL_RENDERER_PRELIT;
4854
4855       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
4856         flags |= GTK_CELL_RENDERER_SELECTED;
4857
4858       /* we *need* to set cell data on all cells before the call
4859        * to _has_can_focus_cell, else _has_can_focus_cell() does not
4860        * return a correct value.
4861        */
4862       for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
4863            list;
4864            list = (rtl ? list->prev : list->next))
4865         {
4866           GtkTreeViewColumn *column = list->data;
4867           gtk_tree_view_column_cell_set_cell_data (column,
4868                                                    tree_view->priv->model,
4869                                                    &iter,
4870                                                    GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT),
4871                                                    node->children?TRUE:FALSE);
4872         }
4873
4874       has_can_focus_cell = gtk_tree_view_has_can_focus_cell (tree_view);
4875
4876       for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
4877            list;
4878            list = (rtl ? list->prev : list->next))
4879         {
4880           GtkTreeViewColumn *column = list->data;
4881           GtkRegionFlags row_flags = 0, column_flags = 0;
4882           GtkStateFlags state = 0;
4883           gint width;
4884           gboolean draw_focus;
4885
4886           if (!gtk_tree_view_column_get_visible (column))
4887             continue;
4888
4889           n_col++;
4890           width = gtk_tree_view_column_get_width (column);
4891
4892           if (cell_offset > clip.x + clip.width ||
4893               cell_offset + width < clip.x)
4894             {
4895               cell_offset += width;
4896               continue;
4897             }
4898
4899           if (gtk_tree_view_column_get_sort_indicator (column))
4900             flags |= GTK_CELL_RENDERER_SORTED;
4901           else
4902             flags &= ~GTK_CELL_RENDERER_SORTED;
4903
4904           if (cursor == node)
4905             flags |= GTK_CELL_RENDERER_FOCUSED;
4906           else
4907             flags &= ~GTK_CELL_RENDERER_FOCUSED;
4908
4909           background_area.x = cell_offset;
4910           background_area.width = width;
4911
4912           cell_area = background_area;
4913           cell_area.y += vertical_separator / 2;
4914           cell_area.x += horizontal_separator / 2;
4915           cell_area.height -= vertical_separator;
4916           cell_area.width -= horizontal_separator;
4917
4918           if (draw_vgrid_lines)
4919             {
4920               if (list == first_column)
4921                 {
4922                   cell_area.width -= grid_line_width / 2;
4923                 }
4924               else if (list == last_column)
4925                 {
4926                   cell_area.x += grid_line_width / 2;
4927                   cell_area.width -= grid_line_width / 2;
4928                 }
4929               else
4930                 {
4931                   cell_area.x += grid_line_width / 2;
4932                   cell_area.width -= grid_line_width;
4933                 }
4934             }
4935
4936           if (draw_hgrid_lines)
4937             {
4938               cell_area.y += grid_line_width / 2;
4939               cell_area.height -= grid_line_width;
4940             }
4941
4942           if (!gdk_rectangle_intersect (&clip, &background_area, NULL))
4943             {
4944               cell_offset += gtk_tree_view_column_get_width (column);
4945               continue;
4946             }
4947
4948           gtk_tree_view_column_cell_set_cell_data (column,
4949                                                    tree_view->priv->model,
4950                                                    &iter,
4951                                                    GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT),
4952                                                    node->children?TRUE:FALSE);
4953
4954           /* Select the detail for drawing the cell.  relevant
4955            * factors are parity, sortedness, and whether to
4956            * display rules.
4957            */
4958           if (allow_rules && tree_view->priv->has_rules)
4959             {
4960               if (parity)
4961                 row_flags |= GTK_REGION_ODD;
4962               else
4963                 row_flags |= GTK_REGION_EVEN;
4964             }
4965
4966           if ((flags & GTK_CELL_RENDERER_SORTED) &&
4967               n_visible_columns >= 3)
4968             column_flags |= GTK_REGION_SORTED;
4969
4970           is_first = (rtl ? !list->next : !list->prev);
4971           is_last = (rtl ? !list->prev : !list->next);
4972
4973           if (is_first)
4974             column_flags |= GTK_REGION_FIRST;
4975
4976           if (is_last)
4977             column_flags |= GTK_REGION_LAST;
4978
4979           if ((n_col % 2) == 0)
4980             column_flags |= GTK_REGION_EVEN;
4981           else
4982             column_flags |= GTK_REGION_ODD;
4983
4984           gtk_style_context_save (context);
4985
4986           state = gtk_cell_renderer_get_state (NULL, widget, flags);
4987           gtk_style_context_set_state (context, state);
4988
4989           gtk_style_context_add_class (context, GTK_STYLE_CLASS_CELL);
4990           gtk_style_context_add_region (context, GTK_STYLE_REGION_ROW, row_flags);
4991           gtk_style_context_add_region (context, GTK_STYLE_REGION_COLUMN, column_flags);
4992
4993           if (node == cursor && has_can_focus_cell
4994               && ((column == tree_view->priv->focus_column
4995                    && tree_view->priv->draw_keyfocus &&
4996                    gtk_widget_has_visible_focus (widget))
4997                   || (column == tree_view->priv->edited_column)))
4998             draw_focus = TRUE;
4999           else
5000             draw_focus = FALSE;
5001
5002           /* Draw background */
5003           gtk_render_background (context, cr,
5004                                  background_area.x,
5005                                  background_area.y,
5006                                  background_area.width,
5007                                  background_area.height);
5008
5009           /* Draw frame */
5010           gtk_render_frame (context, cr,
5011                             background_area.x,
5012                             background_area.y,
5013                             background_area.width,
5014                             background_area.height);
5015
5016           if (gtk_tree_view_is_expander_column (tree_view, column))
5017             {
5018               if (!rtl)
5019                 cell_area.x += (depth - 1) * tree_view->priv->level_indentation;
5020               cell_area.width -= (depth - 1) * tree_view->priv->level_indentation;
5021
5022               if (gtk_tree_view_draw_expanders (tree_view))
5023                 {
5024                   if (!rtl)
5025                     cell_area.x += depth * tree_view->priv->expander_size;
5026                   cell_area.width -= depth * tree_view->priv->expander_size;
5027                 }
5028
5029               /* If we have an expander column, the highlight underline
5030                * starts with that column, so that it indicates which
5031                * level of the tree we're dropping at.
5032                */
5033               highlight_x = cell_area.x;
5034               expander_cell_width = cell_area.width;
5035
5036               if (is_separator)
5037                 {
5038                   gtk_style_context_save (context);
5039                   gtk_style_context_add_class (context, GTK_STYLE_CLASS_SEPARATOR);
5040
5041                   gtk_render_line (context, cr,
5042                                    cell_area.x,
5043                                    cell_area.y + cell_area.height / 2,
5044                                    cell_area.x + cell_area.width,
5045                                    cell_area.y + cell_area.height / 2);
5046
5047                   gtk_style_context_restore (context);
5048                 }
5049               else
5050                 {
5051                   _gtk_tree_view_column_cell_render (column,
5052                                                      cr,
5053                                                      &background_area,
5054                                                      &cell_area,
5055                                                      flags,
5056                                                      draw_focus);
5057                 }
5058
5059               if (gtk_tree_view_draw_expanders (tree_view)
5060                   && (node->flags & GTK_RBNODE_IS_PARENT) == GTK_RBNODE_IS_PARENT)
5061                 {
5062                   gtk_tree_view_draw_arrow (GTK_TREE_VIEW (widget),
5063                                             cr,
5064                                             tree,
5065                                             node);
5066                 }
5067             }
5068           else
5069             {
5070               if (is_separator)
5071                 {
5072                   gtk_style_context_save (context);
5073                   gtk_style_context_add_class (context, GTK_STYLE_CLASS_SEPARATOR);
5074
5075                   gtk_render_line (context, cr,
5076                                    cell_area.x,
5077                                    cell_area.y + cell_area.height / 2,
5078                                    cell_area.x + cell_area.width,
5079                                    cell_area.y + cell_area.height / 2);
5080
5081                   gtk_style_context_restore (context);
5082                 }
5083               else
5084                 _gtk_tree_view_column_cell_render (column,
5085                                                    cr,
5086                                                    &background_area,
5087                                                    &cell_area,
5088                                                    flags,
5089                                                    draw_focus);
5090             }
5091
5092           if (draw_hgrid_lines)
5093             {
5094               if (background_area.y > 0)
5095                 gtk_tree_view_draw_line (tree_view, cr,
5096                                          GTK_TREE_VIEW_GRID_LINE,
5097                                          background_area.x, background_area.y,
5098                                          background_area.x + background_area.width,
5099                                          background_area.y);
5100
5101               if (y_offset + max_height >= clip.height)
5102                 gtk_tree_view_draw_line (tree_view, cr,
5103                                          GTK_TREE_VIEW_GRID_LINE,
5104                                          background_area.x, background_area.y + max_height,
5105                                          background_area.x + background_area.width,
5106                                          background_area.y + max_height);
5107             }
5108
5109           if (gtk_tree_view_is_expander_column (tree_view, column) &&
5110               tree_view->priv->tree_lines_enabled)
5111             {
5112               gint x = background_area.x;
5113               gint mult = rtl ? -1 : 1;
5114               gint y0 = background_area.y;
5115               gint y1 = background_area.y + background_area.height/2;
5116               gint y2 = background_area.y + background_area.height;
5117
5118               if (rtl)
5119                 x += background_area.width - 1;
5120
5121               if ((node->flags & GTK_RBNODE_IS_PARENT) == GTK_RBNODE_IS_PARENT
5122                   && depth > 1)
5123                 {
5124                   gtk_tree_view_draw_line (tree_view, cr,
5125                                            GTK_TREE_VIEW_TREE_LINE,
5126                                            x + tree_view->priv->expander_size * (depth - 1.5) * mult,
5127                                            y1,
5128                                            x + tree_view->priv->expander_size * (depth - 1.1) * mult,
5129                                            y1);
5130                 }
5131               else if (depth > 1)
5132                 {
5133                   gtk_tree_view_draw_line (tree_view, cr,
5134                                            GTK_TREE_VIEW_TREE_LINE,
5135                                            x + tree_view->priv->expander_size * (depth - 1.5) * mult,
5136                                            y1,
5137                                            x + tree_view->priv->expander_size * (depth - 0.5) * mult,
5138                                            y1);
5139                 }
5140
5141               if (depth > 1)
5142                 {
5143                   gint i;
5144                   GtkRBNode *tmp_node;
5145                   GtkRBTree *tmp_tree;
5146
5147                   if (!_gtk_rbtree_next (tree, node))
5148                     gtk_tree_view_draw_line (tree_view, cr,
5149                                              GTK_TREE_VIEW_TREE_LINE,
5150                                              x + tree_view->priv->expander_size * (depth - 1.5) * mult,
5151                                              y0,
5152                                              x + tree_view->priv->expander_size * (depth - 1.5) * mult,
5153                                              y1);
5154                   else
5155                     gtk_tree_view_draw_line (tree_view, cr,
5156                                              GTK_TREE_VIEW_TREE_LINE,
5157                                              x + tree_view->priv->expander_size * (depth - 1.5) * mult,
5158                                              y0,
5159                                              x + tree_view->priv->expander_size * (depth - 1.5) * mult,
5160                                              y2);
5161
5162                   tmp_node = tree->parent_node;
5163                   tmp_tree = tree->parent_tree;
5164
5165                   for (i = depth - 2; i > 0; i--)
5166                     {
5167                       if (_gtk_rbtree_next (tmp_tree, tmp_node))
5168                         gtk_tree_view_draw_line (tree_view, cr,
5169                                                  GTK_TREE_VIEW_TREE_LINE,
5170                                                  x + tree_view->priv->expander_size * (i - 0.5) * mult,
5171                                                  y0,
5172                                                  x + tree_view->priv->expander_size * (i - 0.5) * mult,
5173                                                  y2);
5174
5175                       tmp_node = tmp_tree->parent_node;
5176                       tmp_tree = tmp_tree->parent_tree;
5177                     }
5178                 }
5179             }
5180
5181           gtk_style_context_restore (context);
5182           cell_offset += gtk_tree_view_column_get_width (column);
5183         }
5184
5185       if (node == drag_highlight)
5186         {
5187           /* Draw indicator for the drop
5188            */
5189           gint highlight_y = -1;
5190           GtkRBTree *tree = NULL;
5191           GtkRBNode *node = NULL;
5192
5193           switch (tree_view->priv->drag_dest_pos)
5194             {
5195             case GTK_TREE_VIEW_DROP_BEFORE:
5196               highlight_y = background_area.y - 1;
5197               if (highlight_y < 0)
5198                       highlight_y = 0;
5199               break;
5200
5201             case GTK_TREE_VIEW_DROP_AFTER:
5202               highlight_y = background_area.y + background_area.height - 1;
5203               break;
5204
5205             case GTK_TREE_VIEW_DROP_INTO_OR_BEFORE:
5206             case GTK_TREE_VIEW_DROP_INTO_OR_AFTER:
5207               _gtk_tree_view_find_node (tree_view, drag_dest_path, &tree, &node);
5208
5209               if (tree == NULL)
5210                 break;
5211
5212               gtk_render_focus (context, cr,
5213                                 0, gtk_tree_view_get_row_y_offset (tree_view, tree, node)
5214                                    - focus_line_width / 2,
5215                                 gdk_window_get_width (tree_view->priv->bin_window),
5216                                 gtk_tree_view_get_row_height (tree_view, node)
5217                                    - focus_line_width + 1);
5218               break;
5219             }
5220
5221           if (highlight_y >= 0)
5222             {
5223               gtk_tree_view_draw_line (tree_view, cr,
5224                                        GTK_TREE_VIEW_FOREGROUND_LINE,
5225                                        rtl ? highlight_x + expander_cell_width : highlight_x,
5226                                        highlight_y,
5227                                        rtl ? 0 : bin_window_width,
5228                                        highlight_y);
5229             }
5230         }
5231
5232       /* draw the big row-spanning focus rectangle, if needed */
5233       if (!has_can_focus_cell && node == cursor &&
5234           tree_view->priv->draw_keyfocus &&
5235           gtk_widget_has_visible_focus (widget))
5236         {
5237           gint tmp_y, tmp_height;
5238           GtkStateFlags focus_rect_state = 0;
5239
5240           gtk_style_context_save (context);
5241
5242           focus_rect_state = gtk_cell_renderer_get_state (NULL, widget, flags);
5243           gtk_style_context_set_state (context, focus_rect_state);
5244
5245           if (draw_hgrid_lines)
5246             {
5247               tmp_y = gtk_tree_view_get_row_y_offset (tree_view, tree, node) + grid_line_width / 2;
5248               tmp_height = gtk_tree_view_get_row_height (tree_view, node) - grid_line_width;
5249             }
5250           else
5251             {
5252               tmp_y = gtk_tree_view_get_row_y_offset (tree_view, tree, node);
5253               tmp_height = gtk_tree_view_get_row_height (tree_view, node);
5254             }
5255
5256           gtk_render_focus (context, cr,
5257                             0, tmp_y,
5258                             gdk_window_get_width (tree_view->priv->bin_window),
5259                             tmp_height);
5260
5261           gtk_style_context_restore (context);
5262         }
5263
5264       y_offset += max_height;
5265       if (node->children)
5266         {
5267           GtkTreeIter parent = iter;
5268           gboolean has_child;
5269
5270           tree = node->children;
5271           node = _gtk_rbtree_first (tree);
5272
5273           has_child = gtk_tree_model_iter_children (tree_view->priv->model,
5274                                                     &iter,
5275                                                     &parent);
5276           depth++;
5277
5278           /* Sanity Check! */
5279           TREE_VIEW_INTERNAL_ASSERT (has_child, FALSE);
5280         }
5281       else
5282         {
5283           gboolean done = FALSE;
5284
5285           do
5286             {
5287               node = _gtk_rbtree_next (tree, node);
5288               if (node != NULL)
5289                 {
5290                   gboolean has_next = gtk_tree_model_iter_next (tree_view->priv->model, &iter);
5291                   done = TRUE;
5292
5293                   /* Sanity Check! */
5294                   TREE_VIEW_INTERNAL_ASSERT (has_next, FALSE);
5295                 }
5296               else
5297                 {
5298                   GtkTreeIter parent_iter = iter;
5299                   gboolean has_parent;
5300
5301                   node = tree->parent_node;
5302                   tree = tree->parent_tree;
5303                   if (tree == NULL)
5304                     /* we should go to done to free some memory */
5305                     goto done;
5306                   has_parent = gtk_tree_model_iter_parent (tree_view->priv->model,
5307                                                            &iter,
5308                                                            &parent_iter);
5309                   depth--;
5310
5311                   /* Sanity check */
5312                   TREE_VIEW_INTERNAL_ASSERT (has_parent, FALSE);
5313                 }
5314             }
5315           while (!done);
5316         }
5317     }
5318   while (y_offset < clip.height);
5319
5320 done:
5321   gtk_tree_view_draw_grid_lines (tree_view, cr, n_visible_columns);
5322
5323   if (tree_view->priv->rubber_band_status == RUBBER_BAND_ACTIVE)
5324     gtk_tree_view_paint_rubber_band (tree_view, cr);
5325
5326   if (cursor_path)
5327     gtk_tree_path_free (cursor_path);
5328
5329   if (drag_dest_path)
5330     gtk_tree_path_free (drag_dest_path);
5331
5332   return FALSE;
5333 }
5334
5335 static gboolean
5336 gtk_tree_view_draw (GtkWidget *widget,
5337                     cairo_t   *cr)
5338 {
5339   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
5340   GtkWidget   *button;
5341
5342   if (gtk_cairo_should_draw_window (cr, tree_view->priv->bin_window))
5343     {
5344       GtkStyleContext *context;
5345       GList *tmp_list;
5346
5347       context = gtk_widget_get_style_context (widget);
5348
5349       cairo_save (cr);
5350
5351       gtk_style_context_save (context);
5352       gtk_style_context_add_class (context, GTK_STYLE_CLASS_VIEW);
5353
5354       gtk_cairo_transform_to_window (cr, widget, tree_view->priv->bin_window);
5355
5356       gtk_tree_view_bin_draw (widget, cr);
5357
5358       gtk_style_context_restore (context);
5359       cairo_restore (cr);
5360
5361       /* We can't just chain up to Container::draw as it will try to send the
5362        * event to the headers, so we handle propagating it to our children
5363        * (eg. widgets being edited) ourselves.
5364        */
5365       tmp_list = tree_view->priv->children;
5366       while (tmp_list)
5367         {
5368           GtkTreeViewChild *child = tmp_list->data;
5369           tmp_list = tmp_list->next;
5370
5371           gtk_container_propagate_draw (GTK_CONTAINER (tree_view), child->widget, cr);
5372         }
5373     }
5374
5375   if (gtk_cairo_should_draw_window (cr, tree_view->priv->header_window))
5376     {
5377       GList *list;
5378
5379       for (list = tree_view->priv->columns; list != NULL; list = list->next)
5380         {
5381           GtkTreeViewColumn *column = list->data;
5382
5383           if (column == tree_view->priv->drag_column)
5384             continue;
5385
5386           if (gtk_tree_view_column_get_visible (column))
5387             {
5388               button = gtk_tree_view_column_get_button (column);
5389               gtk_container_propagate_draw (GTK_CONTAINER (tree_view),
5390                                             button, cr);
5391             }
5392         }
5393     }
5394
5395   if (tree_view->priv->drag_window &&
5396       gtk_cairo_should_draw_window (cr, tree_view->priv->drag_window))
5397     {
5398       button = gtk_tree_view_column_get_button (tree_view->priv->drag_column);
5399       gtk_container_propagate_draw (GTK_CONTAINER (tree_view),
5400                                     button, cr);
5401     }
5402
5403   return FALSE;
5404 }
5405
5406 enum
5407 {
5408   DROP_HOME,
5409   DROP_RIGHT,
5410   DROP_LEFT,
5411   DROP_END
5412 };
5413
5414 /* returns 0x1 when no column has been found -- yes it's hackish */
5415 static GtkTreeViewColumn *
5416 gtk_tree_view_get_drop_column (GtkTreeView       *tree_view,
5417                                GtkTreeViewColumn *column,
5418                                gint               drop_position)
5419 {
5420   GtkTreeViewColumn *left_column = NULL;
5421   GtkTreeViewColumn *cur_column = NULL;
5422   GList *tmp_list;
5423
5424   if (!gtk_tree_view_column_get_reorderable (column))
5425     return (GtkTreeViewColumn *)0x1;
5426
5427   switch (drop_position)
5428     {
5429       case DROP_HOME:
5430         /* find first column where we can drop */
5431         tmp_list = tree_view->priv->columns;
5432         if (column == GTK_TREE_VIEW_COLUMN (tmp_list->data))
5433           return (GtkTreeViewColumn *)0x1;
5434
5435         while (tmp_list)
5436           {
5437             g_assert (tmp_list);
5438
5439             cur_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
5440             tmp_list = tmp_list->next;
5441
5442             if (left_column &&
5443                 gtk_tree_view_column_get_visible (left_column) == FALSE)
5444               continue;
5445
5446             if (!tree_view->priv->column_drop_func)
5447               return left_column;
5448
5449             if (!tree_view->priv->column_drop_func (tree_view, column, left_column, cur_column, tree_view->priv->column_drop_func_data))
5450               {
5451                 left_column = cur_column;
5452                 continue;
5453               }
5454
5455             return left_column;
5456           }
5457
5458         if (!tree_view->priv->column_drop_func)
5459           return left_column;
5460
5461         if (tree_view->priv->column_drop_func (tree_view, column, left_column, NULL, tree_view->priv->column_drop_func_data))
5462           return left_column;
5463         else
5464           return (GtkTreeViewColumn *)0x1;
5465         break;
5466
5467       case DROP_RIGHT:
5468         /* find first column after column where we can drop */
5469         tmp_list = tree_view->priv->columns;
5470
5471         for (; tmp_list; tmp_list = tmp_list->next)
5472           if (GTK_TREE_VIEW_COLUMN (tmp_list->data) == column)
5473             break;
5474
5475         if (!tmp_list || !tmp_list->next)
5476           return (GtkTreeViewColumn *)0x1;
5477
5478         tmp_list = tmp_list->next;
5479         left_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
5480         tmp_list = tmp_list->next;
5481
5482         while (tmp_list)
5483           {
5484             g_assert (tmp_list);
5485
5486             cur_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
5487             tmp_list = tmp_list->next;
5488
5489             if (left_column &&
5490                 gtk_tree_view_column_get_visible (left_column) == FALSE)
5491               {
5492                 left_column = cur_column;
5493                 if (tmp_list)
5494                   tmp_list = tmp_list->next;
5495                 continue;
5496               }
5497
5498             if (!tree_view->priv->column_drop_func)
5499               return left_column;
5500
5501             if (!tree_view->priv->column_drop_func (tree_view, column, left_column, cur_column, tree_view->priv->column_drop_func_data))
5502               {
5503                 left_column = cur_column;
5504                 continue;
5505               }
5506
5507             return left_column;
5508           }
5509
5510         if (!tree_view->priv->column_drop_func)
5511           return left_column;
5512
5513         if (tree_view->priv->column_drop_func (tree_view, column, left_column, NULL, tree_view->priv->column_drop_func_data))
5514           return left_column;
5515         else
5516           return (GtkTreeViewColumn *)0x1;
5517         break;
5518
5519       case DROP_LEFT:
5520         /* find first column before column where we can drop */
5521         tmp_list = tree_view->priv->columns;
5522
5523         for (; tmp_list; tmp_list = tmp_list->next)
5524           if (GTK_TREE_VIEW_COLUMN (tmp_list->data) == column)
5525             break;
5526
5527         if (!tmp_list || !tmp_list->prev)
5528           return (GtkTreeViewColumn *)0x1;
5529
5530         tmp_list = tmp_list->prev;
5531         cur_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
5532         tmp_list = tmp_list->prev;
5533
5534         while (tmp_list)
5535           {
5536             g_assert (tmp_list);
5537
5538             left_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
5539
5540             if (left_column &&
5541                 gtk_tree_view_column_get_visible (left_column) == FALSE)
5542               {
5543                 /*if (!tmp_list->prev)
5544                   return (GtkTreeViewColumn *)0x1;
5545                   */
5546 /*
5547                 cur_column = GTK_TREE_VIEW_COLUMN (tmp_list->prev->data);
5548                 tmp_list = tmp_list->prev->prev;
5549                 continue;*/
5550
5551                 cur_column = left_column;
5552                 if (tmp_list)
5553                   tmp_list = tmp_list->prev;
5554                 continue;
5555               }
5556
5557             if (!tree_view->priv->column_drop_func)
5558               return left_column;
5559
5560             if (tree_view->priv->column_drop_func (tree_view, column, left_column, cur_column, tree_view->priv->column_drop_func_data))
5561               return left_column;
5562
5563             cur_column = left_column;
5564             tmp_list = tmp_list->prev;
5565           }
5566
5567         if (!tree_view->priv->column_drop_func)
5568           return NULL;
5569
5570         if (tree_view->priv->column_drop_func (tree_view, column, NULL, cur_column, tree_view->priv->column_drop_func_data))
5571           return NULL;
5572         else
5573           return (GtkTreeViewColumn *)0x1;
5574         break;
5575
5576       case DROP_END:
5577         /* same as DROP_HOME case, but doing it backwards */
5578         tmp_list = g_list_last (tree_view->priv->columns);
5579         cur_column = NULL;
5580
5581         if (column == GTK_TREE_VIEW_COLUMN (tmp_list->data))
5582           return (GtkTreeViewColumn *)0x1;
5583
5584         while (tmp_list)
5585           {
5586             g_assert (tmp_list);
5587
5588             left_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
5589
5590             if (left_column &&
5591                 gtk_tree_view_column_get_visible (left_column) == FALSE)
5592               {
5593                 cur_column = left_column;
5594                 tmp_list = tmp_list->prev;
5595               }
5596
5597             if (!tree_view->priv->column_drop_func)
5598               return left_column;
5599
5600             if (tree_view->priv->column_drop_func (tree_view, column, left_column, cur_column, tree_view->priv->column_drop_func_data))
5601               return left_column;
5602
5603             cur_column = left_column;
5604             tmp_list = tmp_list->prev;
5605           }
5606
5607         if (!tree_view->priv->column_drop_func)
5608           return NULL;
5609
5610         if (tree_view->priv->column_drop_func (tree_view, column, NULL, cur_column, tree_view->priv->column_drop_func_data))
5611           return NULL;
5612         else
5613           return (GtkTreeViewColumn *)0x1;
5614         break;
5615     }
5616
5617   return (GtkTreeViewColumn *)0x1;
5618 }
5619
5620 static gboolean
5621 gtk_tree_view_key_press (GtkWidget   *widget,
5622                          GdkEventKey *event)
5623 {
5624   GtkTreeView *tree_view = (GtkTreeView *) widget;
5625   GtkWidget   *button;
5626
5627   if (tree_view->priv->rubber_band_status)
5628     {
5629       if (event->keyval == GDK_KEY_Escape)
5630         gtk_tree_view_stop_rubber_band (tree_view);
5631
5632       return TRUE;
5633     }
5634
5635   if (tree_view->priv->in_column_drag)
5636     {
5637       if (event->keyval == GDK_KEY_Escape)
5638         {
5639           tree_view->priv->cur_reorder = NULL;
5640           gtk_tree_view_button_release_drag_column (widget, NULL);
5641         }
5642       return TRUE;
5643     }
5644
5645   if (tree_view->priv->headers_visible)
5646     {
5647       GList *focus_column;
5648       gboolean rtl;
5649
5650       rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
5651
5652       for (focus_column = tree_view->priv->columns;
5653            focus_column;
5654            focus_column = focus_column->next)
5655         {
5656           GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN (focus_column->data);
5657
5658           button = gtk_tree_view_column_get_button (column);
5659           if (gtk_widget_has_focus (button))
5660             break;
5661         }
5662
5663       if (focus_column &&
5664           (event->state & GDK_SHIFT_MASK) && (event->state & GDK_MOD1_MASK) &&
5665           (event->keyval == GDK_KEY_Left || event->keyval == GDK_KEY_KP_Left
5666            || event->keyval == GDK_KEY_Right || event->keyval == GDK_KEY_KP_Right))
5667         {
5668           GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN (focus_column->data);
5669           gint max_width, min_width;
5670
5671           if (!gtk_tree_view_column_get_resizable (column))
5672             {
5673               gtk_widget_error_bell (widget);
5674               return TRUE;
5675             }
5676
5677           if (event->keyval == (rtl ? GDK_KEY_Right : GDK_KEY_Left)
5678               || event->keyval == (rtl ? GDK_KEY_KP_Right : GDK_KEY_KP_Left))
5679             {
5680               GtkRequisition button_req;
5681               gint old_width = _gtk_tree_view_column_get_resized_width (column);
5682               gint new_width;
5683
5684               button = gtk_tree_view_column_get_button (column);
5685
5686               gtk_widget_get_preferred_size (button, &button_req, NULL);
5687
5688               new_width = MAX (old_width, gtk_tree_view_column_get_width (column));
5689               new_width -= 2;
5690               if (new_width < 0)
5691                 new_width = 0;
5692
5693               _gtk_tree_view_column_set_resized_width (column, new_width);
5694
5695               min_width = gtk_tree_view_column_get_min_width (column);
5696               if (min_width == -1)
5697                 new_width = MAX (button_req.width, new_width);
5698               else
5699                 {
5700                   new_width = MAX (min_width, new_width);
5701                 }
5702
5703               max_width = gtk_tree_view_column_get_max_width (column);
5704               if (max_width != -1)
5705                 new_width = MIN (new_width, max_width);
5706
5707               _gtk_tree_view_column_set_use_resized_width (column, TRUE);
5708
5709               if (new_width != old_width)
5710                 {
5711                   _gtk_tree_view_column_set_resized_width (column, new_width);
5712                   gtk_widget_queue_resize (widget);
5713                 }
5714               else
5715                 gtk_widget_error_bell (widget);
5716             }
5717           else if (event->keyval == (rtl ? GDK_KEY_Left : GDK_KEY_Right)
5718                    || event->keyval == (rtl ? GDK_KEY_KP_Left : GDK_KEY_KP_Right))
5719             {
5720               gint old_width = _gtk_tree_view_column_get_resized_width (column);
5721               gint new_width;
5722
5723               new_width = MAX (old_width, gtk_tree_view_column_get_width (column));
5724               new_width += 2;
5725
5726               max_width = gtk_tree_view_column_get_max_width (column);
5727               if (max_width != -1)
5728                 new_width = MIN (new_width, max_width);
5729
5730               _gtk_tree_view_column_set_use_resized_width (column, TRUE);
5731
5732               if (new_width != old_width)
5733                 {
5734                   _gtk_tree_view_column_set_resized_width (column, new_width);
5735                   gtk_widget_queue_resize (widget);
5736                 }
5737               else
5738                 gtk_widget_error_bell (widget);
5739             }
5740
5741           return TRUE;
5742         }
5743
5744       if (focus_column &&
5745           (event->state & GDK_MOD1_MASK) &&
5746           (event->keyval == GDK_KEY_Left || event->keyval == GDK_KEY_KP_Left
5747            || event->keyval == GDK_KEY_Right || event->keyval == GDK_KEY_KP_Right
5748            || event->keyval == GDK_KEY_Home || event->keyval == GDK_KEY_KP_Home
5749            || event->keyval == GDK_KEY_End || event->keyval == GDK_KEY_KP_End))
5750         {
5751           GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN (focus_column->data);
5752
5753           if (event->keyval == (rtl ? GDK_KEY_Right : GDK_KEY_Left)
5754               || event->keyval == (rtl ? GDK_KEY_KP_Right : GDK_KEY_KP_Left))
5755             {
5756               GtkTreeViewColumn *col;
5757               col = gtk_tree_view_get_drop_column (tree_view, column, DROP_LEFT);
5758               if (col != (GtkTreeViewColumn *)0x1)
5759                 gtk_tree_view_move_column_after (tree_view, column, col);
5760               else
5761                 gtk_widget_error_bell (widget);
5762             }
5763           else if (event->keyval == (rtl ? GDK_KEY_Left : GDK_KEY_Right)
5764                    || event->keyval == (rtl ? GDK_KEY_KP_Left : GDK_KEY_KP_Right))
5765             {
5766               GtkTreeViewColumn *col;
5767               col = gtk_tree_view_get_drop_column (tree_view, column, DROP_RIGHT);
5768               if (col != (GtkTreeViewColumn *)0x1)
5769                 gtk_tree_view_move_column_after (tree_view, column, col);
5770               else
5771                 gtk_widget_error_bell (widget);
5772             }
5773           else if (event->keyval == GDK_KEY_Home || event->keyval == GDK_KEY_KP_Home)
5774             {
5775               GtkTreeViewColumn *col;
5776               col = gtk_tree_view_get_drop_column (tree_view, column, DROP_HOME);
5777               if (col != (GtkTreeViewColumn *)0x1)
5778                 gtk_tree_view_move_column_after (tree_view, column, col);
5779               else
5780                 gtk_widget_error_bell (widget);
5781             }
5782           else if (event->keyval == GDK_KEY_End || event->keyval == GDK_KEY_KP_End)
5783             {
5784               GtkTreeViewColumn *col;
5785               col = gtk_tree_view_get_drop_column (tree_view, column, DROP_END);
5786               if (col != (GtkTreeViewColumn *)0x1)
5787                 gtk_tree_view_move_column_after (tree_view, column, col);
5788               else
5789                 gtk_widget_error_bell (widget);
5790             }
5791
5792           return TRUE;
5793         }
5794     }
5795
5796   /* Chain up to the parent class.  It handles the keybindings. */
5797   if (GTK_WIDGET_CLASS (gtk_tree_view_parent_class)->key_press_event (widget, event))
5798     return TRUE;
5799
5800   if (tree_view->priv->search_entry_avoid_unhandled_binding)
5801     {
5802       tree_view->priv->search_entry_avoid_unhandled_binding = FALSE;
5803       return FALSE;
5804     }
5805
5806   /* We pass the event to the search_entry.  If its text changes, then we start
5807    * the typeahead find capabilities. */
5808   if (gtk_widget_has_focus (GTK_WIDGET (tree_view))
5809       && tree_view->priv->enable_search
5810       && !tree_view->priv->search_custom_entry_set)
5811     {
5812       GdkEvent *new_event;
5813       char *old_text;
5814       const char *new_text;
5815       gboolean retval;
5816       GdkScreen *screen;
5817       gboolean text_modified;
5818       gulong popup_menu_id;
5819
5820       gtk_tree_view_ensure_interactive_directory (tree_view);
5821
5822       /* Make a copy of the current text */
5823       old_text = g_strdup (gtk_entry_get_text (GTK_ENTRY (tree_view->priv->search_entry)));
5824       new_event = gdk_event_copy ((GdkEvent *) event);
5825       g_object_unref (((GdkEventKey *) new_event)->window);
5826       ((GdkEventKey *) new_event)->window = g_object_ref (gtk_widget_get_window (tree_view->priv->search_window));
5827       gtk_widget_realize (tree_view->priv->search_window);
5828
5829       popup_menu_id = g_signal_connect (tree_view->priv->search_entry,
5830                                         "popup-menu", G_CALLBACK (gtk_true),
5831                                         NULL);
5832
5833       /* Move the entry off screen */
5834       screen = gtk_widget_get_screen (GTK_WIDGET (tree_view));
5835       gtk_window_move (GTK_WINDOW (tree_view->priv->search_window),
5836                        gdk_screen_get_width (screen) + 1,
5837                        gdk_screen_get_height (screen) + 1);
5838       gtk_widget_show (tree_view->priv->search_window);
5839
5840       /* Send the event to the window.  If the preedit_changed signal is emitted
5841        * during this event, we will set priv->imcontext_changed  */
5842       tree_view->priv->imcontext_changed = FALSE;
5843       retval = gtk_widget_event (tree_view->priv->search_window, new_event);
5844       gdk_event_free (new_event);
5845       gtk_widget_hide (tree_view->priv->search_window);
5846
5847       g_signal_handler_disconnect (tree_view->priv->search_entry,
5848                                    popup_menu_id);
5849
5850       /* We check to make sure that the entry tried to handle the text, and that
5851        * the text has changed.
5852        */
5853       new_text = gtk_entry_get_text (GTK_ENTRY (tree_view->priv->search_entry));
5854       text_modified = strcmp (old_text, new_text) != 0;
5855       g_free (old_text);
5856       if (tree_view->priv->imcontext_changed ||    /* we're in a preedit */
5857           (retval && text_modified))               /* ...or the text was modified */
5858         {
5859           if (gtk_tree_view_real_start_interactive_search (tree_view,
5860                                                            gdk_event_get_device ((GdkEvent *) event),
5861                                                            FALSE))
5862             {
5863               gtk_widget_grab_focus (GTK_WIDGET (tree_view));
5864               return TRUE;
5865             }
5866           else
5867             {
5868               gtk_entry_set_text (GTK_ENTRY (tree_view->priv->search_entry), "");
5869               return FALSE;
5870             }
5871         }
5872     }
5873
5874   return FALSE;
5875 }
5876
5877 static gboolean
5878 gtk_tree_view_key_release (GtkWidget   *widget,
5879                            GdkEventKey *event)
5880 {
5881   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
5882
5883   if (tree_view->priv->rubber_band_status)
5884     return TRUE;
5885
5886   return GTK_WIDGET_CLASS (gtk_tree_view_parent_class)->key_release_event (widget, event);
5887 }
5888
5889 /* FIXME Is this function necessary? Can I get an enter_notify event
5890  * w/o either an expose event or a mouse motion event?
5891  */
5892 static gboolean
5893 gtk_tree_view_enter_notify (GtkWidget        *widget,
5894                             GdkEventCrossing *event)
5895 {
5896   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
5897   GtkRBTree *tree;
5898   GtkRBNode *node;
5899   gint new_y;
5900
5901   /* Sanity check it */
5902   if (event->window != tree_view->priv->bin_window)
5903     return FALSE;
5904
5905   if (tree_view->priv->tree == NULL)
5906     return FALSE;
5907
5908   if (event->mode == GDK_CROSSING_GRAB ||
5909       event->mode == GDK_CROSSING_GTK_GRAB ||
5910       event->mode == GDK_CROSSING_GTK_UNGRAB ||
5911       event->mode == GDK_CROSSING_STATE_CHANGED)
5912     return TRUE;
5913
5914   /* find the node internally */
5915   new_y = TREE_WINDOW_Y_TO_RBTREE_Y(tree_view, event->y);
5916   if (new_y < 0)
5917     new_y = 0;
5918   _gtk_rbtree_find_offset (tree_view->priv->tree, new_y, &tree, &node);
5919
5920   tree_view->priv->event_last_x = event->x;
5921   tree_view->priv->event_last_y = event->y;
5922
5923   if ((tree_view->priv->button_pressed_node == NULL) ||
5924       (tree_view->priv->button_pressed_node == node))
5925     prelight_or_select (tree_view, tree, node, event->x, event->y);
5926
5927   return TRUE;
5928 }
5929
5930 static gboolean
5931 gtk_tree_view_leave_notify (GtkWidget        *widget,
5932                             GdkEventCrossing *event)
5933 {
5934   GtkTreeView *tree_view;
5935
5936   if (event->mode == GDK_CROSSING_GRAB ||
5937       event->mode == GDK_CROSSING_GTK_GRAB ||
5938       event->mode == GDK_CROSSING_GTK_UNGRAB)
5939     return TRUE;
5940
5941   tree_view = GTK_TREE_VIEW (widget);
5942
5943   if (tree_view->priv->prelight_node)
5944     _gtk_tree_view_queue_draw_node (tree_view,
5945                                    tree_view->priv->prelight_tree,
5946                                    tree_view->priv->prelight_node,
5947                                    NULL);
5948
5949   tree_view->priv->event_last_x = -10000;
5950   tree_view->priv->event_last_y = -10000;
5951
5952   prelight_or_select (tree_view,
5953                       NULL, NULL,
5954                       -1000, -1000); /* coords not possibly over an arrow */
5955
5956   return TRUE;
5957 }
5958
5959
5960 static gint
5961 gtk_tree_view_focus_out (GtkWidget     *widget,
5962                          GdkEventFocus *event)
5963 {
5964   GtkTreeView *tree_view;
5965
5966   tree_view = GTK_TREE_VIEW (widget);
5967
5968   gtk_widget_queue_draw (widget);
5969
5970   /* destroy interactive search dialog */
5971   if (tree_view->priv->search_window)
5972     gtk_tree_view_search_dialog_hide (tree_view->priv->search_window, tree_view,
5973                                       gdk_event_get_device ((GdkEvent *) event));
5974
5975   return FALSE;
5976 }
5977
5978
5979 /* Incremental Reflow
5980  */
5981
5982 static void
5983 gtk_tree_view_node_queue_redraw (GtkTreeView *tree_view,
5984                                  GtkRBTree   *tree,
5985                                  GtkRBNode   *node)
5986 {
5987   GtkAllocation allocation;
5988   gint y;
5989
5990   y = _gtk_rbtree_node_find_offset (tree, node)
5991     - gtk_adjustment_get_value (tree_view->priv->vadjustment)
5992     + gtk_tree_view_get_effective_header_height (tree_view);
5993
5994   gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
5995   gtk_widget_queue_draw_area (GTK_WIDGET (tree_view),
5996                               0, y,
5997                               allocation.width,
5998                               GTK_RBNODE_GET_HEIGHT (node));
5999 }
6000
6001 static gboolean
6002 node_is_visible (GtkTreeView *tree_view,
6003                  GtkRBTree   *tree,
6004                  GtkRBNode   *node)
6005 {
6006   int y;
6007   int height;
6008
6009   y = _gtk_rbtree_node_find_offset (tree, node);
6010   height = gtk_tree_view_get_row_height (tree_view, node);
6011
6012   if (y >= gtk_adjustment_get_value (tree_view->priv->vadjustment) &&
6013       y + height <= (gtk_adjustment_get_value (tree_view->priv->vadjustment)
6014                      + gtk_adjustment_get_page_size (tree_view->priv->vadjustment)))
6015     return TRUE;
6016
6017   return FALSE;
6018 }
6019
6020 /* Returns TRUE if it updated the size
6021  */
6022 static gboolean
6023 validate_row (GtkTreeView *tree_view,
6024               GtkRBTree   *tree,
6025               GtkRBNode   *node,
6026               GtkTreeIter *iter,
6027               GtkTreePath *path)
6028 {
6029   GtkTreeViewColumn *column;
6030   GList *list, *first_column, *last_column;
6031   gint height = 0;
6032   gint horizontal_separator;
6033   gint vertical_separator;
6034   gint depth = gtk_tree_path_get_depth (path);
6035   gboolean retval = FALSE;
6036   gboolean is_separator = FALSE;
6037   gboolean draw_vgrid_lines, draw_hgrid_lines;
6038   gint focus_pad;
6039   gint grid_line_width;
6040   gboolean wide_separators;
6041   gint separator_height;
6042
6043   /* double check the row needs validating */
6044   if (! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) &&
6045       ! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
6046     return FALSE;
6047
6048   is_separator = row_is_separator (tree_view, iter, NULL);
6049
6050   gtk_widget_style_get (GTK_WIDGET (tree_view),
6051                         "focus-padding", &focus_pad,
6052                         "horizontal-separator", &horizontal_separator,
6053                         "vertical-separator", &vertical_separator,
6054                         "grid-line-width", &grid_line_width,
6055                         "wide-separators",  &wide_separators,
6056                         "separator-height", &separator_height,
6057                         NULL);
6058
6059   draw_vgrid_lines =
6060     tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_VERTICAL
6061     || tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_BOTH;
6062   draw_hgrid_lines =
6063     tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_HORIZONTAL
6064     || tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_BOTH;
6065
6066   for (last_column = g_list_last (tree_view->priv->columns);
6067        last_column &&
6068        !(gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (last_column->data)));
6069        last_column = last_column->prev)
6070     ;
6071
6072   for (first_column = g_list_first (tree_view->priv->columns);
6073        first_column &&
6074        !(gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (first_column->data)));
6075        first_column = first_column->next)
6076     ;
6077
6078   for (list = tree_view->priv->columns; list; list = list->next)
6079     {
6080       gint padding = 0;
6081       gint original_width;
6082       gint new_width;
6083       gint row_height;
6084
6085       column = list->data;
6086
6087       if (!gtk_tree_view_column_get_visible (column))
6088         continue;
6089
6090       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID) &&
6091           !_gtk_tree_view_column_cell_get_dirty (column))
6092         continue;
6093
6094       original_width = _gtk_tree_view_column_get_requested_width (column);
6095
6096       gtk_tree_view_column_cell_set_cell_data (column, tree_view->priv->model, iter,
6097                                                GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT),
6098                                                node->children?TRUE:FALSE);
6099       gtk_tree_view_column_cell_get_size (column,
6100                                           NULL, NULL, NULL,
6101                                           NULL, &row_height);
6102
6103       if (!is_separator)
6104         {
6105           row_height += vertical_separator;
6106           height = MAX (height, row_height);
6107           height = MAX (height, tree_view->priv->expander_size);
6108         }
6109       else
6110         {
6111           if (wide_separators)
6112             height = separator_height + 2 * focus_pad;
6113           else
6114             height = 2 + 2 * focus_pad;
6115         }
6116
6117       if (gtk_tree_view_is_expander_column (tree_view, column))
6118         {
6119           padding += horizontal_separator + (depth - 1) * tree_view->priv->level_indentation;
6120
6121           if (gtk_tree_view_draw_expanders (tree_view))
6122             padding += depth * tree_view->priv->expander_size;
6123         }
6124       else
6125         padding += horizontal_separator;
6126
6127       if (draw_vgrid_lines)
6128         {
6129           if (list->data == first_column || list->data == last_column)
6130             padding += grid_line_width / 2.0;
6131           else
6132             padding += grid_line_width;
6133         }
6134
6135       /* Update the padding for the column */
6136       _gtk_tree_view_column_push_padding (column, padding);
6137       new_width = _gtk_tree_view_column_get_requested_width (column);
6138
6139       if (new_width > original_width)
6140         retval = TRUE;
6141     }
6142
6143   if (draw_hgrid_lines)
6144     height += grid_line_width;
6145
6146   if (height != GTK_RBNODE_GET_HEIGHT (node))
6147     {
6148       retval = TRUE;
6149       _gtk_rbtree_node_set_height (tree, node, height);
6150     }
6151   _gtk_rbtree_node_mark_valid (tree, node);
6152   tree_view->priv->post_validation_flag = TRUE;
6153
6154   return retval;
6155 }
6156
6157
6158 static void
6159 validate_visible_area (GtkTreeView *tree_view)
6160 {
6161   GtkAllocation allocation;
6162   GtkTreePath *path = NULL;
6163   GtkTreePath *above_path = NULL;
6164   GtkTreeIter iter;
6165   GtkRBTree *tree = NULL;
6166   GtkRBNode *node = NULL;
6167   gboolean need_redraw = FALSE;
6168   gboolean size_changed = FALSE;
6169   gint total_height;
6170   gint area_above = 0;
6171   gint area_below = 0;
6172
6173   if (tree_view->priv->tree == NULL)
6174     return;
6175
6176   if (! GTK_RBNODE_FLAG_SET (tree_view->priv->tree->root, GTK_RBNODE_DESCENDANTS_INVALID) &&
6177       tree_view->priv->scroll_to_path == NULL)
6178     return;
6179
6180   gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
6181   total_height = allocation.height - gtk_tree_view_get_effective_header_height (tree_view);
6182
6183   if (total_height == 0)
6184     return;
6185
6186   /* First, we check to see if we need to scroll anywhere
6187    */
6188   if (tree_view->priv->scroll_to_path)
6189     {
6190       path = gtk_tree_row_reference_get_path (tree_view->priv->scroll_to_path);
6191       if (path && !_gtk_tree_view_find_node (tree_view, path, &tree, &node))
6192         {
6193           /* we are going to scroll, and will update dy */
6194           gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
6195           if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) ||
6196               GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
6197             {
6198               _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
6199               if (validate_row (tree_view, tree, node, &iter, path))
6200                 size_changed = TRUE;
6201             }
6202
6203           if (tree_view->priv->scroll_to_use_align)
6204             {
6205               gint height = gtk_tree_view_get_row_height (tree_view, node);
6206               area_above = (total_height - height) *
6207                 tree_view->priv->scroll_to_row_align;
6208               area_below = total_height - area_above - height;
6209               area_above = MAX (area_above, 0);
6210               area_below = MAX (area_below, 0);
6211             }
6212           else
6213             {
6214               /* two cases:
6215                * 1) row not visible
6216                * 2) row visible
6217                */
6218               gint dy;
6219               gint height = gtk_tree_view_get_row_height (tree_view, node);
6220
6221               dy = _gtk_rbtree_node_find_offset (tree, node);
6222
6223               if (dy >= gtk_adjustment_get_value (tree_view->priv->vadjustment) &&
6224                   dy + height <= (gtk_adjustment_get_value (tree_view->priv->vadjustment)
6225                                   + gtk_adjustment_get_page_size (tree_view->priv->vadjustment)))
6226                 {
6227                   /* row visible: keep the row at the same position */
6228                   area_above = dy - gtk_adjustment_get_value (tree_view->priv->vadjustment);
6229                   area_below = (gtk_adjustment_get_value (tree_view->priv->vadjustment) +
6230                                 gtk_adjustment_get_page_size (tree_view->priv->vadjustment))
6231                                - dy - height;
6232                 }
6233               else
6234                 {
6235                   /* row not visible */
6236                   if (dy >= 0
6237                       && dy + height <= gtk_adjustment_get_page_size (tree_view->priv->vadjustment))
6238                     {
6239                       /* row at the beginning -- fixed */
6240                       area_above = dy;
6241                       area_below = gtk_adjustment_get_page_size (tree_view->priv->vadjustment)
6242                                    - area_above - height;
6243                     }
6244                   else if (dy >= (gtk_adjustment_get_upper (tree_view->priv->vadjustment) -
6245                                   gtk_adjustment_get_page_size (tree_view->priv->vadjustment)))
6246                     {
6247                       /* row at the end -- fixed */
6248                       area_above = dy - (gtk_adjustment_get_upper (tree_view->priv->vadjustment) -
6249                                    gtk_adjustment_get_page_size (tree_view->priv->vadjustment));
6250                       area_below = gtk_adjustment_get_page_size (tree_view->priv->vadjustment) -
6251                                    area_above - height;
6252
6253                       if (area_below < 0)
6254                         {
6255                           area_above = gtk_adjustment_get_page_size (tree_view->priv->vadjustment) - height;
6256                           area_below = 0;
6257                         }
6258                     }
6259                   else
6260                     {
6261                       /* row somewhere in the middle, bring it to the top
6262                        * of the view
6263                        */
6264                       area_above = 0;
6265                       area_below = total_height - height;
6266                     }
6267                 }
6268             }
6269         }
6270       else
6271         /* the scroll to isn't valid; ignore it.
6272          */
6273         {
6274           if (tree_view->priv->scroll_to_path && !path)
6275             {
6276               gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
6277               tree_view->priv->scroll_to_path = NULL;
6278             }
6279           if (path)
6280             gtk_tree_path_free (path);
6281           path = NULL;
6282         }
6283     }
6284
6285   /* We didn't have a scroll_to set, so we just handle things normally
6286    */
6287   if (path == NULL)
6288     {
6289       gint offset;
6290
6291       offset = _gtk_rbtree_find_offset (tree_view->priv->tree,
6292                                         TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, 0),
6293                                         &tree, &node);
6294       if (node == NULL)
6295         {
6296           /* In this case, nothing has been validated */
6297           path = gtk_tree_path_new_first ();
6298           _gtk_tree_view_find_node (tree_view, path, &tree, &node);
6299         }
6300       else
6301         {
6302           path = _gtk_tree_view_find_path (tree_view, tree, node);
6303           total_height += offset;
6304         }
6305
6306       gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
6307
6308       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) ||
6309           GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
6310         {
6311           _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
6312           if (validate_row (tree_view, tree, node, &iter, path))
6313             size_changed = TRUE;
6314         }
6315       area_above = 0;
6316       area_below = total_height - gtk_tree_view_get_row_height (tree_view, node);
6317     }
6318
6319   above_path = gtk_tree_path_copy (path);
6320
6321   /* if we do not validate any row above the new top_row, we will make sure
6322    * that the row immediately above top_row has been validated. (if we do not
6323    * do this, _gtk_rbtree_find_offset will find the row above top_row, because
6324    * when invalidated that row's height will be zero. and this will mess up
6325    * scrolling).
6326    */
6327   if (area_above == 0)
6328     {
6329       GtkRBTree *tmptree;
6330       GtkRBNode *tmpnode;
6331
6332       _gtk_tree_view_find_node (tree_view, above_path, &tmptree, &tmpnode);
6333       _gtk_rbtree_prev_full (tmptree, tmpnode, &tmptree, &tmpnode);
6334
6335       if (tmpnode)
6336         {
6337           GtkTreePath *tmppath;
6338           GtkTreeIter tmpiter;
6339
6340           tmppath = _gtk_tree_view_find_path (tree_view, tmptree, tmpnode);
6341           gtk_tree_model_get_iter (tree_view->priv->model, &tmpiter, tmppath);
6342
6343           if (GTK_RBNODE_FLAG_SET (tmpnode, GTK_RBNODE_INVALID) ||
6344               GTK_RBNODE_FLAG_SET (tmpnode, GTK_RBNODE_COLUMN_INVALID))
6345             {
6346               _gtk_tree_view_queue_draw_node (tree_view, tmptree, tmpnode, NULL);
6347               if (validate_row (tree_view, tmptree, tmpnode, &tmpiter, tmppath))
6348                 size_changed = TRUE;
6349             }
6350
6351           gtk_tree_path_free (tmppath);
6352         }
6353     }
6354
6355   /* Now, we walk forwards and backwards, measuring rows. Unfortunately,
6356    * backwards is much slower then forward, as there is no iter_prev function.
6357    * We go forwards first in case we run out of tree.  Then we go backwards to
6358    * fill out the top.
6359    */
6360   while (node && area_below > 0)
6361     {
6362       if (node->children)
6363         {
6364           GtkTreeIter parent = iter;
6365           gboolean has_child;
6366
6367           tree = node->children;
6368           node = _gtk_rbtree_first (tree);
6369
6370           has_child = gtk_tree_model_iter_children (tree_view->priv->model,
6371                                                     &iter,
6372                                                     &parent);
6373           TREE_VIEW_INTERNAL_ASSERT_VOID (has_child);
6374           gtk_tree_path_down (path);
6375         }
6376       else
6377         {
6378           gboolean done = FALSE;
6379           do
6380             {
6381               node = _gtk_rbtree_next (tree, node);
6382               if (node != NULL)
6383                 {
6384                   gboolean has_next = gtk_tree_model_iter_next (tree_view->priv->model, &iter);
6385                   done = TRUE;
6386                   gtk_tree_path_next (path);
6387
6388                   /* Sanity Check! */
6389                   TREE_VIEW_INTERNAL_ASSERT_VOID (has_next);
6390                 }
6391               else
6392                 {
6393                   GtkTreeIter parent_iter = iter;
6394                   gboolean has_parent;
6395
6396                   node = tree->parent_node;
6397                   tree = tree->parent_tree;
6398                   if (tree == NULL)
6399                     break;
6400                   has_parent = gtk_tree_model_iter_parent (tree_view->priv->model,
6401                                                            &iter,
6402                                                            &parent_iter);
6403                   gtk_tree_path_up (path);
6404
6405                   /* Sanity check */
6406                   TREE_VIEW_INTERNAL_ASSERT_VOID (has_parent);
6407                 }
6408             }
6409           while (!done);
6410         }
6411
6412       if (!node)
6413         break;
6414
6415       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) ||
6416           GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
6417         {
6418           _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
6419           if (validate_row (tree_view, tree, node, &iter, path))
6420               size_changed = TRUE;
6421         }
6422
6423       area_below -= gtk_tree_view_get_row_height (tree_view, node);
6424     }
6425   gtk_tree_path_free (path);
6426
6427   /* If we ran out of tree, and have extra area_below left, we need to add it
6428    * to area_above */
6429   if (area_below > 0)
6430     area_above += area_below;
6431
6432   _gtk_tree_view_find_node (tree_view, above_path, &tree, &node);
6433
6434   /* We walk backwards */
6435   while (area_above > 0)
6436     {
6437       _gtk_rbtree_prev_full (tree, node, &tree, &node);
6438
6439       /* Always find the new path in the tree.  We cannot just assume
6440        * a gtk_tree_path_prev() is enough here, as there might be children
6441        * in between this node and the previous sibling node.  If this
6442        * appears to be a performance hotspot in profiles, we can look into
6443        * intrigate logic for keeping path, node and iter in sync like
6444        * we do for forward walks.  (Which will be hard because of the lacking
6445        * iter_prev).
6446        */
6447
6448       if (node == NULL)
6449         break;
6450
6451       gtk_tree_path_free (above_path);
6452       above_path = _gtk_tree_view_find_path (tree_view, tree, node);
6453
6454       gtk_tree_model_get_iter (tree_view->priv->model, &iter, above_path);
6455
6456       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) ||
6457           GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
6458         {
6459           _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
6460           if (validate_row (tree_view, tree, node, &iter, above_path))
6461             size_changed = TRUE;
6462         }
6463       area_above -= gtk_tree_view_get_row_height (tree_view, node);
6464     }
6465
6466   /* if we scrolled to a path, we need to set the dy here,
6467    * and sync the top row accordingly
6468    */
6469   if (tree_view->priv->scroll_to_path)
6470     {
6471       gtk_tree_view_set_top_row (tree_view, above_path, -area_above);
6472       gtk_tree_view_top_row_to_dy (tree_view);
6473
6474       need_redraw = TRUE;
6475     }
6476   else if (tree_view->priv->height <= gtk_adjustment_get_page_size (tree_view->priv->vadjustment))
6477     {
6478       /* when we are not scrolling, we should never set dy to something
6479        * else than zero. we update top_row to be in sync with dy = 0.
6480        */
6481       gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment), 0);
6482       gtk_tree_view_dy_to_top_row (tree_view);
6483     }
6484   else if (gtk_adjustment_get_value (tree_view->priv->vadjustment) + gtk_adjustment_get_page_size (tree_view->priv->vadjustment) > tree_view->priv->height)
6485     {
6486       gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment), tree_view->priv->height - gtk_adjustment_get_page_size (tree_view->priv->vadjustment));
6487       gtk_tree_view_dy_to_top_row (tree_view);
6488     }
6489   else
6490     gtk_tree_view_top_row_to_dy (tree_view);
6491
6492   /* update width/height and queue a resize */
6493   if (size_changed)
6494     {
6495       GtkRequisition requisition;
6496
6497       /* We temporarily guess a size, under the assumption that it will be the
6498        * same when we get our next size_allocate.  If we don't do this, we'll be
6499        * in an inconsistent state if we call top_row_to_dy. */
6500
6501       gtk_widget_get_preferred_size (GTK_WIDGET (tree_view),
6502                                      &requisition, NULL);
6503       gtk_adjustment_set_upper (tree_view->priv->hadjustment,
6504                                 MAX (gtk_adjustment_get_upper (tree_view->priv->hadjustment), requisition.width));
6505       gtk_adjustment_set_upper (tree_view->priv->vadjustment,
6506                                 MAX (gtk_adjustment_get_upper (tree_view->priv->vadjustment), requisition.height));
6507       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
6508     }
6509
6510   if (tree_view->priv->scroll_to_path)
6511     {
6512       gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
6513       tree_view->priv->scroll_to_path = NULL;
6514     }
6515
6516   if (above_path)
6517     gtk_tree_path_free (above_path);
6518
6519   if (tree_view->priv->scroll_to_column)
6520     {
6521       tree_view->priv->scroll_to_column = NULL;
6522     }
6523   if (need_redraw)
6524     gtk_widget_queue_draw (GTK_WIDGET (tree_view));
6525 }
6526
6527 static void
6528 initialize_fixed_height_mode (GtkTreeView *tree_view)
6529 {
6530   if (!tree_view->priv->tree)
6531     return;
6532
6533   if (tree_view->priv->fixed_height < 0)
6534     {
6535       GtkTreeIter iter;
6536       GtkTreePath *path;
6537
6538       GtkRBTree *tree = NULL;
6539       GtkRBNode *node = NULL;
6540
6541       tree = tree_view->priv->tree;
6542       node = tree->root;
6543
6544       path = _gtk_tree_view_find_path (tree_view, tree, node);
6545       gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
6546
6547       validate_row (tree_view, tree, node, &iter, path);
6548
6549       gtk_tree_path_free (path);
6550
6551       tree_view->priv->fixed_height = gtk_tree_view_get_row_height (tree_view, node);
6552     }
6553
6554    _gtk_rbtree_set_fixed_height (tree_view->priv->tree,
6555                                  tree_view->priv->fixed_height, TRUE);
6556 }
6557
6558 /* Our strategy for finding nodes to validate is a little convoluted.  We find
6559  * the left-most uninvalidated node.  We then try walking right, validating
6560  * nodes.  Once we find a valid node, we repeat the previous process of finding
6561  * the first invalid node.
6562  */
6563
6564 static gboolean
6565 do_validate_rows (GtkTreeView *tree_view, gboolean queue_resize)
6566 {
6567   GtkRBTree *tree = NULL;
6568   GtkRBNode *node = NULL;
6569   gboolean validated_area = FALSE;
6570   gint retval = TRUE;
6571   GtkTreePath *path = NULL;
6572   GtkTreeIter iter;
6573   GTimer *timer;
6574   gint i = 0;
6575
6576   gint y = -1;
6577   gint prev_height = -1;
6578   gboolean fixed_height = TRUE;
6579
6580   g_assert (tree_view);
6581
6582   if (tree_view->priv->tree == NULL)
6583       return FALSE;
6584
6585   if (tree_view->priv->fixed_height_mode)
6586     {
6587       if (tree_view->priv->fixed_height < 0)
6588         initialize_fixed_height_mode (tree_view);
6589
6590       return FALSE;
6591     }
6592
6593   timer = g_timer_new ();
6594   g_timer_start (timer);
6595
6596   do
6597     {
6598       gboolean changed = FALSE;
6599
6600       if (! GTK_RBNODE_FLAG_SET (tree_view->priv->tree->root, GTK_RBNODE_DESCENDANTS_INVALID))
6601         {
6602           retval = FALSE;
6603           goto done;
6604         }
6605
6606       if (path != NULL)
6607         {
6608           node = _gtk_rbtree_next (tree, node);
6609           if (node != NULL)
6610             {
6611               TREE_VIEW_INTERNAL_ASSERT (gtk_tree_model_iter_next (tree_view->priv->model, &iter), FALSE);
6612               gtk_tree_path_next (path);
6613             }
6614           else
6615             {
6616               gtk_tree_path_free (path);
6617               path = NULL;
6618             }
6619         }
6620
6621       if (path == NULL)
6622         {
6623           tree = tree_view->priv->tree;
6624           node = tree_view->priv->tree->root;
6625
6626           g_assert (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_DESCENDANTS_INVALID));
6627
6628           do
6629             {
6630               if (node->left != tree->nil &&
6631                   GTK_RBNODE_FLAG_SET (node->left, GTK_RBNODE_DESCENDANTS_INVALID))
6632                 {
6633                   node = node->left;
6634                 }
6635               else if (node->right != tree->nil &&
6636                        GTK_RBNODE_FLAG_SET (node->right, GTK_RBNODE_DESCENDANTS_INVALID))
6637                 {
6638                   node = node->right;
6639                 }
6640               else if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) ||
6641                        GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
6642                 {
6643                   break;
6644                 }
6645               else if (node->children != NULL)
6646                 {
6647                   tree = node->children;
6648                   node = tree->root;
6649                 }
6650               else
6651                 /* RBTree corruption!  All bad */
6652                 g_assert_not_reached ();
6653             }
6654           while (TRUE);
6655           path = _gtk_tree_view_find_path (tree_view, tree, node);
6656           gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
6657         }
6658
6659       changed = validate_row (tree_view, tree, node, &iter, path);
6660       validated_area = changed || validated_area;
6661
6662       if (changed)
6663         {
6664           gint offset = gtk_tree_view_get_row_y_offset (tree_view, tree, node);
6665
6666           if (y == -1 || y > offset)
6667             y = offset;
6668         }
6669
6670       if (!tree_view->priv->fixed_height_check)
6671         {
6672           gint height;
6673
6674           height = gtk_tree_view_get_row_height (tree_view, node);
6675           if (prev_height < 0)
6676             prev_height = height;
6677           else if (prev_height != height)
6678             fixed_height = FALSE;
6679         }
6680
6681       i++;
6682     }
6683   while (g_timer_elapsed (timer, NULL) < GTK_TREE_VIEW_TIME_MS_PER_IDLE / 1000.);
6684
6685   if (!tree_view->priv->fixed_height_check)
6686    {
6687      if (fixed_height)
6688        _gtk_rbtree_set_fixed_height (tree_view->priv->tree, prev_height, FALSE);
6689
6690      tree_view->priv->fixed_height_check = 1;
6691    }
6692
6693  done:
6694   if (validated_area)
6695     {
6696       GtkRequisition requisition;
6697
6698       /* We temporarily guess a size, under the assumption that it will be the
6699        * same when we get our next size_allocate.  If we don't do this, we'll be
6700        * in an inconsistent state when we call top_row_to_dy. */
6701
6702       /* FIXME: This is called from size_request, for some reason it is not infinitely
6703        * recursing, we cannot call gtk_widget_get_preferred_size() here because that's
6704        * not allowed (from inside ->get_preferred_width/height() implementations, one
6705        * should call the vfuncs directly). However what is desired here is the full
6706        * size including any margins and limited by any alignment (i.e. after
6707        * GtkWidget:adjust_size_request() is called).
6708        *
6709        * Currently bypassing this but the real solution is to not update the scroll adjustments
6710        * untill we've recieved an allocation (never update scroll adjustments from size-requests).
6711        */
6712       gtk_tree_view_size_request (GTK_WIDGET (tree_view), &requisition, FALSE);
6713
6714       /* If rows above the current position have changed height, this has
6715        * affected the current view and thus needs a redraw.
6716        */
6717       if (y != -1 && y < gtk_adjustment_get_value (tree_view->priv->vadjustment))
6718         gtk_widget_queue_draw (GTK_WIDGET (tree_view));
6719
6720       gtk_adjustment_set_upper (tree_view->priv->hadjustment,
6721                                 MAX (gtk_adjustment_get_upper (tree_view->priv->hadjustment), requisition.width));
6722       gtk_adjustment_set_upper (tree_view->priv->vadjustment,
6723                                 MAX (gtk_adjustment_get_upper (tree_view->priv->vadjustment), requisition.height));
6724
6725       if (queue_resize)
6726         gtk_widget_queue_resize_no_redraw (GTK_WIDGET (tree_view));
6727     }
6728
6729   if (path) gtk_tree_path_free (path);
6730   g_timer_destroy (timer);
6731
6732   return retval;
6733 }
6734
6735 static gboolean
6736 validate_rows (GtkTreeView *tree_view)
6737 {
6738   gboolean retval;
6739
6740   retval = do_validate_rows (tree_view, TRUE);
6741
6742   if (! retval && tree_view->priv->validate_rows_timer)
6743     {
6744       g_source_remove (tree_view->priv->validate_rows_timer);
6745       tree_view->priv->validate_rows_timer = 0;
6746     }
6747
6748   return retval;
6749 }
6750
6751 static gboolean
6752 validate_rows_handler (GtkTreeView *tree_view)
6753 {
6754   gboolean retval;
6755
6756   retval = do_validate_rows (tree_view, TRUE);
6757   if (! retval && tree_view->priv->validate_rows_timer)
6758     {
6759       g_source_remove (tree_view->priv->validate_rows_timer);
6760       tree_view->priv->validate_rows_timer = 0;
6761     }
6762
6763   return retval;
6764 }
6765
6766 static gboolean
6767 do_presize_handler (GtkTreeView *tree_view)
6768 {
6769   if (tree_view->priv->mark_rows_col_dirty)
6770     {
6771       if (tree_view->priv->tree)
6772         _gtk_rbtree_column_invalid (tree_view->priv->tree);
6773       tree_view->priv->mark_rows_col_dirty = FALSE;
6774     }
6775   validate_visible_area (tree_view);
6776   tree_view->priv->presize_handler_timer = 0;
6777
6778   if (tree_view->priv->fixed_height_mode)
6779     {
6780       GtkRequisition requisition;
6781
6782       gtk_widget_get_preferred_size (GTK_WIDGET (tree_view),
6783                                      &requisition, NULL);
6784
6785       gtk_adjustment_set_upper (tree_view->priv->hadjustment,
6786                                 MAX (gtk_adjustment_get_upper (tree_view->priv->hadjustment), requisition.width));
6787       gtk_adjustment_set_upper (tree_view->priv->vadjustment,
6788                                 MAX (gtk_adjustment_get_upper (tree_view->priv->vadjustment), requisition.height));
6789       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
6790     }
6791
6792   return FALSE;
6793 }
6794
6795 static gboolean
6796 presize_handler_callback (gpointer data)
6797 {
6798   do_presize_handler (GTK_TREE_VIEW (data));
6799
6800   return FALSE;
6801 }
6802
6803 static void
6804 install_presize_handler (GtkTreeView *tree_view)
6805 {
6806   if (! gtk_widget_get_realized (GTK_WIDGET (tree_view)))
6807     return;
6808
6809   if (! tree_view->priv->presize_handler_timer)
6810     {
6811       tree_view->priv->presize_handler_timer =
6812         gdk_threads_add_idle_full (GTK_PRIORITY_RESIZE - 2, presize_handler_callback, tree_view, NULL);
6813     }
6814   if (! tree_view->priv->validate_rows_timer)
6815     {
6816       tree_view->priv->validate_rows_timer =
6817         gdk_threads_add_idle_full (GTK_TREE_VIEW_PRIORITY_VALIDATE, (GSourceFunc) validate_rows_handler, tree_view, NULL);
6818     }
6819 }
6820
6821 static void
6822 gtk_tree_view_bin_process_updates (GtkTreeView *tree_view)
6823 {
6824   /* Prior to drawing, we make sure the visible area is validated. */
6825   if (tree_view->priv->presize_handler_timer)
6826     {
6827       g_source_remove (tree_view->priv->presize_handler_timer);
6828       tree_view->priv->presize_handler_timer = 0;
6829
6830       do_presize_handler (tree_view);
6831     }
6832
6833   gdk_window_process_updates (tree_view->priv->bin_window, TRUE);
6834 }
6835
6836 static gboolean
6837 scroll_sync_handler (GtkTreeView *tree_view)
6838 {
6839   if (tree_view->priv->height <= gtk_adjustment_get_page_size (tree_view->priv->vadjustment))
6840     gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment), 0);
6841   else if (gtk_tree_row_reference_valid (tree_view->priv->top_row))
6842     gtk_tree_view_top_row_to_dy (tree_view);
6843   else
6844     gtk_tree_view_dy_to_top_row (tree_view);
6845
6846   tree_view->priv->scroll_sync_timer = 0;
6847
6848   return FALSE;
6849 }
6850
6851 static void
6852 install_scroll_sync_handler (GtkTreeView *tree_view)
6853 {
6854   if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
6855     return;
6856
6857   if (!tree_view->priv->scroll_sync_timer)
6858     {
6859       tree_view->priv->scroll_sync_timer =
6860         gdk_threads_add_idle_full (GTK_TREE_VIEW_PRIORITY_SCROLL_SYNC, (GSourceFunc) scroll_sync_handler, tree_view, NULL);
6861     }
6862 }
6863
6864 static void
6865 gtk_tree_view_set_top_row (GtkTreeView *tree_view,
6866                            GtkTreePath *path,
6867                            gint         offset)
6868 {
6869   gtk_tree_row_reference_free (tree_view->priv->top_row);
6870
6871   if (!path)
6872     {
6873       tree_view->priv->top_row = NULL;
6874       tree_view->priv->top_row_dy = 0;
6875     }
6876   else
6877     {
6878       tree_view->priv->top_row = gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view), tree_view->priv->model, path);
6879       tree_view->priv->top_row_dy = offset;
6880     }
6881 }
6882
6883 /* Always call this iff dy is in the visible range.  If the tree is empty, then
6884  * it's set to be NULL, and top_row_dy is 0;
6885  */
6886 static void
6887 gtk_tree_view_dy_to_top_row (GtkTreeView *tree_view)
6888 {
6889   gint offset;
6890   GtkTreePath *path;
6891   GtkRBTree *tree;
6892   GtkRBNode *node;
6893
6894   if (tree_view->priv->tree == NULL)
6895     {
6896       gtk_tree_view_set_top_row (tree_view, NULL, 0);
6897     }
6898   else
6899     {
6900       offset = _gtk_rbtree_find_offset (tree_view->priv->tree,
6901                                         tree_view->priv->dy,
6902                                         &tree, &node);
6903
6904       if (tree == NULL)
6905         {
6906           gtk_tree_view_set_top_row (tree_view, NULL, 0);
6907         }
6908       else
6909         {
6910           path = _gtk_tree_view_find_path (tree_view, tree, node);
6911           gtk_tree_view_set_top_row (tree_view, path, offset);
6912           gtk_tree_path_free (path);
6913         }
6914     }
6915 }
6916
6917 static void
6918 gtk_tree_view_top_row_to_dy (GtkTreeView *tree_view)
6919 {
6920   GtkTreePath *path;
6921   GtkRBTree *tree;
6922   GtkRBNode *node;
6923   int new_dy;
6924
6925   /* Avoid recursive calls */
6926   if (tree_view->priv->in_top_row_to_dy)
6927     return;
6928
6929   if (tree_view->priv->top_row)
6930     path = gtk_tree_row_reference_get_path (tree_view->priv->top_row);
6931   else
6932     path = NULL;
6933
6934   if (!path)
6935     tree = NULL;
6936   else
6937     _gtk_tree_view_find_node (tree_view, path, &tree, &node);
6938
6939   if (path)
6940     gtk_tree_path_free (path);
6941
6942   if (tree == NULL)
6943     {
6944       /* keep dy and set new toprow */
6945       gtk_tree_row_reference_free (tree_view->priv->top_row);
6946       tree_view->priv->top_row = NULL;
6947       tree_view->priv->top_row_dy = 0;
6948       /* DO NOT install the idle handler */
6949       gtk_tree_view_dy_to_top_row (tree_view);
6950       return;
6951     }
6952
6953   if (gtk_tree_view_get_row_height (tree_view, node)
6954       < tree_view->priv->top_row_dy)
6955     {
6956       /* new top row -- do NOT install the idle handler */
6957       gtk_tree_view_dy_to_top_row (tree_view);
6958       return;
6959     }
6960
6961   new_dy = _gtk_rbtree_node_find_offset (tree, node);
6962   new_dy += tree_view->priv->top_row_dy;
6963
6964   if (new_dy + gtk_adjustment_get_page_size (tree_view->priv->vadjustment) > tree_view->priv->height)
6965     new_dy = tree_view->priv->height - gtk_adjustment_get_page_size (tree_view->priv->vadjustment);
6966
6967   new_dy = MAX (0, new_dy);
6968
6969   tree_view->priv->in_top_row_to_dy = TRUE;
6970   gtk_adjustment_set_value (tree_view->priv->vadjustment, (gdouble)new_dy);
6971   tree_view->priv->in_top_row_to_dy = FALSE;
6972 }
6973
6974
6975 void
6976 _gtk_tree_view_install_mark_rows_col_dirty (GtkTreeView *tree_view,
6977                                             gboolean     install_handler)
6978 {
6979   tree_view->priv->mark_rows_col_dirty = TRUE;
6980
6981   if (install_handler)
6982     install_presize_handler (tree_view);
6983 }
6984
6985 /*
6986  * This function works synchronously (due to the while (validate_rows...)
6987  * loop).
6988  *
6989  * There was a check for column_type != GTK_TREE_VIEW_COLUMN_AUTOSIZE
6990  * here. You now need to check that yourself.
6991  */
6992 void
6993 _gtk_tree_view_column_autosize (GtkTreeView *tree_view,
6994                                 GtkTreeViewColumn *column)
6995 {
6996   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
6997   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (column));
6998
6999   _gtk_tree_view_column_cell_set_dirty (column, FALSE);
7000
7001   do_presize_handler (tree_view);
7002   while (validate_rows (tree_view));
7003
7004   gtk_widget_queue_resize (GTK_WIDGET (tree_view));
7005 }
7006
7007 /* Drag-and-drop */
7008
7009 static void
7010 set_source_row (GdkDragContext *context,
7011                 GtkTreeModel   *model,
7012                 GtkTreePath    *source_row)
7013 {
7014   g_object_set_data_full (G_OBJECT (context),
7015                           I_("gtk-tree-view-source-row"),
7016                           source_row ? gtk_tree_row_reference_new (model, source_row) : NULL,
7017                           (GDestroyNotify) (source_row ? gtk_tree_row_reference_free : NULL));
7018 }
7019
7020 static GtkTreePath*
7021 get_source_row (GdkDragContext *context)
7022 {
7023   GtkTreeRowReference *ref =
7024     g_object_get_data (G_OBJECT (context), "gtk-tree-view-source-row");
7025
7026   if (ref)
7027     return gtk_tree_row_reference_get_path (ref);
7028   else
7029     return NULL;
7030 }
7031
7032 typedef struct
7033 {
7034   GtkTreeRowReference *dest_row;
7035   guint                path_down_mode   : 1;
7036   guint                empty_view_drop  : 1;
7037   guint                drop_append_mode : 1;
7038 }
7039 DestRow;
7040
7041 static void
7042 dest_row_free (gpointer data)
7043 {
7044   DestRow *dr = (DestRow *)data;
7045
7046   gtk_tree_row_reference_free (dr->dest_row);
7047   g_slice_free (DestRow, dr);
7048 }
7049
7050 static void
7051 set_dest_row (GdkDragContext *context,
7052               GtkTreeModel   *model,
7053               GtkTreePath    *dest_row,
7054               gboolean        path_down_mode,
7055               gboolean        empty_view_drop,
7056               gboolean        drop_append_mode)
7057 {
7058   DestRow *dr;
7059
7060   if (!dest_row)
7061     {
7062       g_object_set_data_full (G_OBJECT (context), I_("gtk-tree-view-dest-row"),
7063                               NULL, NULL);
7064       return;
7065     }
7066
7067   dr = g_slice_new (DestRow);
7068
7069   dr->dest_row = gtk_tree_row_reference_new (model, dest_row);
7070   dr->path_down_mode = path_down_mode != FALSE;
7071   dr->empty_view_drop = empty_view_drop != FALSE;
7072   dr->drop_append_mode = drop_append_mode != FALSE;
7073
7074   g_object_set_data_full (G_OBJECT (context), I_("gtk-tree-view-dest-row"),
7075                           dr, (GDestroyNotify) dest_row_free);
7076 }
7077
7078 static GtkTreePath*
7079 get_dest_row (GdkDragContext *context,
7080               gboolean       *path_down_mode)
7081 {
7082   DestRow *dr =
7083     g_object_get_data (G_OBJECT (context), "gtk-tree-view-dest-row");
7084
7085   if (dr)
7086     {
7087       GtkTreePath *path = NULL;
7088
7089       if (path_down_mode)
7090         *path_down_mode = dr->path_down_mode;
7091
7092       if (dr->dest_row)
7093         path = gtk_tree_row_reference_get_path (dr->dest_row);
7094       else if (dr->empty_view_drop)
7095         path = gtk_tree_path_new_from_indices (0, -1);
7096       else
7097         path = NULL;
7098
7099       if (path && dr->drop_append_mode)
7100         gtk_tree_path_next (path);
7101
7102       return path;
7103     }
7104   else
7105     return NULL;
7106 }
7107
7108 /* Get/set whether drag_motion requested the drag data and
7109  * drag_data_received should thus not actually insert the data,
7110  * since the data doesn't result from a drop.
7111  */
7112 static void
7113 set_status_pending (GdkDragContext *context,
7114                     GdkDragAction   suggested_action)
7115 {
7116   g_object_set_data (G_OBJECT (context),
7117                      I_("gtk-tree-view-status-pending"),
7118                      GINT_TO_POINTER (suggested_action));
7119 }
7120
7121 static GdkDragAction
7122 get_status_pending (GdkDragContext *context)
7123 {
7124   return GPOINTER_TO_INT (g_object_get_data (G_OBJECT (context),
7125                                              "gtk-tree-view-status-pending"));
7126 }
7127
7128 static TreeViewDragInfo*
7129 get_info (GtkTreeView *tree_view)
7130 {
7131   return g_object_get_data (G_OBJECT (tree_view), "gtk-tree-view-drag-info");
7132 }
7133
7134 static void
7135 destroy_info (TreeViewDragInfo *di)
7136 {
7137   g_slice_free (TreeViewDragInfo, di);
7138 }
7139
7140 static TreeViewDragInfo*
7141 ensure_info (GtkTreeView *tree_view)
7142 {
7143   TreeViewDragInfo *di;
7144
7145   di = get_info (tree_view);
7146
7147   if (di == NULL)
7148     {
7149       di = g_slice_new0 (TreeViewDragInfo);
7150
7151       g_object_set_data_full (G_OBJECT (tree_view),
7152                               I_("gtk-tree-view-drag-info"),
7153                               di,
7154                               (GDestroyNotify) destroy_info);
7155     }
7156
7157   return di;
7158 }
7159
7160 static void
7161 remove_info (GtkTreeView *tree_view)
7162 {
7163   g_object_set_data (G_OBJECT (tree_view), I_("gtk-tree-view-drag-info"), NULL);
7164 }
7165
7166 #if 0
7167 static gint
7168 drag_scan_timeout (gpointer data)
7169 {
7170   GtkTreeView *tree_view;
7171   gint x, y;
7172   GdkModifierType state;
7173   GtkTreePath *path = NULL;
7174   GtkTreeViewColumn *column = NULL;
7175   GdkRectangle visible_rect;
7176
7177   GDK_THREADS_ENTER ();
7178
7179   tree_view = GTK_TREE_VIEW (data);
7180
7181   gdk_window_get_device_position (tree_view->priv->bin_window,
7182                                   gdk_device_manager_get_client_pointer (
7183                                     gdk_display_get_device_manager (
7184                                       gtk_widget_get_display (GTK_WIDGET (tree_view)))),
7185                                   &x, &y, &state);
7186
7187   gtk_tree_view_get_visible_rect (tree_view, &visible_rect);
7188
7189   /* See if we are near the edge. */
7190   if ((x - visible_rect.x) < SCROLL_EDGE_SIZE ||
7191       (visible_rect.x + visible_rect.width - x) < SCROLL_EDGE_SIZE ||
7192       (y - visible_rect.y) < SCROLL_EDGE_SIZE ||
7193       (visible_rect.y + visible_rect.height - y) < SCROLL_EDGE_SIZE)
7194     {
7195       gtk_tree_view_get_path_at_pos (tree_view,
7196                                      tree_view->priv->bin_window,
7197                                      x, y,
7198                                      &path,
7199                                      &column,
7200                                      NULL,
7201                                      NULL);
7202
7203       if (path != NULL)
7204         {
7205           gtk_tree_view_scroll_to_cell (tree_view,
7206                                         path,
7207                                         column,
7208                                         TRUE,
7209                                         0.5, 0.5);
7210
7211           gtk_tree_path_free (path);
7212         }
7213     }
7214
7215   GDK_THREADS_LEAVE ();
7216
7217   return TRUE;
7218 }
7219 #endif /* 0 */
7220
7221 static void
7222 add_scroll_timeout (GtkTreeView *tree_view)
7223 {
7224   if (tree_view->priv->scroll_timeout == 0)
7225     {
7226       tree_view->priv->scroll_timeout =
7227         gdk_threads_add_timeout (150, scroll_row_timeout, tree_view);
7228     }
7229 }
7230
7231 static void
7232 remove_scroll_timeout (GtkTreeView *tree_view)
7233 {
7234   if (tree_view->priv->scroll_timeout != 0)
7235     {
7236       g_source_remove (tree_view->priv->scroll_timeout);
7237       tree_view->priv->scroll_timeout = 0;
7238     }
7239 }
7240
7241 static gboolean
7242 check_model_dnd (GtkTreeModel *model,
7243                  GType         required_iface,
7244                  const gchar  *signal)
7245 {
7246   if (model == NULL || !G_TYPE_CHECK_INSTANCE_TYPE ((model), required_iface))
7247     {
7248       g_warning ("You must override the default '%s' handler "
7249                  "on GtkTreeView when using models that don't support "
7250                  "the %s interface and enabling drag-and-drop. The simplest way to do this "
7251                  "is to connect to '%s' and call "
7252                  "g_signal_stop_emission_by_name() in your signal handler to prevent "
7253                  "the default handler from running. Look at the source code "
7254                  "for the default handler in gtktreeview.c to get an idea what "
7255                  "your handler should do. (gtktreeview.c is in the GTK source "
7256                  "code.) If you're using GTK from a language other than C, "
7257                  "there may be a more natural way to override default handlers, e.g. via derivation.",
7258                  signal, g_type_name (required_iface), signal);
7259       return FALSE;
7260     }
7261   else
7262     return TRUE;
7263 }
7264
7265 static void
7266 remove_open_timeout (GtkTreeView *tree_view)
7267 {
7268   if (tree_view->priv->open_dest_timeout != 0)
7269     {
7270       g_source_remove (tree_view->priv->open_dest_timeout);
7271       tree_view->priv->open_dest_timeout = 0;
7272     }
7273 }
7274
7275
7276 static gint
7277 open_row_timeout (gpointer data)
7278 {
7279   GtkTreeView *tree_view = data;
7280   GtkTreePath *dest_path = NULL;
7281   GtkTreeViewDropPosition pos;
7282   gboolean result = FALSE;
7283
7284   gtk_tree_view_get_drag_dest_row (tree_view,
7285                                    &dest_path,
7286                                    &pos);
7287
7288   if (dest_path &&
7289       (pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER ||
7290        pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE))
7291     {
7292       gtk_tree_view_expand_row (tree_view, dest_path, FALSE);
7293       tree_view->priv->open_dest_timeout = 0;
7294
7295       gtk_tree_path_free (dest_path);
7296     }
7297   else
7298     {
7299       if (dest_path)
7300         gtk_tree_path_free (dest_path);
7301
7302       result = TRUE;
7303     }
7304
7305   return result;
7306 }
7307
7308 static gboolean
7309 scroll_row_timeout (gpointer data)
7310 {
7311   GtkTreeView *tree_view = data;
7312
7313   gtk_tree_view_vertical_autoscroll (tree_view);
7314
7315   if (tree_view->priv->rubber_band_status == RUBBER_BAND_ACTIVE)
7316     gtk_tree_view_update_rubber_band (tree_view);
7317
7318   return TRUE;
7319 }
7320
7321 /* Returns TRUE if event should not be propagated to parent widgets */
7322 static gboolean
7323 set_destination_row (GtkTreeView    *tree_view,
7324                      GdkDragContext *context,
7325                      /* coordinates relative to the widget */
7326                      gint            x,
7327                      gint            y,
7328                      GdkDragAction  *suggested_action,
7329                      GdkAtom        *target)
7330 {
7331   GtkTreePath *path = NULL;
7332   GtkTreeViewDropPosition pos;
7333   GtkTreeViewDropPosition old_pos;
7334   TreeViewDragInfo *di;
7335   GtkWidget *widget;
7336   GtkTreePath *old_dest_path = NULL;
7337   gboolean can_drop = FALSE;
7338
7339   *suggested_action = 0;
7340   *target = GDK_NONE;
7341
7342   widget = GTK_WIDGET (tree_view);
7343
7344   di = get_info (tree_view);
7345
7346   if (di == NULL || y - gtk_tree_view_get_effective_header_height (tree_view) < 0)
7347     {
7348       /* someone unset us as a drag dest, note that if
7349        * we return FALSE drag_leave isn't called
7350        */
7351
7352       gtk_tree_view_set_drag_dest_row (tree_view,
7353                                        NULL,
7354                                        GTK_TREE_VIEW_DROP_BEFORE);
7355
7356       remove_scroll_timeout (GTK_TREE_VIEW (widget));
7357       remove_open_timeout (GTK_TREE_VIEW (widget));
7358
7359       return FALSE; /* no longer a drop site */
7360     }
7361
7362   *target = gtk_drag_dest_find_target (widget, context,
7363                                        gtk_drag_dest_get_target_list (widget));
7364   if (*target == GDK_NONE)
7365     {
7366       return FALSE;
7367     }
7368
7369   if (!gtk_tree_view_get_dest_row_at_pos (tree_view,
7370                                           x, y,
7371                                           &path,
7372                                           &pos))
7373     {
7374       gint n_children;
7375       GtkTreeModel *model;
7376
7377       remove_open_timeout (tree_view);
7378
7379       /* the row got dropped on empty space, let's setup a special case
7380        */
7381
7382       if (path)
7383         gtk_tree_path_free (path);
7384
7385       model = gtk_tree_view_get_model (tree_view);
7386
7387       n_children = gtk_tree_model_iter_n_children (model, NULL);
7388       if (n_children)
7389         {
7390           pos = GTK_TREE_VIEW_DROP_AFTER;
7391           path = gtk_tree_path_new_from_indices (n_children - 1, -1);
7392         }
7393       else
7394         {
7395           pos = GTK_TREE_VIEW_DROP_BEFORE;
7396           path = gtk_tree_path_new_from_indices (0, -1);
7397         }
7398
7399       can_drop = TRUE;
7400
7401       goto out;
7402     }
7403
7404   g_assert (path);
7405
7406   /* If we left the current row's "open" zone, unset the timeout for
7407    * opening the row
7408    */
7409   gtk_tree_view_get_drag_dest_row (tree_view,
7410                                    &old_dest_path,
7411                                    &old_pos);
7412
7413   if (old_dest_path &&
7414       (gtk_tree_path_compare (path, old_dest_path) != 0 ||
7415        !(pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER ||
7416          pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE)))
7417     remove_open_timeout (tree_view);
7418
7419   if (old_dest_path)
7420     gtk_tree_path_free (old_dest_path);
7421
7422   if (TRUE /* FIXME if the location droppable predicate */)
7423     {
7424       can_drop = TRUE;
7425     }
7426
7427 out:
7428   if (can_drop)
7429     {
7430       GtkWidget *source_widget;
7431
7432       *suggested_action = gdk_drag_context_get_suggested_action (context);
7433       source_widget = gtk_drag_get_source_widget (context);
7434
7435       if (source_widget == widget)
7436         {
7437           /* Default to MOVE, unless the user has
7438            * pressed ctrl or shift to affect available actions
7439            */
7440           if ((gdk_drag_context_get_actions (context) & GDK_ACTION_MOVE) != 0)
7441             *suggested_action = GDK_ACTION_MOVE;
7442         }
7443
7444       gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
7445                                        path, pos);
7446     }
7447   else
7448     {
7449       /* can't drop here */
7450       remove_open_timeout (tree_view);
7451
7452       gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
7453                                        NULL,
7454                                        GTK_TREE_VIEW_DROP_BEFORE);
7455     }
7456
7457   if (path)
7458     gtk_tree_path_free (path);
7459
7460   return TRUE;
7461 }
7462
7463 static GtkTreePath*
7464 get_logical_dest_row (GtkTreeView *tree_view,
7465                       gboolean    *path_down_mode,
7466                       gboolean    *drop_append_mode)
7467 {
7468   /* adjust path to point to the row the drop goes in front of */
7469   GtkTreePath *path = NULL;
7470   GtkTreeViewDropPosition pos;
7471
7472   g_return_val_if_fail (path_down_mode != NULL, NULL);
7473   g_return_val_if_fail (drop_append_mode != NULL, NULL);
7474
7475   *path_down_mode = FALSE;
7476   *drop_append_mode = 0;
7477
7478   gtk_tree_view_get_drag_dest_row (tree_view, &path, &pos);
7479
7480   if (path == NULL)
7481     return NULL;
7482
7483   if (pos == GTK_TREE_VIEW_DROP_BEFORE)
7484     ; /* do nothing */
7485   else if (pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE ||
7486            pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER)
7487     *path_down_mode = TRUE;
7488   else
7489     {
7490       GtkTreeIter iter;
7491       GtkTreeModel *model = gtk_tree_view_get_model (tree_view);
7492
7493       g_assert (pos == GTK_TREE_VIEW_DROP_AFTER);
7494
7495       if (!gtk_tree_model_get_iter (model, &iter, path) ||
7496           !gtk_tree_model_iter_next (model, &iter))
7497         *drop_append_mode = 1;
7498       else
7499         {
7500           *drop_append_mode = 0;
7501           gtk_tree_path_next (path);
7502         }
7503     }
7504
7505   return path;
7506 }
7507
7508 static gboolean
7509 gtk_tree_view_maybe_begin_dragging_row (GtkTreeView      *tree_view,
7510                                         GdkEventMotion   *event)
7511 {
7512   GtkWidget *widget = GTK_WIDGET (tree_view);
7513   GdkDragContext *context;
7514   TreeViewDragInfo *di;
7515   GtkTreePath *path = NULL;
7516   gint button;
7517   gint cell_x, cell_y;
7518   GtkTreeModel *model;
7519   gboolean retval = FALSE;
7520
7521   di = get_info (tree_view);
7522
7523   if (di == NULL || !di->source_set)
7524     goto out;
7525
7526   if (tree_view->priv->pressed_button < 0)
7527     goto out;
7528
7529   if (!gtk_drag_check_threshold (widget,
7530                                  tree_view->priv->press_start_x,
7531                                  tree_view->priv->press_start_y,
7532                                  event->x, event->y))
7533     goto out;
7534
7535   model = gtk_tree_view_get_model (tree_view);
7536
7537   if (model == NULL)
7538     goto out;
7539
7540   button = tree_view->priv->pressed_button;
7541   tree_view->priv->pressed_button = -1;
7542
7543   gtk_tree_view_get_path_at_pos (tree_view,
7544                                  tree_view->priv->press_start_x,
7545                                  tree_view->priv->press_start_y,
7546                                  &path,
7547                                  NULL,
7548                                  &cell_x,
7549                                  &cell_y);
7550
7551   if (path == NULL)
7552     goto out;
7553
7554   if (!GTK_IS_TREE_DRAG_SOURCE (model) ||
7555       !gtk_tree_drag_source_row_draggable (GTK_TREE_DRAG_SOURCE (model),
7556                                            path))
7557     goto out;
7558
7559   if (!(GDK_BUTTON1_MASK << (button - 1) & di->start_button_mask))
7560     goto out;
7561
7562   /* Now we can begin the drag */
7563
7564   retval = TRUE;
7565
7566   context = gtk_drag_begin (widget,
7567                             gtk_drag_source_get_target_list (widget),
7568                             di->source_actions,
7569                             button,
7570                             (GdkEvent*)event);
7571
7572   set_source_row (context, model, path);
7573
7574  out:
7575   if (path)
7576     gtk_tree_path_free (path);
7577
7578   return retval;
7579 }
7580
7581
7582 static void
7583 gtk_tree_view_drag_begin (GtkWidget      *widget,
7584                           GdkDragContext *context)
7585 {
7586   GtkTreeView *tree_view;
7587   GtkTreePath *path = NULL;
7588   gint cell_x, cell_y;
7589   cairo_surface_t *row_pix;
7590   TreeViewDragInfo *di;
7591
7592   tree_view = GTK_TREE_VIEW (widget);
7593
7594   /* if the user uses a custom DND source impl, we don't set the icon here */
7595   di = get_info (tree_view);
7596
7597   if (di == NULL || !di->source_set)
7598     return;
7599
7600   gtk_tree_view_get_path_at_pos (tree_view,
7601                                  tree_view->priv->press_start_x,
7602                                  tree_view->priv->press_start_y,
7603                                  &path,
7604                                  NULL,
7605                                  &cell_x,
7606                                  &cell_y);
7607
7608   /* If path is NULL, there's nothing we can drag.  For now, we silently
7609    * bail out.  Actually, dragging should not be possible from an empty
7610    * tree view, but there's no way we can cancel that from here.
7611    * Automatically unsetting the tree view as drag source for empty models
7612    * is something that would likely break other people's code ...
7613    */
7614   if (!path)
7615     return;
7616
7617   row_pix = gtk_tree_view_create_row_drag_icon (tree_view,
7618                                                 path);
7619   cairo_surface_set_device_offset (row_pix,
7620                                    /* the + 1 is for the black border in the icon */
7621                                    - (tree_view->priv->press_start_x + 1),
7622                                    - (cell_y + 1));
7623
7624   gtk_drag_set_icon_surface (context, row_pix);
7625
7626   cairo_surface_destroy (row_pix);
7627   gtk_tree_path_free (path);
7628 }
7629
7630 static void
7631 gtk_tree_view_drag_end (GtkWidget      *widget,
7632                         GdkDragContext *context)
7633 {
7634   /* do nothing */
7635 }
7636
7637 /* Default signal implementations for the drag signals */
7638 static void
7639 gtk_tree_view_drag_data_get (GtkWidget        *widget,
7640                              GdkDragContext   *context,
7641                              GtkSelectionData *selection_data,
7642                              guint             info,
7643                              guint             time)
7644 {
7645   GtkTreeView *tree_view;
7646   GtkTreeModel *model;
7647   TreeViewDragInfo *di;
7648   GtkTreePath *source_row;
7649
7650   tree_view = GTK_TREE_VIEW (widget);
7651
7652   model = gtk_tree_view_get_model (tree_view);
7653
7654   if (model == NULL)
7655     return;
7656
7657   di = get_info (GTK_TREE_VIEW (widget));
7658
7659   if (di == NULL)
7660     return;
7661
7662   source_row = get_source_row (context);
7663
7664   if (source_row == NULL)
7665     return;
7666
7667   /* We can implement the GTK_TREE_MODEL_ROW target generically for
7668    * any model; for DragSource models there are some other targets
7669    * we also support.
7670    */
7671
7672   if (GTK_IS_TREE_DRAG_SOURCE (model) &&
7673       gtk_tree_drag_source_drag_data_get (GTK_TREE_DRAG_SOURCE (model),
7674                                           source_row,
7675                                           selection_data))
7676     goto done;
7677
7678   /* If drag_data_get does nothing, try providing row data. */
7679   if (gtk_selection_data_get_target (selection_data) == gdk_atom_intern_static_string ("GTK_TREE_MODEL_ROW"))
7680     {
7681       gtk_tree_set_row_drag_data (selection_data,
7682                                   model,
7683                                   source_row);
7684     }
7685
7686  done:
7687   gtk_tree_path_free (source_row);
7688 }
7689
7690
7691 static void
7692 gtk_tree_view_drag_data_delete (GtkWidget      *widget,
7693                                 GdkDragContext *context)
7694 {
7695   TreeViewDragInfo *di;
7696   GtkTreeModel *model;
7697   GtkTreeView *tree_view;
7698   GtkTreePath *source_row;
7699
7700   tree_view = GTK_TREE_VIEW (widget);
7701   model = gtk_tree_view_get_model (tree_view);
7702
7703   if (!check_model_dnd (model, GTK_TYPE_TREE_DRAG_SOURCE, "drag_data_delete"))
7704     return;
7705
7706   di = get_info (tree_view);
7707
7708   if (di == NULL)
7709     return;
7710
7711   source_row = get_source_row (context);
7712
7713   if (source_row == NULL)
7714     return;
7715
7716   gtk_tree_drag_source_drag_data_delete (GTK_TREE_DRAG_SOURCE (model),
7717                                          source_row);
7718
7719   gtk_tree_path_free (source_row);
7720
7721   set_source_row (context, NULL, NULL);
7722 }
7723
7724 static void
7725 gtk_tree_view_drag_leave (GtkWidget      *widget,
7726                           GdkDragContext *context,
7727                           guint             time)
7728 {
7729   /* unset any highlight row */
7730   gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
7731                                    NULL,
7732                                    GTK_TREE_VIEW_DROP_BEFORE);
7733
7734   remove_scroll_timeout (GTK_TREE_VIEW (widget));
7735   remove_open_timeout (GTK_TREE_VIEW (widget));
7736 }
7737
7738
7739 static gboolean
7740 gtk_tree_view_drag_motion (GtkWidget        *widget,
7741                            GdkDragContext   *context,
7742                            /* coordinates relative to the widget */
7743                            gint              x,
7744                            gint              y,
7745                            guint             time)
7746 {
7747   gboolean empty;
7748   GtkTreePath *path = NULL;
7749   GtkTreeViewDropPosition pos;
7750   GtkTreeView *tree_view;
7751   GdkDragAction suggested_action = 0;
7752   GdkAtom target;
7753
7754   tree_view = GTK_TREE_VIEW (widget);
7755
7756   if (!set_destination_row (tree_view, context, x, y, &suggested_action, &target))
7757     return FALSE;
7758
7759   gtk_tree_view_get_drag_dest_row (tree_view, &path, &pos);
7760
7761   /* we only know this *after* set_desination_row */
7762   empty = tree_view->priv->empty_view_drop;
7763
7764   if (path == NULL && !empty)
7765     {
7766       /* Can't drop here. */
7767       gdk_drag_status (context, 0, time);
7768     }
7769   else
7770     {
7771       if (tree_view->priv->open_dest_timeout == 0 &&
7772           (pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER ||
7773            pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE))
7774         {
7775           tree_view->priv->open_dest_timeout =
7776             gdk_threads_add_timeout (AUTO_EXPAND_TIMEOUT, open_row_timeout, tree_view);
7777         }
7778       else
7779         {
7780           add_scroll_timeout (tree_view);
7781         }
7782
7783       if (target == gdk_atom_intern_static_string ("GTK_TREE_MODEL_ROW"))
7784         {
7785           /* Request data so we can use the source row when
7786            * determining whether to accept the drop
7787            */
7788           set_status_pending (context, suggested_action);
7789           gtk_drag_get_data (widget, context, target, time);
7790         }
7791       else
7792         {
7793           set_status_pending (context, 0);
7794           gdk_drag_status (context, suggested_action, time);
7795         }
7796     }
7797
7798   if (path)
7799     gtk_tree_path_free (path);
7800
7801   return TRUE;
7802 }
7803
7804
7805 static gboolean
7806 gtk_tree_view_drag_drop (GtkWidget        *widget,
7807                          GdkDragContext   *context,
7808                          /* coordinates relative to the widget */
7809                          gint              x,
7810                          gint              y,
7811                          guint             time)
7812 {
7813   GtkTreeView *tree_view;
7814   GtkTreePath *path;
7815   GdkDragAction suggested_action = 0;
7816   GdkAtom target = GDK_NONE;
7817   TreeViewDragInfo *di;
7818   GtkTreeModel *model;
7819   gboolean path_down_mode;
7820   gboolean drop_append_mode;
7821
7822   tree_view = GTK_TREE_VIEW (widget);
7823
7824   model = gtk_tree_view_get_model (tree_view);
7825
7826   remove_scroll_timeout (GTK_TREE_VIEW (widget));
7827   remove_open_timeout (GTK_TREE_VIEW (widget));
7828
7829   di = get_info (tree_view);
7830
7831   if (di == NULL)
7832     return FALSE;
7833
7834   if (!check_model_dnd (model, GTK_TYPE_TREE_DRAG_DEST, "drag_drop"))
7835     return FALSE;
7836
7837   if (!set_destination_row (tree_view, context, x, y, &suggested_action, &target))
7838     return FALSE;
7839
7840   path = get_logical_dest_row (tree_view, &path_down_mode, &drop_append_mode);
7841
7842   if (target != GDK_NONE && path != NULL)
7843     {
7844       /* in case a motion had requested drag data, change things so we
7845        * treat drag data receives as a drop.
7846        */
7847       set_status_pending (context, 0);
7848       set_dest_row (context, model, path,
7849                     path_down_mode, tree_view->priv->empty_view_drop,
7850                     drop_append_mode);
7851     }
7852
7853   if (path)
7854     gtk_tree_path_free (path);
7855
7856   /* Unset this thing */
7857   gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
7858                                    NULL,
7859                                    GTK_TREE_VIEW_DROP_BEFORE);
7860
7861   if (target != GDK_NONE)
7862     {
7863       gtk_drag_get_data (widget, context, target, time);
7864       return TRUE;
7865     }
7866   else
7867     return FALSE;
7868 }
7869
7870 static void
7871 gtk_tree_view_drag_data_received (GtkWidget        *widget,
7872                                   GdkDragContext   *context,
7873                                   /* coordinates relative to the widget */
7874                                   gint              x,
7875                                   gint              y,
7876                                   GtkSelectionData *selection_data,
7877                                   guint             info,
7878                                   guint             time)
7879 {
7880   GtkTreePath *path;
7881   TreeViewDragInfo *di;
7882   gboolean accepted = FALSE;
7883   GtkTreeModel *model;
7884   GtkTreeView *tree_view;
7885   GtkTreePath *dest_row;
7886   GdkDragAction suggested_action;
7887   gboolean path_down_mode;
7888   gboolean drop_append_mode;
7889
7890   tree_view = GTK_TREE_VIEW (widget);
7891
7892   model = gtk_tree_view_get_model (tree_view);
7893
7894   if (!check_model_dnd (model, GTK_TYPE_TREE_DRAG_DEST, "drag_data_received"))
7895     return;
7896
7897   di = get_info (tree_view);
7898
7899   if (di == NULL)
7900     return;
7901
7902   suggested_action = get_status_pending (context);
7903
7904   if (suggested_action)
7905     {
7906       /* We are getting this data due to a request in drag_motion,
7907        * rather than due to a request in drag_drop, so we are just
7908        * supposed to call drag_status, not actually paste in the
7909        * data.
7910        */
7911       path = get_logical_dest_row (tree_view, &path_down_mode,
7912                                    &drop_append_mode);
7913
7914       if (path == NULL)
7915         suggested_action = 0;
7916       else if (path_down_mode)
7917         gtk_tree_path_down (path);
7918
7919       if (suggested_action)
7920         {
7921           if (!gtk_tree_drag_dest_row_drop_possible (GTK_TREE_DRAG_DEST (model),
7922                                                      path,
7923                                                      selection_data))
7924             {
7925               if (path_down_mode)
7926                 {
7927                   path_down_mode = FALSE;
7928                   gtk_tree_path_up (path);
7929
7930                   if (!gtk_tree_drag_dest_row_drop_possible (GTK_TREE_DRAG_DEST (model),
7931                                                              path,
7932                                                              selection_data))
7933                     suggested_action = 0;
7934                 }
7935               else
7936                 suggested_action = 0;
7937             }
7938         }
7939
7940       gdk_drag_status (context, suggested_action, time);
7941
7942       if (path)
7943         gtk_tree_path_free (path);
7944
7945       /* If you can't drop, remove user drop indicator until the next motion */
7946       if (suggested_action == 0)
7947         gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
7948                                          NULL,
7949                                          GTK_TREE_VIEW_DROP_BEFORE);
7950
7951       return;
7952     }
7953
7954   dest_row = get_dest_row (context, &path_down_mode);
7955
7956   if (dest_row == NULL)
7957     return;
7958
7959   if (gtk_selection_data_get_length (selection_data) >= 0)
7960     {
7961       if (path_down_mode)
7962         {
7963           gtk_tree_path_down (dest_row);
7964           if (!gtk_tree_drag_dest_row_drop_possible (GTK_TREE_DRAG_DEST (model),
7965                                                      dest_row, selection_data))
7966             gtk_tree_path_up (dest_row);
7967         }
7968     }
7969
7970   if (gtk_selection_data_get_length (selection_data) >= 0)
7971     {
7972       if (gtk_tree_drag_dest_drag_data_received (GTK_TREE_DRAG_DEST (model),
7973                                                  dest_row,
7974                                                  selection_data))
7975         accepted = TRUE;
7976     }
7977
7978   gtk_drag_finish (context,
7979                    accepted,
7980                    (gdk_drag_context_get_selected_action (context) == GDK_ACTION_MOVE),
7981                    time);
7982
7983   if (gtk_tree_path_get_depth (dest_row) == 1 &&
7984       gtk_tree_path_get_indices (dest_row)[0] == 0 &&
7985       gtk_tree_model_iter_n_children (tree_view->priv->model, NULL) != 0)
7986     {
7987       /* special special case drag to "0", scroll to first item */
7988       if (!tree_view->priv->scroll_to_path)
7989         gtk_tree_view_scroll_to_cell (tree_view, dest_row, NULL, FALSE, 0.0, 0.0);
7990     }
7991
7992   gtk_tree_path_free (dest_row);
7993
7994   /* drop dest_row */
7995   set_dest_row (context, NULL, NULL, FALSE, FALSE, FALSE);
7996 }
7997
7998
7999
8000 /* GtkContainer Methods
8001  */
8002
8003
8004 static void
8005 gtk_tree_view_remove (GtkContainer *container,
8006                       GtkWidget    *widget)
8007 {
8008   GtkTreeView *tree_view = GTK_TREE_VIEW (container);
8009   GtkTreeViewChild *child = NULL;
8010   GList *tmp_list;
8011
8012   tmp_list = tree_view->priv->children;
8013   while (tmp_list)
8014     {
8015       child = tmp_list->data;
8016       if (child->widget == widget)
8017         {
8018           gtk_widget_unparent (widget);
8019
8020           tree_view->priv->children = g_list_remove_link (tree_view->priv->children, tmp_list);
8021           g_list_free_1 (tmp_list);
8022           g_slice_free (GtkTreeViewChild, child);
8023           return;
8024         }
8025
8026       tmp_list = tmp_list->next;
8027     }
8028
8029   tmp_list = tree_view->priv->columns;
8030
8031   while (tmp_list)
8032     {
8033       GtkTreeViewColumn *column;
8034       GtkWidget         *button;
8035
8036       column = tmp_list->data;
8037       button = gtk_tree_view_column_get_button (column);
8038
8039       if (button == widget)
8040         {
8041           gtk_widget_unparent (widget);
8042           return;
8043         }
8044       tmp_list = tmp_list->next;
8045     }
8046 }
8047
8048 static void
8049 gtk_tree_view_forall (GtkContainer *container,
8050                       gboolean      include_internals,
8051                       GtkCallback   callback,
8052                       gpointer      callback_data)
8053 {
8054   GtkTreeView *tree_view = GTK_TREE_VIEW (container);
8055   GtkTreeViewChild *child = NULL;
8056   GtkTreeViewColumn *column;
8057   GtkWidget *button;
8058   GList *tmp_list;
8059
8060   tmp_list = tree_view->priv->children;
8061   while (tmp_list)
8062     {
8063       child = tmp_list->data;
8064       tmp_list = tmp_list->next;
8065
8066       (* callback) (child->widget, callback_data);
8067     }
8068   if (include_internals == FALSE)
8069     return;
8070
8071   for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list = tmp_list->next)
8072     {
8073       column = tmp_list->data;
8074       button = gtk_tree_view_column_get_button (column);
8075
8076       if (button)
8077         (* callback) (button, callback_data);
8078     }
8079 }
8080
8081 /* Returns TRUE is any of the columns contains a cell that can-focus.
8082  * If this is not the case, a column-spanning focus rectangle will be
8083  * drawn.
8084  */
8085 static gboolean
8086 gtk_tree_view_has_can_focus_cell (GtkTreeView *tree_view)
8087 {
8088   GList *list;
8089
8090   for (list = tree_view->priv->columns; list; list = list->next)
8091     {
8092       GtkTreeViewColumn *column = list->data;
8093
8094       if (!gtk_tree_view_column_get_visible (column))
8095         continue;
8096       if (gtk_cell_area_is_activatable (gtk_cell_layout_get_area (GTK_CELL_LAYOUT (column))))
8097         return TRUE;
8098     }
8099
8100   return FALSE;
8101 }
8102
8103 static void
8104 column_sizing_notify (GObject    *object,
8105                       GParamSpec *pspec,
8106                       gpointer    data)
8107 {
8108   GtkTreeViewColumn *c = GTK_TREE_VIEW_COLUMN (object);
8109
8110   if (gtk_tree_view_column_get_sizing (c) != GTK_TREE_VIEW_COLUMN_FIXED)
8111     /* disable fixed height mode */
8112     g_object_set (data, "fixed-height-mode", FALSE, NULL);
8113 }
8114
8115 /**
8116  * gtk_tree_view_set_fixed_height_mode:
8117  * @tree_view: a #GtkTreeView
8118  * @enable: %TRUE to enable fixed height mode
8119  *
8120  * Enables or disables the fixed height mode of @tree_view.
8121  * Fixed height mode speeds up #GtkTreeView by assuming that all
8122  * rows have the same height.
8123  * Only enable this option if all rows are the same height and all
8124  * columns are of type %GTK_TREE_VIEW_COLUMN_FIXED.
8125  *
8126  * Since: 2.6
8127  **/
8128 void
8129 gtk_tree_view_set_fixed_height_mode (GtkTreeView *tree_view,
8130                                      gboolean     enable)
8131 {
8132   GList *l;
8133
8134   enable = enable != FALSE;
8135
8136   if (enable == tree_view->priv->fixed_height_mode)
8137     return;
8138
8139   if (!enable)
8140     {
8141       tree_view->priv->fixed_height_mode = 0;
8142       tree_view->priv->fixed_height = -1;
8143
8144       /* force a revalidation */
8145       install_presize_handler (tree_view);
8146     }
8147   else
8148     {
8149       /* make sure all columns are of type FIXED */
8150       for (l = tree_view->priv->columns; l; l = l->next)
8151         {
8152           GtkTreeViewColumn *c = l->data;
8153
8154           g_return_if_fail (gtk_tree_view_column_get_sizing (c) == GTK_TREE_VIEW_COLUMN_FIXED);
8155         }
8156
8157       /* yes, we really have to do this is in a separate loop */
8158       for (l = tree_view->priv->columns; l; l = l->next)
8159         g_signal_connect (l->data, "notify::sizing",
8160                           G_CALLBACK (column_sizing_notify), tree_view);
8161
8162       tree_view->priv->fixed_height_mode = 1;
8163       tree_view->priv->fixed_height = -1;
8164
8165       if (tree_view->priv->tree)
8166         initialize_fixed_height_mode (tree_view);
8167     }
8168
8169   g_object_notify (G_OBJECT (tree_view), "fixed-height-mode");
8170 }
8171
8172 /**
8173  * gtk_tree_view_get_fixed_height_mode:
8174  * @tree_view: a #GtkTreeView
8175  *
8176  * Returns whether fixed height mode is turned on for @tree_view.
8177  *
8178  * Return value: %TRUE if @tree_view is in fixed height mode
8179  *
8180  * Since: 2.6
8181  **/
8182 gboolean
8183 gtk_tree_view_get_fixed_height_mode (GtkTreeView *tree_view)
8184 {
8185   return tree_view->priv->fixed_height_mode;
8186 }
8187
8188 /* Returns TRUE if the focus is within the headers, after the focus operation is
8189  * done
8190  */
8191 static gboolean
8192 gtk_tree_view_header_focus (GtkTreeView      *tree_view,
8193                             GtkDirectionType  dir,
8194                             gboolean          clamp_column_visible)
8195 {
8196   GtkTreeViewColumn *column;
8197   GtkWidget *focus_child;
8198   GtkWidget *button;
8199   GList *last_column, *first_column;
8200   GList *tmp_list;
8201   gboolean rtl;
8202
8203   if (! tree_view->priv->headers_visible)
8204     return FALSE;
8205
8206   focus_child = gtk_container_get_focus_child (GTK_CONTAINER (tree_view));
8207
8208   first_column = tree_view->priv->columns;
8209   while (first_column)
8210     {
8211       column = GTK_TREE_VIEW_COLUMN (first_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       first_column = first_column->next;
8220     }
8221
8222   /* No headers are visible, or are focusable.  We can't focus in or out.
8223    */
8224   if (first_column == NULL)
8225     return FALSE;
8226
8227   last_column = g_list_last (tree_view->priv->columns);
8228   while (last_column)
8229     {
8230       column = GTK_TREE_VIEW_COLUMN (last_column->data);
8231       button = gtk_tree_view_column_get_button (column);
8232
8233       if (gtk_widget_get_can_focus (button) &&
8234           gtk_tree_view_column_get_visible (column) &&
8235           (gtk_tree_view_column_get_clickable (column) ||
8236            gtk_tree_view_column_get_reorderable (column)))
8237         break;
8238       last_column = last_column->prev;
8239     }
8240
8241
8242   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
8243
8244   switch (dir)
8245     {
8246     case GTK_DIR_TAB_BACKWARD:
8247     case GTK_DIR_TAB_FORWARD:
8248     case GTK_DIR_UP:
8249     case GTK_DIR_DOWN:
8250       if (focus_child == NULL)
8251         {
8252           if (tree_view->priv->focus_column != NULL)
8253             button = gtk_tree_view_column_get_button (tree_view->priv->focus_column);
8254           else
8255             button = NULL;
8256
8257           if (button && gtk_widget_get_can_focus (button))
8258             focus_child = button;
8259           else
8260             focus_child = gtk_tree_view_column_get_button (GTK_TREE_VIEW_COLUMN (first_column->data));
8261
8262           gtk_widget_grab_focus (focus_child);
8263           break;
8264         }
8265       return FALSE;
8266
8267     case GTK_DIR_LEFT:
8268     case GTK_DIR_RIGHT:
8269       if (focus_child == NULL)
8270         {
8271           if (tree_view->priv->focus_column != NULL)
8272             focus_child = gtk_tree_view_column_get_button (tree_view->priv->focus_column);
8273           else if (dir == GTK_DIR_LEFT)
8274             focus_child = gtk_tree_view_column_get_button (GTK_TREE_VIEW_COLUMN (last_column->data));
8275           else
8276             focus_child = gtk_tree_view_column_get_button (GTK_TREE_VIEW_COLUMN (first_column->data));
8277
8278           gtk_widget_grab_focus (focus_child);
8279           break;
8280         }
8281
8282       if (gtk_widget_child_focus (focus_child, dir))
8283         {
8284           /* The focus moves inside the button. */
8285           /* This is probably a great example of bad UI */
8286           break;
8287         }
8288
8289       /* We need to move the focus among the row of buttons. */
8290       for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list = tmp_list->next)
8291         if (gtk_tree_view_column_get_button (GTK_TREE_VIEW_COLUMN (tmp_list->data)) == focus_child)
8292           break;
8293
8294       if ((tmp_list == first_column && dir == (rtl ? GTK_DIR_RIGHT : GTK_DIR_LEFT))
8295           || (tmp_list == last_column && dir == (rtl ? GTK_DIR_LEFT : GTK_DIR_RIGHT)))
8296         {
8297           gtk_widget_error_bell (GTK_WIDGET (tree_view));
8298           break;
8299         }
8300
8301       while (tmp_list)
8302         {
8303           GtkTreeViewColumn *column;
8304           GtkWidget         *button;
8305
8306           if (dir == (rtl ? GTK_DIR_LEFT : GTK_DIR_RIGHT))
8307             tmp_list = tmp_list->next;
8308           else
8309             tmp_list = tmp_list->prev;
8310
8311           if (tmp_list == NULL)
8312             {
8313               g_warning ("Internal button not found");
8314               break;
8315             }
8316           column = tmp_list->data;
8317           button = gtk_tree_view_column_get_button (column);
8318           if (button &&
8319               gtk_tree_view_column_get_visible (column) &&
8320               gtk_widget_get_can_focus (button))
8321             {
8322               focus_child = button;
8323               gtk_widget_grab_focus (button);
8324               break;
8325             }
8326         }
8327       break;
8328     default:
8329       g_assert_not_reached ();
8330       break;
8331     }
8332
8333   /* if focus child is non-null, we assume it's been set to the current focus child
8334    */
8335   if (focus_child)
8336     {
8337       for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list = tmp_list->next)
8338         if (gtk_tree_view_column_get_button (GTK_TREE_VIEW_COLUMN (tmp_list->data)) == focus_child)
8339           {
8340             tree_view->priv->focus_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
8341             break;
8342           }
8343
8344       if (clamp_column_visible)
8345         {
8346           gtk_tree_view_clamp_column_visible (tree_view,
8347                                               tree_view->priv->focus_column,
8348                                               FALSE);
8349         }
8350     }
8351
8352   return (focus_child != NULL);
8353 }
8354
8355 /* This function returns in 'path' the first focusable path, if the given path
8356  * is already focusable, it's the returned one.
8357  */
8358 static gboolean
8359 search_first_focusable_path (GtkTreeView  *tree_view,
8360                              GtkTreePath **path,
8361                              gboolean      search_forward,
8362                              GtkRBTree   **new_tree,
8363                              GtkRBNode   **new_node)
8364 {
8365   GtkRBTree *tree = NULL;
8366   GtkRBNode *node = NULL;
8367
8368   if (!path || !*path)
8369     return FALSE;
8370
8371   _gtk_tree_view_find_node (tree_view, *path, &tree, &node);
8372
8373   if (!tree || !node)
8374     return FALSE;
8375
8376   while (node && row_is_separator (tree_view, NULL, *path))
8377     {
8378       if (search_forward)
8379         _gtk_rbtree_next_full (tree, node, &tree, &node);
8380       else
8381         _gtk_rbtree_prev_full (tree, node, &tree, &node);
8382
8383       if (*path)
8384         gtk_tree_path_free (*path);
8385
8386       if (node)
8387         *path = _gtk_tree_view_find_path (tree_view, tree, node);
8388       else
8389         *path = NULL;
8390     }
8391
8392   if (new_tree)
8393     *new_tree = tree;
8394
8395   if (new_node)
8396     *new_node = node;
8397
8398   return (*path != NULL);
8399 }
8400
8401 static gint
8402 gtk_tree_view_focus (GtkWidget        *widget,
8403                      GtkDirectionType  direction)
8404 {
8405   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
8406   GtkContainer *container = GTK_CONTAINER (widget);
8407   GtkWidget *focus_child;
8408
8409   if (!gtk_widget_is_sensitive (widget) || !gtk_widget_get_can_focus (widget))
8410     return FALSE;
8411
8412   focus_child = gtk_container_get_focus_child (container);
8413
8414   gtk_tree_view_stop_editing (GTK_TREE_VIEW (widget), FALSE);
8415   /* Case 1.  Headers currently have focus. */
8416   if (focus_child)
8417     {
8418       switch (direction)
8419         {
8420         case GTK_DIR_LEFT:
8421         case GTK_DIR_RIGHT:
8422           gtk_tree_view_header_focus (tree_view, direction, TRUE);
8423           return TRUE;
8424         case GTK_DIR_TAB_BACKWARD:
8425         case GTK_DIR_UP:
8426           return FALSE;
8427         case GTK_DIR_TAB_FORWARD:
8428         case GTK_DIR_DOWN:
8429           gtk_widget_grab_focus (widget);
8430           return TRUE;
8431         default:
8432           g_assert_not_reached ();
8433           return FALSE;
8434         }
8435     }
8436
8437   /* Case 2. We don't have focus at all. */
8438   if (!gtk_widget_has_focus (widget))
8439     {
8440       gtk_widget_grab_focus (widget);
8441       return TRUE;
8442     }
8443
8444   /* Case 3. We have focus already. */
8445   if (direction == GTK_DIR_TAB_BACKWARD)
8446     return (gtk_tree_view_header_focus (tree_view, direction, FALSE));
8447   else if (direction == GTK_DIR_TAB_FORWARD)
8448     return FALSE;
8449
8450   /* Other directions caught by the keybindings */
8451   gtk_widget_grab_focus (widget);
8452   return TRUE;
8453 }
8454
8455 static void
8456 gtk_tree_view_grab_focus (GtkWidget *widget)
8457 {
8458   GTK_WIDGET_CLASS (gtk_tree_view_parent_class)->grab_focus (widget);
8459
8460   gtk_tree_view_focus_to_cursor (GTK_TREE_VIEW (widget));
8461 }
8462
8463 static void
8464 gtk_tree_view_style_updated (GtkWidget *widget)
8465 {
8466   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
8467   GList *list;
8468   GtkTreeViewColumn *column;
8469
8470   GTK_WIDGET_CLASS (gtk_tree_view_parent_class)->style_updated (widget);
8471
8472   if (gtk_widget_get_realized (widget))
8473     {
8474       gtk_tree_view_ensure_background (tree_view);
8475
8476       gtk_tree_view_set_grid_lines (tree_view, tree_view->priv->grid_lines);
8477       gtk_tree_view_set_enable_tree_lines (tree_view, tree_view->priv->tree_lines_enabled);
8478     }
8479
8480   gtk_widget_style_get (widget,
8481                         "expander-size", &tree_view->priv->expander_size,
8482                         NULL);
8483   tree_view->priv->expander_size += EXPANDER_EXTRA_PADDING;
8484
8485   for (list = tree_view->priv->columns; list; list = list->next)
8486     {
8487       column = list->data;
8488       _gtk_tree_view_column_cell_set_dirty (column, TRUE);
8489     }
8490
8491   tree_view->priv->fixed_height = -1;
8492   _gtk_rbtree_mark_invalid (tree_view->priv->tree);
8493
8494   gtk_widget_queue_resize (widget);
8495 }
8496
8497
8498 static void
8499 gtk_tree_view_set_focus_child (GtkContainer *container,
8500                                GtkWidget    *child)
8501 {
8502   GtkTreeView *tree_view = GTK_TREE_VIEW (container);
8503   GList *list;
8504
8505   for (list = tree_view->priv->columns; list; list = list->next)
8506     {
8507       if (gtk_tree_view_column_get_button (GTK_TREE_VIEW_COLUMN (list->data)) == child)
8508         {
8509           tree_view->priv->focus_column = GTK_TREE_VIEW_COLUMN (list->data);
8510           break;
8511         }
8512     }
8513
8514   GTK_CONTAINER_CLASS (gtk_tree_view_parent_class)->set_focus_child (container, child);
8515 }
8516
8517 static GtkWidgetPath *
8518 gtk_tree_view_get_path_for_child (GtkContainer *container,
8519                                   GtkWidget    *child)
8520 {
8521   GtkTreeView *tree_view = GTK_TREE_VIEW (container);
8522   GtkWidgetPath *path;
8523   gboolean rtl;
8524   GList *list;
8525   gint n_col = 0;
8526
8527   path = GTK_CONTAINER_CLASS (gtk_tree_view_parent_class)->get_path_for_child (container, child);
8528   rtl = (gtk_widget_get_direction (GTK_WIDGET (container)) == GTK_TEXT_DIR_RTL);
8529
8530   for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
8531        list;
8532        list = (rtl ? list->prev : list->next))
8533     {
8534       GtkTreeViewColumn *column = list->data;
8535       GtkRegionFlags flags = 0;
8536
8537       if (!gtk_tree_view_column_get_visible (column))
8538         continue;
8539
8540       n_col++;
8541
8542       if (gtk_tree_view_column_get_widget (column) != child &&
8543           gtk_tree_view_column_get_button (column) != child)
8544         continue;
8545
8546       if ((n_col % 2) == 0)
8547         flags |= GTK_REGION_EVEN;
8548       else
8549         flags |= GTK_REGION_ODD;
8550
8551       if (n_col == 1)
8552         flags |= GTK_REGION_FIRST;
8553
8554       if ((rtl && !list->prev) ||
8555           (!rtl && !list->next))
8556         flags |= GTK_REGION_LAST;
8557
8558       gtk_widget_path_iter_add_region (path, -1, GTK_STYLE_REGION_COLUMN_HEADER, flags);
8559       break;
8560     }
8561
8562   gtk_widget_path_append_for_widget (path, child);
8563
8564   return path;
8565 }
8566
8567 static gboolean
8568 gtk_tree_view_real_move_cursor (GtkTreeView       *tree_view,
8569                                 GtkMovementStep    step,
8570                                 gint               count)
8571 {
8572   GdkModifierType state;
8573
8574   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
8575   g_return_val_if_fail (step == GTK_MOVEMENT_LOGICAL_POSITIONS ||
8576                         step == GTK_MOVEMENT_VISUAL_POSITIONS ||
8577                         step == GTK_MOVEMENT_DISPLAY_LINES ||
8578                         step == GTK_MOVEMENT_PAGES ||
8579                         step == GTK_MOVEMENT_BUFFER_ENDS, FALSE);
8580
8581   if (tree_view->priv->tree == NULL)
8582     return FALSE;
8583   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
8584     return FALSE;
8585
8586   gtk_tree_view_stop_editing (tree_view, FALSE);
8587   tree_view->priv->draw_keyfocus = TRUE;
8588   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
8589
8590   if (gtk_get_current_event_state (&state))
8591     {
8592       GdkModifierType extend_mod_mask;
8593       GdkModifierType modify_mod_mask;
8594
8595       extend_mod_mask =
8596         gtk_widget_get_modifier_mask (GTK_WIDGET (tree_view),
8597                                       GDK_MODIFIER_INTENT_EXTEND_SELECTION);
8598
8599       modify_mod_mask =
8600         gtk_widget_get_modifier_mask (GTK_WIDGET (tree_view),
8601                                       GDK_MODIFIER_INTENT_MODIFY_SELECTION);
8602
8603       if ((state & modify_mod_mask) == modify_mod_mask)
8604         tree_view->priv->modify_selection_pressed = TRUE;
8605       if ((state & extend_mod_mask) == extend_mod_mask)
8606         tree_view->priv->extend_selection_pressed = TRUE;
8607     }
8608   /* else we assume not pressed */
8609
8610   switch (step)
8611     {
8612       /* currently we make no distinction.  When we go bi-di, we need to */
8613     case GTK_MOVEMENT_LOGICAL_POSITIONS:
8614     case GTK_MOVEMENT_VISUAL_POSITIONS:
8615       gtk_tree_view_move_cursor_left_right (tree_view, count);
8616       break;
8617     case GTK_MOVEMENT_DISPLAY_LINES:
8618       gtk_tree_view_move_cursor_up_down (tree_view, count);
8619       break;
8620     case GTK_MOVEMENT_PAGES:
8621       gtk_tree_view_move_cursor_page_up_down (tree_view, count);
8622       break;
8623     case GTK_MOVEMENT_BUFFER_ENDS:
8624       gtk_tree_view_move_cursor_start_end (tree_view, count);
8625       break;
8626     default:
8627       g_assert_not_reached ();
8628     }
8629
8630   tree_view->priv->modify_selection_pressed = FALSE;
8631   tree_view->priv->extend_selection_pressed = FALSE;
8632
8633   return TRUE;
8634 }
8635
8636 static void
8637 gtk_tree_view_put (GtkTreeView *tree_view,
8638                    GtkWidget   *child_widget,
8639                    /* in bin_window coordinates */
8640                    gint         x,
8641                    gint         y,
8642                    gint         width,
8643                    gint         height)
8644 {
8645   GtkTreeViewChild *child;
8646
8647   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
8648   g_return_if_fail (GTK_IS_WIDGET (child_widget));
8649
8650   child = g_slice_new (GtkTreeViewChild);
8651
8652   child->widget = child_widget;
8653   child->x = x;
8654   child->y = y;
8655   child->width = width;
8656   child->height = height;
8657
8658   tree_view->priv->children = g_list_append (tree_view->priv->children, child);
8659
8660   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
8661     gtk_widget_set_parent_window (child->widget, tree_view->priv->bin_window);
8662
8663   gtk_widget_set_parent (child_widget, GTK_WIDGET (tree_view));
8664 }
8665
8666 void
8667 _gtk_tree_view_child_move_resize (GtkTreeView *tree_view,
8668                                   GtkWidget   *widget,
8669                                   /* in tree coordinates */
8670                                   gint         x,
8671                                   gint         y,
8672                                   gint         width,
8673                                   gint         height)
8674 {
8675   GtkTreeViewChild *child = NULL;
8676   GList *list;
8677   GdkRectangle allocation;
8678
8679   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
8680   g_return_if_fail (GTK_IS_WIDGET (widget));
8681
8682   for (list = tree_view->priv->children; list; list = list->next)
8683     {
8684       if (((GtkTreeViewChild *)list->data)->widget == widget)
8685         {
8686           child = list->data;
8687           break;
8688         }
8689     }
8690   if (child == NULL)
8691     return;
8692
8693   allocation.x = child->x = x;
8694   allocation.y = child->y = y;
8695   allocation.width = child->width = width;
8696   allocation.height = child->height = height;
8697
8698   if (gtk_widget_get_realized (widget))
8699     gtk_widget_size_allocate (widget, &allocation);
8700 }
8701
8702
8703 /* TreeModel Callbacks
8704  */
8705
8706 static void
8707 gtk_tree_view_row_changed (GtkTreeModel *model,
8708                            GtkTreePath  *path,
8709                            GtkTreeIter  *iter,
8710                            gpointer      data)
8711 {
8712   GtkTreeView *tree_view = (GtkTreeView *)data;
8713   GtkRBTree *tree;
8714   GtkRBNode *node;
8715   gboolean free_path = FALSE;
8716   GList *list;
8717   GtkTreePath *cursor_path;
8718
8719   g_return_if_fail (path != NULL || iter != NULL);
8720
8721   if (tree_view->priv->cursor != NULL)
8722     cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
8723   else
8724     cursor_path = NULL;
8725
8726   if (tree_view->priv->edited_column &&
8727       (cursor_path == NULL || gtk_tree_path_compare (cursor_path, path) == 0))
8728     gtk_tree_view_stop_editing (tree_view, TRUE);
8729
8730   if (cursor_path != NULL)
8731     gtk_tree_path_free (cursor_path);
8732
8733   if (path == NULL)
8734     {
8735       path = gtk_tree_model_get_path (model, iter);
8736       free_path = TRUE;
8737     }
8738   else if (iter == NULL)
8739     gtk_tree_model_get_iter (model, iter, path);
8740
8741   if (_gtk_tree_view_find_node (tree_view,
8742                                 path,
8743                                 &tree,
8744                                 &node))
8745     /* We aren't actually showing the node */
8746     goto done;
8747
8748   if (tree == NULL)
8749     goto done;
8750
8751   if (tree_view->priv->fixed_height_mode
8752       && tree_view->priv->fixed_height >= 0)
8753     {
8754       _gtk_rbtree_node_set_height (tree, node, tree_view->priv->fixed_height);
8755       if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
8756         gtk_tree_view_node_queue_redraw (tree_view, tree, node);
8757     }
8758   else
8759     {
8760       _gtk_rbtree_node_mark_invalid (tree, node);
8761       for (list = tree_view->priv->columns; list; list = list->next)
8762         {
8763           GtkTreeViewColumn *column;
8764
8765           column = list->data;
8766           if (!gtk_tree_view_column_get_visible (column))
8767             continue;
8768
8769           if (gtk_tree_view_column_get_sizing (column) == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
8770             {
8771               _gtk_tree_view_column_cell_set_dirty (column, TRUE);
8772             }
8773         }
8774     }
8775
8776  done:
8777   if (!tree_view->priv->fixed_height_mode &&
8778       gtk_widget_get_realized (GTK_WIDGET (tree_view)))
8779     install_presize_handler (tree_view);
8780   if (free_path)
8781     gtk_tree_path_free (path);
8782 }
8783
8784 static void
8785 gtk_tree_view_row_inserted (GtkTreeModel *model,
8786                             GtkTreePath  *path,
8787                             GtkTreeIter  *iter,
8788                             gpointer      data)
8789 {
8790   GtkTreeView *tree_view = (GtkTreeView *) data;
8791   gint *indices;
8792   GtkRBTree *tree;
8793   GtkRBNode *tmpnode = NULL;
8794   gint depth;
8795   gint i = 0;
8796   gint height;
8797   gboolean free_path = FALSE;
8798   gboolean node_visible = TRUE;
8799
8800   g_return_if_fail (path != NULL || iter != NULL);
8801
8802   if (tree_view->priv->fixed_height_mode
8803       && tree_view->priv->fixed_height >= 0)
8804     height = tree_view->priv->fixed_height;
8805   else
8806     height = 0;
8807
8808   if (path == NULL)
8809     {
8810       path = gtk_tree_model_get_path (model, iter);
8811       free_path = TRUE;
8812     }
8813   else if (iter == NULL)
8814     gtk_tree_model_get_iter (model, iter, path);
8815
8816   if (tree_view->priv->tree == NULL)
8817     tree_view->priv->tree = _gtk_rbtree_new ();
8818
8819   tree = tree_view->priv->tree;
8820
8821   /* Update all row-references */
8822   gtk_tree_row_reference_inserted (G_OBJECT (data), path);
8823   depth = gtk_tree_path_get_depth (path);
8824   indices = gtk_tree_path_get_indices (path);
8825
8826   /* First, find the parent tree */
8827   while (i < depth - 1)
8828     {
8829       if (tree == NULL)
8830         {
8831           /* We aren't showing the node */
8832           node_visible = FALSE;
8833           goto done;
8834         }
8835
8836       tmpnode = _gtk_rbtree_find_count (tree, indices[i] + 1);
8837       if (tmpnode == NULL)
8838         {
8839           g_warning ("A node was inserted with a parent that's not in the tree.\n" \
8840                      "This possibly means that a GtkTreeModel inserted a child node\n" \
8841                      "before the parent was inserted.");
8842           goto done;
8843         }
8844       else if (!GTK_RBNODE_FLAG_SET (tmpnode, GTK_RBNODE_IS_PARENT))
8845         {
8846           /* FIXME enforce correct behavior on model, probably */
8847           /* In theory, the model should have emitted has_child_toggled here.  We
8848            * try to catch it anyway, just to be safe, in case the model hasn't.
8849            */
8850           GtkTreePath *tmppath = _gtk_tree_view_find_path (tree_view,
8851                                                            tree,
8852                                                            tmpnode);
8853           gtk_tree_view_row_has_child_toggled (model, tmppath, NULL, data);
8854           gtk_tree_path_free (tmppath);
8855           goto done;
8856         }
8857
8858       tree = tmpnode->children;
8859       i++;
8860     }
8861
8862   if (tree == NULL)
8863     {
8864       node_visible = FALSE;
8865       goto done;
8866     }
8867
8868   /* ref the node */
8869   gtk_tree_model_ref_node (tree_view->priv->model, iter);
8870   if (indices[depth - 1] == 0)
8871     {
8872       tmpnode = _gtk_rbtree_find_count (tree, 1);
8873       tmpnode = _gtk_rbtree_insert_before (tree, tmpnode, height, FALSE);
8874     }
8875   else
8876     {
8877       tmpnode = _gtk_rbtree_find_count (tree, indices[depth - 1]);
8878       tmpnode = _gtk_rbtree_insert_after (tree, tmpnode, height, FALSE);
8879     }
8880
8881  done:
8882   if (height > 0)
8883     {
8884       if (tree)
8885         _gtk_rbtree_node_mark_valid (tree, tmpnode);
8886
8887       if (node_visible && node_is_visible (tree_view, tree, tmpnode))
8888         gtk_widget_queue_resize (GTK_WIDGET (tree_view));
8889       else
8890         gtk_widget_queue_resize_no_redraw (GTK_WIDGET (tree_view));
8891     }
8892   else
8893     install_presize_handler (tree_view);
8894   if (free_path)
8895     gtk_tree_path_free (path);
8896 }
8897
8898 static void
8899 gtk_tree_view_row_has_child_toggled (GtkTreeModel *model,
8900                                      GtkTreePath  *path,
8901                                      GtkTreeIter  *iter,
8902                                      gpointer      data)
8903 {
8904   GtkTreeView *tree_view = (GtkTreeView *)data;
8905   GtkTreeIter real_iter;
8906   gboolean has_child;
8907   GtkRBTree *tree;
8908   GtkRBNode *node;
8909   gboolean free_path = FALSE;
8910
8911   g_return_if_fail (path != NULL || iter != NULL);
8912
8913   if (iter)
8914     real_iter = *iter;
8915
8916   if (path == NULL)
8917     {
8918       path = gtk_tree_model_get_path (model, iter);
8919       free_path = TRUE;
8920     }
8921   else if (iter == NULL)
8922     gtk_tree_model_get_iter (model, &real_iter, path);
8923
8924   if (_gtk_tree_view_find_node (tree_view,
8925                                 path,
8926                                 &tree,
8927                                 &node))
8928     /* We aren't actually showing the node */
8929     goto done;
8930
8931   if (tree == NULL)
8932     goto done;
8933
8934   has_child = gtk_tree_model_iter_has_child (model, &real_iter);
8935   /* Sanity check.
8936    */
8937   if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT) == has_child)
8938     goto done;
8939
8940   if (has_child)
8941     GTK_RBNODE_SET_FLAG (node, GTK_RBNODE_IS_PARENT);
8942   else
8943     GTK_RBNODE_UNSET_FLAG (node, GTK_RBNODE_IS_PARENT);
8944
8945   if (has_child && tree_view->priv->is_list)
8946     {
8947       tree_view->priv->is_list = FALSE;
8948       if (tree_view->priv->show_expanders)
8949         {
8950           GList *list;
8951
8952           for (list = tree_view->priv->columns; list; list = list->next)
8953             if (gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (list->data)))
8954               {
8955                 _gtk_tree_view_column_cell_set_dirty (GTK_TREE_VIEW_COLUMN (list->data), TRUE);
8956                 break;
8957               }
8958         }
8959       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
8960     }
8961   else
8962     {
8963       _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
8964     }
8965
8966  done:
8967   if (free_path)
8968     gtk_tree_path_free (path);
8969 }
8970
8971 static void
8972 count_children_helper (GtkRBTree *tree,
8973                        GtkRBNode *node,
8974                        gpointer   data)
8975 {
8976   if (node->children)
8977     _gtk_rbtree_traverse (node->children, node->children->root, G_POST_ORDER, count_children_helper, data);
8978   (*((gint *)data))++;
8979 }
8980
8981 static void
8982 check_selection_helper (GtkRBTree *tree,
8983                         GtkRBNode *node,
8984                         gpointer   data)
8985 {
8986   gint *value = (gint *)data;
8987
8988   *value = GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED);
8989
8990   if (node->children && !*value)
8991     _gtk_rbtree_traverse (node->children, node->children->root, G_POST_ORDER, check_selection_helper, data);
8992 }
8993
8994 static void
8995 gtk_tree_view_row_deleted (GtkTreeModel *model,
8996                            GtkTreePath  *path,
8997                            gpointer      data)
8998 {
8999   GtkTreeView *tree_view = (GtkTreeView *)data;
9000   GtkRBTree *tree;
9001   GtkRBNode *node;
9002   GList *list;
9003   gint selection_changed = FALSE;
9004   GtkStyleContext *context;
9005
9006   g_return_if_fail (path != NULL);
9007
9008   gtk_tree_row_reference_deleted (G_OBJECT (data), path);
9009
9010   if (_gtk_tree_view_find_node (tree_view, path, &tree, &node))
9011     return;
9012
9013   if (tree == NULL)
9014     return;
9015
9016   /* check if the selection has been changed */
9017   _gtk_rbtree_traverse (tree, node, G_POST_ORDER,
9018                         check_selection_helper, &selection_changed);
9019
9020   for (list = tree_view->priv->columns; list; list = list->next)
9021     if (gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (list->data)) &&
9022         gtk_tree_view_column_get_sizing (GTK_TREE_VIEW_COLUMN (list->data)) == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
9023       _gtk_tree_view_column_cell_set_dirty ((GtkTreeViewColumn *)list->data, TRUE);
9024
9025   /* Ensure we don't have a dangling pointer to a dead node */
9026   ensure_unprelighted (tree_view);
9027
9028   /* Cancel editting if we've started */
9029   gtk_tree_view_stop_editing (tree_view, TRUE);
9030
9031   if (tree_view->priv->destroy_count_func)
9032     {
9033       gint child_count = 0;
9034       if (node->children)
9035         _gtk_rbtree_traverse (node->children, node->children->root, G_POST_ORDER, count_children_helper, &child_count);
9036       tree_view->priv->destroy_count_func (tree_view, path, child_count, tree_view->priv->destroy_count_data);
9037     }
9038
9039   if (tree->root->count == 1)
9040     {
9041       if (tree_view->priv->tree == tree)
9042         tree_view->priv->tree = NULL;
9043
9044       _gtk_tree_view_accessible_remove (tree_view, tree, NULL);
9045       _gtk_rbtree_remove (tree);
9046     }
9047   else
9048     {
9049       _gtk_tree_view_accessible_remove (tree_view, tree, node);
9050       _gtk_rbtree_remove_node (tree, node);
9051     }
9052
9053   if (! gtk_tree_row_reference_valid (tree_view->priv->top_row))
9054     {
9055       gtk_tree_row_reference_free (tree_view->priv->top_row);
9056       tree_view->priv->top_row = NULL;
9057     }
9058
9059   /* Cancel any ongoing animation happening within the row */
9060   context = gtk_widget_get_style_context (GTK_WIDGET (tree_view));
9061   gtk_style_context_cancel_animations (context, node);
9062
9063   install_scroll_sync_handler (tree_view);
9064
9065   gtk_widget_queue_resize (GTK_WIDGET (tree_view));
9066
9067   if (selection_changed)
9068     g_signal_emit_by_name (tree_view->priv->selection, "changed");
9069 }
9070
9071 static void
9072 gtk_tree_view_rows_reordered (GtkTreeModel *model,
9073                               GtkTreePath  *parent,
9074                               GtkTreeIter  *iter,
9075                               gint         *new_order,
9076                               gpointer      data)
9077 {
9078   GtkTreeView *tree_view = GTK_TREE_VIEW (data);
9079   GtkRBTree *tree;
9080   GtkRBNode *node;
9081   gint len;
9082
9083   len = gtk_tree_model_iter_n_children (model, iter);
9084
9085   if (len < 2)
9086     return;
9087
9088   gtk_tree_row_reference_reordered (G_OBJECT (data),
9089                                     parent,
9090                                     iter,
9091                                     new_order);
9092
9093   if (_gtk_tree_view_find_node (tree_view,
9094                                 parent,
9095                                 &tree,
9096                                 &node))
9097     return;
9098
9099   /* We need to special case the parent path */
9100   if (tree == NULL)
9101     tree = tree_view->priv->tree;
9102   else
9103     tree = node->children;
9104
9105   if (tree == NULL)
9106     return;
9107
9108   if (tree_view->priv->edited_column)
9109     gtk_tree_view_stop_editing (tree_view, TRUE);
9110
9111   /* we need to be unprelighted */
9112   ensure_unprelighted (tree_view);
9113
9114   _gtk_rbtree_reorder (tree, new_order, len);
9115
9116   gtk_widget_queue_draw (GTK_WIDGET (tree_view));
9117
9118   gtk_tree_view_dy_to_top_row (tree_view);
9119 }
9120
9121
9122 /* Internal tree functions
9123  */
9124
9125
9126 static void
9127 gtk_tree_view_get_background_xrange (GtkTreeView       *tree_view,
9128                                      GtkRBTree         *tree,
9129                                      GtkTreeViewColumn *column,
9130                                      gint              *x1,
9131                                      gint              *x2)
9132 {
9133   GtkTreeViewColumn *tmp_column = NULL;
9134   gint total_width;
9135   GList *list;
9136   gboolean rtl;
9137
9138   if (x1)
9139     *x1 = 0;
9140
9141   if (x2)
9142     *x2 = 0;
9143
9144   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
9145
9146   total_width = 0;
9147   for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
9148        list;
9149        list = (rtl ? list->prev : list->next))
9150     {
9151       tmp_column = list->data;
9152
9153       if (tmp_column == column)
9154         break;
9155
9156       if (gtk_tree_view_column_get_visible (tmp_column))
9157         total_width += gtk_tree_view_column_get_width (tmp_column);
9158     }
9159
9160   if (tmp_column != column)
9161     {
9162       g_warning (G_STRLOC": passed-in column isn't in the tree");
9163       return;
9164     }
9165
9166   if (x1)
9167     *x1 = total_width;
9168
9169   if (x2)
9170     {
9171       if (gtk_tree_view_column_get_visible (column))
9172         *x2 = total_width + gtk_tree_view_column_get_width (column);
9173       else
9174         *x2 = total_width; /* width of 0 */
9175     }
9176 }
9177
9178 static void
9179 gtk_tree_view_get_arrow_xrange (GtkTreeView *tree_view,
9180                                 GtkRBTree   *tree,
9181                                 gint        *x1,
9182                                 gint        *x2)
9183 {
9184   gint x_offset = 0;
9185   GList *list;
9186   GtkTreeViewColumn *tmp_column = NULL;
9187   gint total_width;
9188   gboolean indent_expanders;
9189   gboolean rtl;
9190
9191   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
9192
9193   total_width = 0;
9194   for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
9195        list;
9196        list = (rtl ? list->prev : list->next))
9197     {
9198       tmp_column = list->data;
9199
9200       if (gtk_tree_view_is_expander_column (tree_view, tmp_column))
9201         {
9202           if (rtl)
9203             x_offset = total_width + gtk_tree_view_column_get_width (tmp_column) - tree_view->priv->expander_size;
9204           else
9205             x_offset = total_width;
9206           break;
9207         }
9208
9209       if (gtk_tree_view_column_get_visible (tmp_column))
9210         total_width += gtk_tree_view_column_get_width (tmp_column);
9211     }
9212
9213   gtk_widget_style_get (GTK_WIDGET (tree_view),
9214                         "indent-expanders", &indent_expanders,
9215                         NULL);
9216
9217   if (indent_expanders)
9218     {
9219       if (rtl)
9220         x_offset -= tree_view->priv->expander_size * _gtk_rbtree_get_depth (tree);
9221       else
9222         x_offset += tree_view->priv->expander_size * _gtk_rbtree_get_depth (tree);
9223     }
9224
9225   *x1 = x_offset;
9226
9227   if (tmp_column &&
9228       gtk_tree_view_column_get_visible (tmp_column))
9229     /* +1 because x2 isn't included in the range. */
9230     *x2 = *x1 + tree_view->priv->expander_size + 1;
9231   else
9232     *x2 = *x1;
9233 }
9234
9235 static void
9236 gtk_tree_view_build_tree (GtkTreeView *tree_view,
9237                           GtkRBTree   *tree,
9238                           GtkTreeIter *iter,
9239                           gint         depth,
9240                           gboolean     recurse)
9241 {
9242   GtkRBNode *temp = NULL;
9243   GtkTreePath *path = NULL;
9244
9245   do
9246     {
9247       gtk_tree_model_ref_node (tree_view->priv->model, iter);
9248       temp = _gtk_rbtree_insert_after (tree, temp, 0, FALSE);
9249
9250       if (tree_view->priv->fixed_height > 0)
9251         {
9252           if (GTK_RBNODE_FLAG_SET (temp, GTK_RBNODE_INVALID))
9253             {
9254               _gtk_rbtree_node_set_height (tree, temp, tree_view->priv->fixed_height);
9255               _gtk_rbtree_node_mark_valid (tree, temp);
9256             }
9257         }
9258
9259       if (tree_view->priv->is_list)
9260         continue;
9261
9262       if (recurse)
9263         {
9264           GtkTreeIter child;
9265
9266           if (!path)
9267             path = gtk_tree_model_get_path (tree_view->priv->model, iter);
9268           else
9269             gtk_tree_path_next (path);
9270
9271           if (gtk_tree_model_iter_children (tree_view->priv->model, &child, iter))
9272             {
9273               gboolean expand;
9274
9275               g_signal_emit (tree_view, tree_view_signals[TEST_EXPAND_ROW], 0, iter, path, &expand);
9276
9277               if (gtk_tree_model_iter_has_child (tree_view->priv->model, iter)
9278                   && !expand)
9279                 {
9280                   temp->children = _gtk_rbtree_new ();
9281                   temp->children->parent_tree = tree;
9282                   temp->children->parent_node = temp;
9283                   gtk_tree_view_build_tree (tree_view, temp->children, &child, depth + 1, recurse);
9284                 }
9285             }
9286         }
9287
9288       if (gtk_tree_model_iter_has_child (tree_view->priv->model, iter))
9289         {
9290           if ((temp->flags&GTK_RBNODE_IS_PARENT) != GTK_RBNODE_IS_PARENT)
9291             temp->flags ^= GTK_RBNODE_IS_PARENT;
9292         }
9293     }
9294   while (gtk_tree_model_iter_next (tree_view->priv->model, iter));
9295
9296   if (path)
9297     gtk_tree_path_free (path);
9298 }
9299
9300 /* Make sure the node is visible vertically */
9301 static void
9302 gtk_tree_view_clamp_node_visible (GtkTreeView *tree_view,
9303                                   GtkRBTree   *tree,
9304                                   GtkRBNode   *node)
9305 {
9306   gint node_dy, height;
9307   GtkTreePath *path = NULL;
9308
9309   if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
9310     return;
9311
9312   /* just return if the node is visible, avoiding a costly expose */
9313   node_dy = _gtk_rbtree_node_find_offset (tree, node);
9314   height = gtk_tree_view_get_row_height (tree_view, node);
9315   if (! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID)
9316       && node_dy >= gtk_adjustment_get_value (tree_view->priv->vadjustment)
9317       && node_dy + height <= (gtk_adjustment_get_value (tree_view->priv->vadjustment)
9318                               + gtk_adjustment_get_page_size (tree_view->priv->vadjustment)))
9319     return;
9320
9321   path = _gtk_tree_view_find_path (tree_view, tree, node);
9322   if (path)
9323     {
9324       /* We process updates because we want to clear old selected items when we scroll.
9325        * if this is removed, we get a "selection streak" at the bottom. */
9326       gtk_tree_view_bin_process_updates (tree_view);
9327
9328       gtk_tree_view_scroll_to_cell (tree_view, path, NULL, FALSE, 0.0, 0.0);
9329       gtk_tree_path_free (path);
9330     }
9331 }
9332
9333 static void
9334 gtk_tree_view_clamp_column_visible (GtkTreeView       *tree_view,
9335                                     GtkTreeViewColumn *column,
9336                                     gboolean           focus_to_cell)
9337 {
9338   GtkAllocation allocation;
9339   gint x, width;
9340
9341   if (column == NULL)
9342     return;
9343
9344   gtk_widget_get_allocation (gtk_tree_view_column_get_button (column), &allocation);
9345   x = allocation.x;
9346   width = allocation.width;
9347
9348   if (width > gtk_adjustment_get_page_size (tree_view->priv->hadjustment))
9349     {
9350       /* The column is larger than the horizontal page size.  If the
9351        * column has cells which can be focussed individually, then we make
9352        * sure the cell which gets focus is fully visible (if even the
9353        * focus cell is bigger than the page size, we make sure the
9354        * left-hand side of the cell is visible).
9355        *
9356        * If the column does not have an activatable cell, we
9357        * make sure the left-hand side of the column is visible.
9358        */
9359
9360       if (focus_to_cell && gtk_tree_view_has_can_focus_cell (tree_view))
9361         {
9362           GtkCellArea *cell_area;
9363           GtkCellRenderer *focus_cell;
9364
9365           cell_area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (column));
9366           focus_cell = gtk_cell_area_get_focus_cell (cell_area);
9367
9368           if (gtk_tree_view_column_cell_get_position (column, focus_cell,
9369                                                       &x, &width))
9370             {
9371               if (width < gtk_adjustment_get_page_size (tree_view->priv->hadjustment))
9372                 {
9373                   if (gtk_adjustment_get_value (tree_view->priv->hadjustment) + gtk_adjustment_get_page_size (tree_view->priv->hadjustment) < x + width)
9374                     gtk_adjustment_set_value (tree_view->priv->hadjustment,
9375                                               x + width - gtk_adjustment_get_page_size (tree_view->priv->hadjustment));
9376                   else if (gtk_adjustment_get_value (tree_view->priv->hadjustment) > x)
9377                     gtk_adjustment_set_value (tree_view->priv->hadjustment, x);
9378                 }
9379             }
9380         }
9381
9382       gtk_adjustment_set_value (tree_view->priv->hadjustment, x);
9383     }
9384   else
9385     {
9386       if ((gtk_adjustment_get_value (tree_view->priv->hadjustment) + gtk_adjustment_get_page_size (tree_view->priv->hadjustment)) < (x + width))
9387           gtk_adjustment_set_value (tree_view->priv->hadjustment,
9388                                     x + width - gtk_adjustment_get_page_size (tree_view->priv->hadjustment));
9389       else if (gtk_adjustment_get_value (tree_view->priv->hadjustment) > x)
9390         gtk_adjustment_set_value (tree_view->priv->hadjustment, x);
9391   }
9392 }
9393
9394 /* This function could be more efficient.  I'll optimize it if profiling seems
9395  * to imply that it is important */
9396 GtkTreePath *
9397 _gtk_tree_view_find_path (GtkTreeView *tree_view,
9398                           GtkRBTree   *tree,
9399                           GtkRBNode   *node)
9400 {
9401   GtkTreePath *path;
9402   GtkRBTree *tmp_tree;
9403   GtkRBNode *tmp_node, *last;
9404   gint count;
9405
9406   path = gtk_tree_path_new ();
9407
9408   g_return_val_if_fail (node != NULL, path);
9409   g_return_val_if_fail (node != tree->nil, path);
9410
9411   count = 1 + node->left->count;
9412
9413   last = node;
9414   tmp_node = node->parent;
9415   tmp_tree = tree;
9416   while (tmp_tree)
9417     {
9418       while (tmp_node != tmp_tree->nil)
9419         {
9420           if (tmp_node->right == last)
9421             count += 1 + tmp_node->left->count;
9422           last = tmp_node;
9423           tmp_node = tmp_node->parent;
9424         }
9425       gtk_tree_path_prepend_index (path, count - 1);
9426       last = tmp_tree->parent_node;
9427       tmp_tree = tmp_tree->parent_tree;
9428       if (last)
9429         {
9430           count = 1 + last->left->count;
9431           tmp_node = last->parent;
9432         }
9433     }
9434   return path;
9435 }
9436
9437 /* Returns TRUE if we ran out of tree before finding the path.  If the path is
9438  * invalid (ie. points to a node that's not in the tree), *tree and *node are
9439  * both set to NULL.
9440  */
9441 gboolean
9442 _gtk_tree_view_find_node (GtkTreeView  *tree_view,
9443                           GtkTreePath  *path,
9444                           GtkRBTree   **tree,
9445                           GtkRBNode   **node)
9446 {
9447   GtkRBNode *tmpnode = NULL;
9448   GtkRBTree *tmptree = tree_view->priv->tree;
9449   gint *indices = gtk_tree_path_get_indices (path);
9450   gint depth = gtk_tree_path_get_depth (path);
9451   gint i = 0;
9452
9453   *node = NULL;
9454   *tree = NULL;
9455
9456   if (depth == 0 || tmptree == NULL)
9457     return FALSE;
9458   do
9459     {
9460       tmpnode = _gtk_rbtree_find_count (tmptree, indices[i] + 1);
9461       ++i;
9462       if (tmpnode == NULL)
9463         {
9464           *tree = NULL;
9465           *node = NULL;
9466           return FALSE;
9467         }
9468       if (i >= depth)
9469         {
9470           *tree = tmptree;
9471           *node = tmpnode;
9472           return FALSE;
9473         }
9474       *tree = tmptree;
9475       *node = tmpnode;
9476       tmptree = tmpnode->children;
9477       if (tmptree == NULL)
9478         return TRUE;
9479     }
9480   while (1);
9481 }
9482
9483 static gboolean
9484 gtk_tree_view_is_expander_column (GtkTreeView       *tree_view,
9485                                   GtkTreeViewColumn *column)
9486 {
9487   GList *list;
9488
9489   if (tree_view->priv->is_list)
9490     return FALSE;
9491
9492   if (tree_view->priv->expander_column != NULL)
9493     {
9494       if (tree_view->priv->expander_column == column)
9495         return TRUE;
9496       return FALSE;
9497     }
9498   else
9499     {
9500       for (list = tree_view->priv->columns;
9501            list;
9502            list = list->next)
9503         if (gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (list->data)))
9504           break;
9505       if (list && list->data == column)
9506         return TRUE;
9507     }
9508   return FALSE;
9509 }
9510
9511 static inline gboolean
9512 gtk_tree_view_draw_expanders (GtkTreeView *tree_view)
9513 {
9514   if (!tree_view->priv->is_list && tree_view->priv->show_expanders)
9515     return TRUE;
9516   /* else */
9517   return FALSE;
9518 }
9519
9520 static void
9521 gtk_tree_view_add_move_binding (GtkBindingSet  *binding_set,
9522                                 guint           keyval,
9523                                 guint           modmask,
9524                                 gboolean        add_shifted_binding,
9525                                 GtkMovementStep step,
9526                                 gint            count)
9527 {
9528
9529   gtk_binding_entry_add_signal (binding_set, keyval, modmask,
9530                                 "move-cursor", 2,
9531                                 G_TYPE_ENUM, step,
9532                                 G_TYPE_INT, count);
9533
9534   if (add_shifted_binding)
9535     gtk_binding_entry_add_signal (binding_set, keyval, GDK_SHIFT_MASK,
9536                                   "move-cursor", 2,
9537                                   G_TYPE_ENUM, step,
9538                                   G_TYPE_INT, count);
9539
9540   if ((modmask & GDK_CONTROL_MASK) == GDK_CONTROL_MASK)
9541    return;
9542
9543   gtk_binding_entry_add_signal (binding_set, keyval, GDK_CONTROL_MASK | GDK_SHIFT_MASK,
9544                                 "move-cursor", 2,
9545                                 G_TYPE_ENUM, step,
9546                                 G_TYPE_INT, count);
9547
9548   gtk_binding_entry_add_signal (binding_set, keyval, GDK_CONTROL_MASK,
9549                                 "move-cursor", 2,
9550                                 G_TYPE_ENUM, step,
9551                                 G_TYPE_INT, count);
9552 }
9553
9554 static gint
9555 gtk_tree_view_unref_tree_helper (GtkTreeModel *model,
9556                                  GtkTreeIter  *iter,
9557                                  GtkRBTree    *tree,
9558                                  GtkRBNode    *node)
9559 {
9560   gint retval = FALSE;
9561   do
9562     {
9563       g_return_val_if_fail (node != NULL, FALSE);
9564
9565       if (node->children)
9566         {
9567           GtkTreeIter child;
9568           GtkRBTree *new_tree;
9569           GtkRBNode *new_node;
9570
9571           new_tree = node->children;
9572           new_node = _gtk_rbtree_first (new_tree);
9573
9574           if (!gtk_tree_model_iter_children (model, &child, iter))
9575             return FALSE;
9576
9577           retval = retval || gtk_tree_view_unref_tree_helper (model, &child, new_tree, new_node);
9578         }
9579
9580       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
9581         retval = TRUE;
9582       gtk_tree_model_unref_node (model, iter);
9583       node = _gtk_rbtree_next (tree, node);
9584     }
9585   while (gtk_tree_model_iter_next (model, iter));
9586
9587   return retval;
9588 }
9589
9590 static gint
9591 gtk_tree_view_unref_and_check_selection_tree (GtkTreeView *tree_view,
9592                                               GtkRBTree   *tree)
9593 {
9594   GtkTreeIter iter;
9595   GtkTreePath *path;
9596   GtkRBNode *node;
9597   gint retval;
9598
9599   if (!tree)
9600     return FALSE;
9601
9602   node = _gtk_rbtree_first (tree);
9603
9604   g_return_val_if_fail (node != NULL, FALSE);
9605   path = _gtk_tree_view_find_path (tree_view, tree, node);
9606   gtk_tree_model_get_iter (GTK_TREE_MODEL (tree_view->priv->model),
9607                            &iter, path);
9608   retval = gtk_tree_view_unref_tree_helper (GTK_TREE_MODEL (tree_view->priv->model), &iter, tree, node);
9609   gtk_tree_path_free (path);
9610
9611   return retval;
9612 }
9613
9614 static void
9615 gtk_tree_view_set_column_drag_info (GtkTreeView       *tree_view,
9616                                     GtkTreeViewColumn *column)
9617 {
9618   GtkTreeViewColumn *left_column;
9619   GtkTreeViewColumn *cur_column = NULL;
9620   GtkTreeViewColumnReorder *reorder;
9621   gboolean rtl;
9622   GList *tmp_list;
9623   gint left;
9624
9625   /* We want to precalculate the motion list such that we know what column slots
9626    * are available.
9627    */
9628   left_column = NULL;
9629   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
9630
9631   /* First, identify all possible drop spots */
9632   if (rtl)
9633     tmp_list = g_list_last (tree_view->priv->columns);
9634   else
9635     tmp_list = g_list_first (tree_view->priv->columns);
9636
9637   while (tmp_list)
9638     {
9639       cur_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
9640       tmp_list = rtl?g_list_previous (tmp_list):g_list_next (tmp_list);
9641
9642       if (gtk_tree_view_column_get_visible (cur_column) == FALSE)
9643         continue;
9644
9645       /* If it's not the column moving and func tells us to skip over the column, we continue. */
9646       if (left_column != column && cur_column != column &&
9647           tree_view->priv->column_drop_func &&
9648           ! tree_view->priv->column_drop_func (tree_view, column, left_column, cur_column, tree_view->priv->column_drop_func_data))
9649         {
9650           left_column = cur_column;
9651           continue;
9652         }
9653       reorder = g_slice_new0 (GtkTreeViewColumnReorder);
9654       reorder->left_column = left_column;
9655       left_column = reorder->right_column = cur_column;
9656
9657       tree_view->priv->column_drag_info = g_list_append (tree_view->priv->column_drag_info, reorder);
9658     }
9659
9660   /* Add the last one */
9661   if (tree_view->priv->column_drop_func == NULL ||
9662       ((left_column != column) &&
9663        tree_view->priv->column_drop_func (tree_view, column, left_column, NULL, tree_view->priv->column_drop_func_data)))
9664     {
9665       reorder = g_slice_new0 (GtkTreeViewColumnReorder);
9666       reorder->left_column = left_column;
9667       reorder->right_column = NULL;
9668       tree_view->priv->column_drag_info = g_list_append (tree_view->priv->column_drag_info, reorder);
9669     }
9670
9671   /* We quickly check to see if it even makes sense to reorder columns. */
9672   /* If there is nothing that can be moved, then we return */
9673
9674   if (tree_view->priv->column_drag_info == NULL)
9675     return;
9676
9677   /* We know there are always 2 slots possbile, as you can always return column. */
9678   /* If that's all there is, return */
9679   if (tree_view->priv->column_drag_info->next == NULL ||
9680       (tree_view->priv->column_drag_info->next->next == NULL &&
9681        ((GtkTreeViewColumnReorder *)tree_view->priv->column_drag_info->data)->right_column == column &&
9682        ((GtkTreeViewColumnReorder *)tree_view->priv->column_drag_info->next->data)->left_column == column))
9683     {
9684       for (tmp_list = tree_view->priv->column_drag_info; tmp_list; tmp_list = tmp_list->next)
9685         g_slice_free (GtkTreeViewColumnReorder, tmp_list->data);
9686       g_list_free (tree_view->priv->column_drag_info);
9687       tree_view->priv->column_drag_info = NULL;
9688       return;
9689     }
9690   /* We fill in the ranges for the columns, now that we've isolated them */
9691   left = - TREE_VIEW_COLUMN_DRAG_DEAD_MULTIPLIER (tree_view);
9692
9693   for (tmp_list = tree_view->priv->column_drag_info; tmp_list; tmp_list = tmp_list->next)
9694     {
9695       reorder = (GtkTreeViewColumnReorder *) tmp_list->data;
9696
9697       reorder->left_align = left;
9698       if (tmp_list->next != NULL)
9699         {
9700           GtkAllocation right_allocation, left_allocation;
9701           GtkWidget    *left_button, *right_button;
9702
9703           g_assert (tmp_list->next->data);
9704
9705           right_button = gtk_tree_view_column_get_button (reorder->right_column);
9706           left_button  = gtk_tree_view_column_get_button
9707             (((GtkTreeViewColumnReorder *)tmp_list->next->data)->left_column);
9708
9709           gtk_widget_get_allocation (right_button, &right_allocation);
9710           gtk_widget_get_allocation (left_button, &left_allocation);
9711           left = reorder->right_align = (right_allocation.x + right_allocation.width + left_allocation.x) / 2;
9712         }
9713       else
9714         {
9715           reorder->right_align = gdk_window_get_width (tree_view->priv->header_window)
9716                                  + TREE_VIEW_COLUMN_DRAG_DEAD_MULTIPLIER (tree_view);
9717         }
9718     }
9719 }
9720
9721 void
9722 _gtk_tree_view_column_start_drag (GtkTreeView       *tree_view,
9723                                   GtkTreeViewColumn *column,
9724                                   GdkDevice         *device)
9725 {
9726   GdkEvent *send_event;
9727   GtkAllocation allocation;
9728   GtkAllocation button_allocation;
9729   GdkScreen *screen = gtk_widget_get_screen (GTK_WIDGET (tree_view));
9730   GtkWidget *button;
9731   GdkDevice *pointer, *keyboard;
9732
9733   g_return_if_fail (tree_view->priv->column_drag_info == NULL);
9734   g_return_if_fail (tree_view->priv->cur_reorder == NULL);
9735
9736   gtk_tree_view_set_column_drag_info (tree_view, column);
9737
9738   if (tree_view->priv->column_drag_info == NULL)
9739     return;
9740
9741   button = gtk_tree_view_column_get_button (column);
9742
9743   if (tree_view->priv->drag_window == NULL)
9744     {
9745       GdkWindowAttr attributes;
9746       guint attributes_mask;
9747
9748       gtk_widget_get_allocation (button, &button_allocation);
9749
9750       attributes.window_type = GDK_WINDOW_CHILD;
9751       attributes.wclass = GDK_INPUT_OUTPUT;
9752       attributes.x = button_allocation.x;
9753       attributes.y = 0;
9754       attributes.width = button_allocation.width;
9755       attributes.height = button_allocation.height;
9756       attributes.visual = gtk_widget_get_visual (GTK_WIDGET (tree_view));
9757       attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK;
9758       attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
9759
9760       tree_view->priv->drag_window = gdk_window_new (tree_view->priv->bin_window,
9761                                                      &attributes,
9762                                                      attributes_mask);
9763       gdk_window_set_user_data (tree_view->priv->drag_window, GTK_WIDGET (tree_view));
9764     }
9765
9766   if (gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD)
9767     {
9768       keyboard = device;
9769       pointer = gdk_device_get_associated_device (device);
9770     }
9771   else
9772     {
9773       pointer = device;
9774       keyboard = gdk_device_get_associated_device (device);
9775     }
9776
9777   gdk_device_ungrab (pointer, GDK_CURRENT_TIME);
9778   gdk_device_ungrab (keyboard, GDK_CURRENT_TIME);
9779
9780   gtk_grab_remove (button);
9781
9782   send_event = gdk_event_new (GDK_LEAVE_NOTIFY);
9783   send_event->crossing.send_event = TRUE;
9784   send_event->crossing.window = g_object_ref (gtk_button_get_event_window (GTK_BUTTON (button)));
9785   send_event->crossing.subwindow = NULL;
9786   send_event->crossing.detail = GDK_NOTIFY_ANCESTOR;
9787   send_event->crossing.time = GDK_CURRENT_TIME;
9788   gdk_event_set_device (send_event, device);
9789
9790   gtk_propagate_event (button, send_event);
9791   gdk_event_free (send_event);
9792
9793   send_event = gdk_event_new (GDK_BUTTON_RELEASE);
9794   send_event->button.window = g_object_ref (gdk_screen_get_root_window (screen));
9795   send_event->button.send_event = TRUE;
9796   send_event->button.time = GDK_CURRENT_TIME;
9797   send_event->button.x = -1;
9798   send_event->button.y = -1;
9799   send_event->button.axes = NULL;
9800   send_event->button.state = 0;
9801   send_event->button.button = 1;
9802   send_event->button.x_root = 0;
9803   send_event->button.y_root = 0;
9804   gdk_event_set_device (send_event, device);
9805
9806   gtk_propagate_event (button, send_event);
9807   gdk_event_free (send_event);
9808
9809   /* Kids, don't try this at home */
9810   g_object_ref (button);
9811   gtk_container_remove (GTK_CONTAINER (tree_view), button);
9812   gtk_widget_set_parent_window (button, tree_view->priv->drag_window);
9813   gtk_widget_set_parent (button, GTK_WIDGET (tree_view));
9814   g_object_unref (button);
9815
9816   gtk_widget_get_allocation (button, &button_allocation);
9817   tree_view->priv->drag_column_x = button_allocation.x;
9818   allocation = button_allocation;
9819   allocation.x = 0;
9820   gtk_widget_size_allocate (button, &allocation);
9821   gtk_widget_set_parent_window (button, tree_view->priv->drag_window);
9822
9823   tree_view->priv->drag_column = column;
9824   gdk_window_show (tree_view->priv->drag_window);
9825
9826   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
9827   while (gtk_events_pending ())
9828     gtk_main_iteration ();
9829
9830   tree_view->priv->in_column_drag = TRUE;
9831
9832   gdk_device_grab (pointer,
9833                    tree_view->priv->drag_window,
9834                    GDK_OWNERSHIP_NONE,
9835                    FALSE,
9836                    GDK_POINTER_MOTION_MASK|GDK_BUTTON_RELEASE_MASK,
9837                    NULL,
9838                    GDK_CURRENT_TIME);
9839   gdk_device_grab (keyboard,
9840                    tree_view->priv->drag_window,
9841                    GDK_OWNERSHIP_NONE,
9842                    FALSE,
9843                    GDK_KEY_PRESS_MASK|GDK_KEY_RELEASE_MASK,
9844                    NULL,
9845                    GDK_CURRENT_TIME);
9846 }
9847
9848 static void
9849 gtk_tree_view_queue_draw_arrow (GtkTreeView        *tree_view,
9850                                 GtkRBTree          *tree,
9851                                 GtkRBNode          *node)
9852 {
9853   GtkAllocation allocation;
9854   GdkRectangle rect;
9855
9856   if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
9857     return;
9858
9859   gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
9860   rect.x = 0;
9861   rect.width = MAX (tree_view->priv->expander_size, MAX (tree_view->priv->width, allocation.width));
9862
9863   rect.y = gtk_tree_view_get_row_y_offset (tree_view, tree, node);
9864   rect.height = gtk_tree_view_get_row_height (tree_view, node);
9865
9866   gdk_window_invalidate_rect (tree_view->priv->bin_window, &rect, TRUE);
9867 }
9868
9869 void
9870 _gtk_tree_view_queue_draw_node (GtkTreeView        *tree_view,
9871                                 GtkRBTree          *tree,
9872                                 GtkRBNode          *node,
9873                                 const GdkRectangle *clip_rect)
9874 {
9875   GtkAllocation allocation;
9876   GdkRectangle rect;
9877
9878   if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
9879     return;
9880
9881   gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
9882   rect.x = 0;
9883   rect.width = MAX (tree_view->priv->width, allocation.width);
9884
9885   rect.y = gtk_tree_view_get_row_y_offset (tree_view, tree, node);
9886   rect.height = gtk_tree_view_get_row_height (tree_view, node);
9887
9888   if (clip_rect)
9889     {
9890       GdkRectangle new_rect;
9891
9892       gdk_rectangle_intersect (clip_rect, &rect, &new_rect);
9893
9894       gdk_window_invalidate_rect (tree_view->priv->bin_window, &new_rect, TRUE);
9895     }
9896   else
9897     {
9898       gdk_window_invalidate_rect (tree_view->priv->bin_window, &rect, TRUE);
9899     }
9900 }
9901
9902 static inline gint
9903 gtk_tree_view_get_effective_header_height (GtkTreeView *tree_view)
9904 {
9905   if (tree_view->priv->headers_visible)
9906     return tree_view->priv->header_height;
9907   /* else */
9908   return 0;
9909 }
9910
9911 gint
9912 _gtk_tree_view_get_header_height (GtkTreeView *tree_view)
9913 {
9914   return tree_view->priv->header_height;
9915 }
9916
9917 void
9918 _gtk_tree_view_get_row_separator_func (GtkTreeView                 *tree_view,
9919                                        GtkTreeViewRowSeparatorFunc *func,
9920                                        gpointer                    *data)
9921 {
9922   *func = tree_view->priv->row_separator_func;
9923   *data = tree_view->priv->row_separator_data;
9924 }
9925
9926 GtkTreePath *
9927 _gtk_tree_view_get_anchor_path (GtkTreeView *tree_view)
9928 {
9929   if (tree_view->priv->anchor)
9930     return gtk_tree_row_reference_get_path (tree_view->priv->anchor);
9931
9932   return NULL;
9933 }
9934
9935 void
9936 _gtk_tree_view_set_anchor_path (GtkTreeView *tree_view,
9937                                 GtkTreePath *anchor_path)
9938 {
9939   if (tree_view->priv->anchor)
9940     {
9941       gtk_tree_row_reference_free (tree_view->priv->anchor);
9942       tree_view->priv->anchor = NULL;
9943     }
9944
9945   if (anchor_path && tree_view->priv->model)
9946     tree_view->priv->anchor =
9947       gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view),
9948                                         tree_view->priv->model, anchor_path);
9949 }
9950
9951 GtkRBTree *
9952 _gtk_tree_view_get_rbtree (GtkTreeView *tree_view)
9953 {
9954   return tree_view->priv->tree;
9955 }
9956
9957 GdkWindow *
9958 _gtk_tree_view_get_header_window (GtkTreeView *tree_view)
9959 {
9960   return tree_view->priv->header_window;
9961 }
9962
9963 void
9964 _gtk_tree_view_set_focus_column (GtkTreeView       *tree_view,
9965                                  GtkTreeViewColumn *column)
9966 {
9967   tree_view->priv->focus_column = column;
9968 }
9969
9970
9971 static void
9972 gtk_tree_view_queue_draw_path (GtkTreeView        *tree_view,
9973                                GtkTreePath        *path,
9974                                const GdkRectangle *clip_rect)
9975 {
9976   GtkRBTree *tree = NULL;
9977   GtkRBNode *node = NULL;
9978
9979   _gtk_tree_view_find_node (tree_view, path, &tree, &node);
9980
9981   if (tree)
9982     _gtk_tree_view_queue_draw_node (tree_view, tree, node, clip_rect);
9983 }
9984
9985 /* x and y are the mouse position
9986  */
9987 static void
9988 gtk_tree_view_draw_arrow (GtkTreeView *tree_view,
9989                           cairo_t     *cr,
9990                           GtkRBTree   *tree,
9991                           GtkRBNode   *node)
9992 {
9993   GdkRectangle area;
9994   GtkStateFlags state = 0;
9995   GtkStyleContext *context;
9996   GtkWidget *widget;
9997   gint x_offset = 0;
9998   gint x2;
9999   gint vertical_separator;
10000   gint expander_size;
10001   GtkCellRendererState flags;
10002
10003   widget = GTK_WIDGET (tree_view);
10004   context = gtk_widget_get_style_context (widget);
10005
10006   gtk_widget_style_get (widget,
10007                         "vertical-separator", &vertical_separator,
10008                         NULL);
10009   expander_size = tree_view->priv->expander_size - EXPANDER_EXTRA_PADDING;
10010
10011   if (! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT))
10012     return;
10013
10014   gtk_tree_view_get_arrow_xrange (tree_view, tree, &x_offset, &x2);
10015
10016   area.x = x_offset;
10017   area.y = gtk_tree_view_get_cell_area_y_offset (tree_view, tree, node,
10018                                                  vertical_separator);
10019   area.width = expander_size;
10020   area.height = gtk_tree_view_get_cell_area_height (tree_view, node,
10021                                                     vertical_separator);
10022
10023   if (!gtk_widget_get_sensitive (widget))
10024     state |= GTK_STATE_FLAG_INSENSITIVE;
10025   else
10026     {
10027       flags = 0;
10028
10029       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
10030         flags |= GTK_CELL_RENDERER_SELECTED;
10031
10032       state = gtk_cell_renderer_get_state (NULL, widget, flags);
10033
10034       if (node == tree_view->priv->prelight_node &&
10035           tree_view->priv->arrow_prelit)
10036         state |= GTK_STATE_FLAG_PRELIGHT;
10037     }
10038
10039   if (node->children != NULL)
10040     state |= GTK_STATE_FLAG_ACTIVE;
10041
10042   gtk_style_context_save (context);
10043
10044   gtk_style_context_set_state (context, state);
10045   gtk_style_context_add_class (context, GTK_STYLE_CLASS_EXPANDER);
10046
10047   gtk_style_context_push_animatable_region (context, node);
10048
10049   gtk_render_expander (context, cr,
10050                        area.x, area.y,
10051                        area.width, area.height);
10052
10053   gtk_style_context_pop_animatable_region (context);
10054   gtk_style_context_restore (context);
10055 }
10056
10057 static void
10058 gtk_tree_view_focus_to_cursor (GtkTreeView *tree_view)
10059
10060 {
10061   GtkTreePath *cursor_path;
10062
10063   if ((tree_view->priv->tree == NULL) ||
10064       (! gtk_widget_get_realized (GTK_WIDGET (tree_view))))
10065     return;
10066
10067   cursor_path = NULL;
10068   if (tree_view->priv->cursor)
10069     cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
10070
10071   if (cursor_path == NULL)
10072     {
10073       /* Consult the selection before defaulting to the
10074        * first focusable element
10075        */
10076       GList *selected_rows;
10077       GtkTreeModel *model;
10078       GtkTreeSelection *selection;
10079
10080       selection = gtk_tree_view_get_selection (tree_view);
10081       selected_rows = gtk_tree_selection_get_selected_rows (selection, &model);
10082
10083       if (selected_rows)
10084         {
10085           cursor_path = gtk_tree_path_copy((const GtkTreePath *)(selected_rows->data));
10086           g_list_foreach (selected_rows, (GFunc)gtk_tree_path_free, NULL);
10087           g_list_free (selected_rows);
10088         }
10089       else
10090         {
10091           cursor_path = gtk_tree_path_new_first ();
10092           search_first_focusable_path (tree_view, &cursor_path,
10093                                        TRUE, NULL, NULL);
10094         }
10095
10096       gtk_tree_row_reference_free (tree_view->priv->cursor);
10097       tree_view->priv->cursor = NULL;
10098
10099       if (cursor_path)
10100         {
10101           if (gtk_tree_selection_get_mode (tree_view->priv->selection) == GTK_SELECTION_MULTIPLE)
10102             gtk_tree_view_real_set_cursor (tree_view, cursor_path, FALSE, FALSE);
10103           else
10104             gtk_tree_view_real_set_cursor (tree_view, cursor_path, TRUE, FALSE);
10105         }
10106     }
10107
10108   if (cursor_path)
10109     {
10110       tree_view->priv->draw_keyfocus = TRUE;
10111
10112       gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
10113       gtk_tree_path_free (cursor_path);
10114
10115       if (tree_view->priv->focus_column == NULL)
10116         {
10117           GList *list;
10118           for (list = tree_view->priv->columns; list; list = list->next)
10119             {
10120               if (gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (list->data)))
10121                 {
10122                   GtkCellArea *cell_area;
10123
10124                   tree_view->priv->focus_column = GTK_TREE_VIEW_COLUMN (list->data);
10125
10126                   /* This happens when the treeview initially grabs focus and there
10127                    * is no column in focus, here we explicitly focus into the first cell */
10128                   cell_area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (tree_view->priv->focus_column));
10129                   if (!gtk_cell_area_get_focus_cell (cell_area))
10130                     {
10131                       gboolean rtl;
10132
10133                       rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
10134                       gtk_cell_area_focus (cell_area,
10135                                            rtl ? GTK_DIR_LEFT : GTK_DIR_RIGHT);
10136                     }
10137
10138                   break;
10139                 }
10140             }
10141         }
10142     }
10143 }
10144
10145 static void
10146 gtk_tree_view_move_cursor_up_down (GtkTreeView *tree_view,
10147                                    gint         count)
10148 {
10149   gint selection_count;
10150   GtkRBTree *cursor_tree = NULL;
10151   GtkRBNode *cursor_node = NULL;
10152   GtkRBTree *new_cursor_tree = NULL;
10153   GtkRBNode *new_cursor_node = NULL;
10154   GtkTreePath *cursor_path = NULL;
10155   gboolean grab_focus = TRUE;
10156   gboolean selectable;
10157   GtkDirectionType direction;
10158   GtkCellArea *cell_area = NULL;
10159   GtkCellRenderer *last_focus_cell = NULL;
10160   GtkTreeIter iter;
10161
10162   if (! gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10163     return;
10164
10165   cursor_path = NULL;
10166   if (!gtk_tree_row_reference_valid (tree_view->priv->cursor))
10167     /* FIXME: we lost the cursor; should we get the first? */
10168     return;
10169
10170   cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
10171   _gtk_tree_view_find_node (tree_view, cursor_path,
10172                             &cursor_tree, &cursor_node);
10173
10174   if (cursor_tree == NULL)
10175     /* FIXME: we lost the cursor; should we get the first? */
10176     return;
10177
10178   direction = count < 0 ? GTK_DIR_UP : GTK_DIR_DOWN;
10179
10180   if (tree_view->priv->focus_column)
10181     cell_area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (tree_view->priv->focus_column));
10182
10183   /* If focus stays in the area for this row, then just return for this round */
10184   if (cell_area && (count == -1 || count == 1) &&
10185       gtk_tree_model_get_iter (tree_view->priv->model, &iter, cursor_path))
10186     {
10187       gtk_tree_view_column_cell_set_cell_data (tree_view->priv->focus_column,
10188                                                tree_view->priv->model,
10189                                                &iter,
10190                                                GTK_RBNODE_FLAG_SET (cursor_node, GTK_RBNODE_IS_PARENT),
10191                                                cursor_node->children?TRUE:FALSE);
10192
10193       /* Save the last cell that had focus, if we hit the end of the view we'll give
10194        * focus back to it. */
10195       last_focus_cell = gtk_cell_area_get_focus_cell (cell_area);
10196
10197       /* If focus stays in the area, no need to change the cursor row */
10198       if (gtk_cell_area_focus (cell_area, direction))
10199         return;
10200     }
10201
10202   selection_count = gtk_tree_selection_count_selected_rows (tree_view->priv->selection);
10203   selectable = _gtk_tree_selection_row_is_selectable (tree_view->priv->selection,
10204                                                       cursor_node,
10205                                                       cursor_path);
10206
10207   if (selection_count == 0
10208       && gtk_tree_selection_get_mode (tree_view->priv->selection) != GTK_SELECTION_NONE
10209       && !tree_view->priv->modify_selection_pressed
10210       && selectable)
10211     {
10212       /* Don't move the cursor, but just select the current node */
10213       new_cursor_tree = cursor_tree;
10214       new_cursor_node = cursor_node;
10215     }
10216   else
10217     {
10218       if (count == -1)
10219         _gtk_rbtree_prev_full (cursor_tree, cursor_node,
10220                                &new_cursor_tree, &new_cursor_node);
10221       else
10222         _gtk_rbtree_next_full (cursor_tree, cursor_node,
10223                                &new_cursor_tree, &new_cursor_node);
10224     }
10225
10226   gtk_tree_path_free (cursor_path);
10227
10228   if (new_cursor_node)
10229     {
10230       cursor_path = _gtk_tree_view_find_path (tree_view,
10231                                               new_cursor_tree, new_cursor_node);
10232
10233       search_first_focusable_path (tree_view, &cursor_path,
10234                                    (count != -1),
10235                                    &new_cursor_tree,
10236                                    &new_cursor_node);
10237
10238       if (cursor_path)
10239         gtk_tree_path_free (cursor_path);
10240     }
10241
10242   /*
10243    * If the list has only one item and multi-selection is set then select
10244    * the row (if not yet selected).
10245    */
10246   if (gtk_tree_selection_get_mode (tree_view->priv->selection) == GTK_SELECTION_MULTIPLE &&
10247       new_cursor_node == NULL)
10248     {
10249       if (count == -1)
10250         _gtk_rbtree_next_full (cursor_tree, cursor_node,
10251                                &new_cursor_tree, &new_cursor_node);
10252       else
10253         _gtk_rbtree_prev_full (cursor_tree, cursor_node,
10254                                &new_cursor_tree, &new_cursor_node);
10255
10256       if (new_cursor_node == NULL
10257           && !GTK_RBNODE_FLAG_SET (cursor_node, GTK_RBNODE_IS_SELECTED))
10258         {
10259           new_cursor_node = cursor_node;
10260           new_cursor_tree = cursor_tree;
10261         }
10262       else
10263         {
10264           new_cursor_node = NULL;
10265         }
10266     }
10267
10268   if (new_cursor_node)
10269     {
10270       cursor_path = _gtk_tree_view_find_path (tree_view, new_cursor_tree, new_cursor_node);
10271       gtk_tree_view_real_set_cursor (tree_view, cursor_path, TRUE, TRUE);
10272       gtk_tree_path_free (cursor_path);
10273
10274       /* Give focus to the area in the new row */
10275       if (cell_area)
10276         gtk_cell_area_focus (cell_area, direction);
10277     }
10278   else
10279     {
10280       gtk_tree_view_clamp_node_visible (tree_view, cursor_tree, cursor_node);
10281
10282       if (!tree_view->priv->extend_selection_pressed)
10283         {
10284           if (! gtk_widget_keynav_failed (GTK_WIDGET (tree_view),
10285                                           count < 0 ?
10286                                           GTK_DIR_UP : GTK_DIR_DOWN))
10287             {
10288               GtkWidget *toplevel = gtk_widget_get_toplevel (GTK_WIDGET (tree_view));
10289
10290               if (toplevel)
10291                 gtk_widget_child_focus (toplevel,
10292                                         count < 0 ?
10293                                         GTK_DIR_TAB_BACKWARD :
10294                                         GTK_DIR_TAB_FORWARD);
10295
10296               grab_focus = FALSE;
10297             }
10298         }
10299       else
10300         {
10301           gtk_widget_error_bell (GTK_WIDGET (tree_view));
10302         }
10303
10304       if (cell_area)
10305         gtk_cell_area_set_focus_cell (cell_area, last_focus_cell);
10306     }
10307
10308   if (grab_focus)
10309     gtk_widget_grab_focus (GTK_WIDGET (tree_view));
10310 }
10311
10312 static void
10313 gtk_tree_view_move_cursor_page_up_down (GtkTreeView *tree_view,
10314                                         gint         count)
10315 {
10316   GtkRBTree *cursor_tree = NULL;
10317   GtkRBNode *cursor_node = NULL;
10318   GtkTreePath *old_cursor_path = NULL;
10319   GtkTreePath *cursor_path = NULL;
10320   GtkRBTree *start_cursor_tree = NULL;
10321   GtkRBNode *start_cursor_node = NULL;
10322   gint y;
10323   gint window_y;
10324   gint vertical_separator;
10325
10326   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10327     return;
10328
10329   if (gtk_tree_row_reference_valid (tree_view->priv->cursor))
10330     old_cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
10331   else
10332     /* This is sorta weird.  Focus in should give us a cursor */
10333     return;
10334
10335   gtk_widget_style_get (GTK_WIDGET (tree_view), "vertical-separator", &vertical_separator, NULL);
10336   _gtk_tree_view_find_node (tree_view, old_cursor_path,
10337                             &cursor_tree, &cursor_node);
10338
10339   if (cursor_tree == NULL)
10340     {
10341       /* FIXME: we lost the cursor.  Should we try to get one? */
10342       gtk_tree_path_free (old_cursor_path);
10343       return;
10344     }
10345   g_return_if_fail (cursor_node != NULL);
10346
10347   y = _gtk_rbtree_node_find_offset (cursor_tree, cursor_node);
10348   window_y = RBTREE_Y_TO_TREE_WINDOW_Y (tree_view, y);
10349   y += tree_view->priv->cursor_offset;
10350   y += count * (int)gtk_adjustment_get_page_increment (tree_view->priv->vadjustment);
10351   y = CLAMP (y, (gint)gtk_adjustment_get_lower (tree_view->priv->vadjustment),  (gint)gtk_adjustment_get_upper (tree_view->priv->vadjustment) - vertical_separator);
10352
10353   if (y >= tree_view->priv->height)
10354     y = tree_view->priv->height - 1;
10355
10356   tree_view->priv->cursor_offset =
10357     _gtk_rbtree_find_offset (tree_view->priv->tree, y,
10358                              &cursor_tree, &cursor_node);
10359
10360   if (cursor_tree == NULL)
10361     {
10362       /* FIXME: we lost the cursor.  Should we try to get one? */
10363       gtk_tree_path_free (old_cursor_path);
10364       return;
10365     }
10366
10367   if (tree_view->priv->cursor_offset
10368       > gtk_tree_view_get_row_height (tree_view, cursor_node))
10369     {
10370       _gtk_rbtree_next_full (cursor_tree, cursor_node,
10371                              &cursor_tree, &cursor_node);
10372       tree_view->priv->cursor_offset -= gtk_tree_view_get_row_height (tree_view, cursor_node);
10373     }
10374
10375   y -= tree_view->priv->cursor_offset;
10376   cursor_path = _gtk_tree_view_find_path (tree_view, cursor_tree, cursor_node);
10377
10378   start_cursor_tree = cursor_tree;
10379   start_cursor_node = cursor_node;
10380
10381   if (! search_first_focusable_path (tree_view, &cursor_path,
10382                                      (count != -1),
10383                                      &cursor_tree, &cursor_node))
10384     {
10385       /* It looks like we reached the end of the view without finding
10386        * a focusable row.  We will step backwards to find the last
10387        * focusable row.
10388        */
10389       cursor_tree = start_cursor_tree;
10390       cursor_node = start_cursor_node;
10391       cursor_path = _gtk_tree_view_find_path (tree_view, cursor_tree, cursor_node);
10392
10393       search_first_focusable_path (tree_view, &cursor_path,
10394                                    (count == -1),
10395                                    &cursor_tree, &cursor_node);
10396     }
10397
10398   if (!cursor_path)
10399     goto cleanup;
10400
10401   /* update y */
10402   y = _gtk_rbtree_node_find_offset (cursor_tree, cursor_node);
10403
10404   gtk_tree_view_real_set_cursor (tree_view, cursor_path, TRUE, FALSE);
10405
10406   y -= window_y;
10407   gtk_tree_view_scroll_to_point (tree_view, -1, y);
10408   gtk_tree_view_clamp_node_visible (tree_view, cursor_tree, cursor_node);
10409   _gtk_tree_view_queue_draw_node (tree_view, cursor_tree, cursor_node, NULL);
10410
10411   if (!gtk_tree_path_compare (old_cursor_path, cursor_path))
10412     gtk_widget_error_bell (GTK_WIDGET (tree_view));
10413
10414   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
10415
10416 cleanup:
10417   gtk_tree_path_free (old_cursor_path);
10418   gtk_tree_path_free (cursor_path);
10419 }
10420
10421 static void
10422 gtk_tree_view_move_cursor_left_right (GtkTreeView *tree_view,
10423                                       gint         count)
10424 {
10425   GtkRBTree *cursor_tree = NULL;
10426   GtkRBNode *cursor_node = NULL;
10427   GtkTreePath *cursor_path = NULL;
10428   GtkTreeViewColumn *column;
10429   GtkTreeIter iter;
10430   GList *list;
10431   gboolean found_column = FALSE;
10432   gboolean rtl;
10433   GtkDirectionType direction;
10434   GtkCellArea     *cell_area;
10435   GtkCellRenderer *last_focus_cell = NULL;
10436   GtkCellArea     *last_focus_area = NULL;
10437
10438   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
10439
10440   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10441     return;
10442
10443   if (gtk_tree_row_reference_valid (tree_view->priv->cursor))
10444     cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
10445   else
10446     return;
10447
10448   _gtk_tree_view_find_node (tree_view, cursor_path, &cursor_tree, &cursor_node);
10449   if (cursor_tree == NULL)
10450     return;
10451   if (gtk_tree_model_get_iter (tree_view->priv->model, &iter, cursor_path) == FALSE)
10452     {
10453       gtk_tree_path_free (cursor_path);
10454       return;
10455     }
10456   gtk_tree_path_free (cursor_path);
10457
10458   list = rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns);
10459   if (tree_view->priv->focus_column)
10460     {
10461       /* Save the cell/area we are moving focus from, if moving the cursor
10462        * by one step hits the end we'll set focus back here */
10463       last_focus_area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (tree_view->priv->focus_column));
10464       last_focus_cell = gtk_cell_area_get_focus_cell (last_focus_area);
10465
10466       for (; list; list = (rtl ? list->prev : list->next))
10467         {
10468           if (list->data == tree_view->priv->focus_column)
10469             break;
10470         }
10471     }
10472
10473   direction = count > 0 ? GTK_DIR_RIGHT : GTK_DIR_LEFT;
10474
10475   while (list)
10476     {
10477       column = list->data;
10478       if (gtk_tree_view_column_get_visible (column) == FALSE)
10479         goto loop_end;
10480
10481       gtk_tree_view_column_cell_set_cell_data (column,
10482                                                tree_view->priv->model,
10483                                                &iter,
10484                                                GTK_RBNODE_FLAG_SET (cursor_node, GTK_RBNODE_IS_PARENT),
10485                                                cursor_node->children?TRUE:FALSE);
10486
10487       cell_area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (column));
10488       if (gtk_cell_area_focus (cell_area, direction))
10489         {
10490           tree_view->priv->focus_column = column;
10491           found_column = TRUE;
10492           break;
10493         }
10494
10495     loop_end:
10496       if (count == 1)
10497         list = rtl ? list->prev : list->next;
10498       else
10499         list = rtl ? list->next : list->prev;
10500     }
10501
10502   if (found_column)
10503     {
10504       if (!gtk_tree_view_has_can_focus_cell (tree_view))
10505         _gtk_tree_view_queue_draw_node (tree_view,
10506                                         cursor_tree,
10507                                         cursor_node,
10508                                         NULL);
10509       g_signal_emit (tree_view, tree_view_signals[CURSOR_CHANGED], 0);
10510       gtk_widget_grab_focus (GTK_WIDGET (tree_view));
10511     }
10512   else
10513     {
10514       gtk_widget_error_bell (GTK_WIDGET (tree_view));
10515
10516       if (last_focus_area)
10517         gtk_cell_area_set_focus_cell (last_focus_area, last_focus_cell);
10518     }
10519
10520   gtk_tree_view_clamp_column_visible (tree_view,
10521                                       tree_view->priv->focus_column, TRUE);
10522 }
10523
10524 static void
10525 gtk_tree_view_move_cursor_start_end (GtkTreeView *tree_view,
10526                                      gint         count)
10527 {
10528   GtkRBTree *cursor_tree;
10529   GtkRBNode *cursor_node;
10530   GtkTreePath *path;
10531   GtkTreePath *old_path;
10532
10533   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10534     return;
10535
10536   g_return_if_fail (tree_view->priv->tree != NULL);
10537
10538   gtk_tree_view_get_cursor (tree_view, &old_path, NULL);
10539
10540   cursor_tree = tree_view->priv->tree;
10541
10542   if (count == -1)
10543     {
10544       cursor_node = _gtk_rbtree_first (cursor_tree);
10545
10546       /* Now go forward to find the first focusable row. */
10547       path = _gtk_tree_view_find_path (tree_view, cursor_tree, cursor_node);
10548       search_first_focusable_path (tree_view, &path,
10549                                    TRUE, &cursor_tree, &cursor_node);
10550     }
10551   else
10552     {
10553       cursor_node = cursor_tree->root;
10554
10555       do
10556         {
10557           while (cursor_node && cursor_node->right != cursor_tree->nil)
10558             cursor_node = cursor_node->right;
10559           if (cursor_node->children == NULL)
10560             break;
10561
10562           cursor_tree = cursor_node->children;
10563           cursor_node = cursor_tree->root;
10564         }
10565       while (1);
10566
10567       /* Now go backwards to find last focusable row. */
10568       path = _gtk_tree_view_find_path (tree_view, cursor_tree, cursor_node);
10569       search_first_focusable_path (tree_view, &path,
10570                                    FALSE, &cursor_tree, &cursor_node);
10571     }
10572
10573   if (!path)
10574     goto cleanup;
10575
10576   if (gtk_tree_path_compare (old_path, path))
10577     {
10578       gtk_tree_view_real_set_cursor (tree_view, path, TRUE, TRUE);
10579       gtk_widget_grab_focus (GTK_WIDGET (tree_view));
10580     }
10581   else
10582     {
10583       gtk_widget_error_bell (GTK_WIDGET (tree_view));
10584     }
10585
10586 cleanup:
10587   gtk_tree_path_free (old_path);
10588   gtk_tree_path_free (path);
10589 }
10590
10591 static gboolean
10592 gtk_tree_view_real_select_all (GtkTreeView *tree_view)
10593 {
10594   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10595     return FALSE;
10596
10597   if (gtk_tree_selection_get_mode (tree_view->priv->selection) != GTK_SELECTION_MULTIPLE)
10598     return FALSE;
10599
10600   gtk_tree_selection_select_all (tree_view->priv->selection);
10601
10602   return TRUE;
10603 }
10604
10605 static gboolean
10606 gtk_tree_view_real_unselect_all (GtkTreeView *tree_view)
10607 {
10608   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10609     return FALSE;
10610
10611   if (gtk_tree_selection_get_mode (tree_view->priv->selection) != GTK_SELECTION_MULTIPLE)
10612     return FALSE;
10613
10614   gtk_tree_selection_unselect_all (tree_view->priv->selection);
10615
10616   return TRUE;
10617 }
10618
10619 static gboolean
10620 gtk_tree_view_real_select_cursor_row (GtkTreeView *tree_view,
10621                                       gboolean     start_editing)
10622 {
10623   GtkRBTree *new_tree = NULL;
10624   GtkRBNode *new_node = NULL;
10625   GtkRBTree *cursor_tree = NULL;
10626   GtkRBNode *cursor_node = NULL;
10627   GtkTreePath *cursor_path = NULL;
10628   GtkTreeSelectMode mode = 0;
10629
10630   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10631     return FALSE;
10632
10633   if (tree_view->priv->cursor)
10634     cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
10635
10636   if (cursor_path == NULL)
10637     return FALSE;
10638
10639   _gtk_tree_view_find_node (tree_view, cursor_path,
10640                             &cursor_tree, &cursor_node);
10641
10642   if (cursor_tree == NULL)
10643     {
10644       gtk_tree_path_free (cursor_path);
10645       return FALSE;
10646     }
10647
10648   if (!tree_view->priv->extend_selection_pressed && start_editing &&
10649       tree_view->priv->focus_column)
10650     {
10651       if (gtk_tree_view_start_editing (tree_view, cursor_path, FALSE))
10652         {
10653           gtk_tree_path_free (cursor_path);
10654           return TRUE;
10655         }
10656     }
10657
10658   if (tree_view->priv->modify_selection_pressed)
10659     mode |= GTK_TREE_SELECT_MODE_TOGGLE;
10660   if (tree_view->priv->extend_selection_pressed)
10661     mode |= GTK_TREE_SELECT_MODE_EXTEND;
10662
10663   _gtk_tree_selection_internal_select_node (tree_view->priv->selection,
10664                                             cursor_node,
10665                                             cursor_tree,
10666                                             cursor_path,
10667                                             mode,
10668                                             FALSE);
10669
10670   /* We bail out if the original (tree, node) don't exist anymore after
10671    * handling the selection-changed callback.  We do return TRUE because
10672    * the key press has been handled at this point.
10673    */
10674   _gtk_tree_view_find_node (tree_view, cursor_path, &new_tree, &new_node);
10675
10676   if (cursor_tree != new_tree || cursor_node != new_node)
10677     return FALSE;
10678
10679   gtk_tree_view_clamp_node_visible (tree_view, cursor_tree, cursor_node);
10680
10681   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
10682   _gtk_tree_view_queue_draw_node (tree_view, cursor_tree, cursor_node, NULL);
10683
10684   if (!tree_view->priv->extend_selection_pressed)
10685     gtk_tree_view_row_activated (tree_view, cursor_path,
10686                                  tree_view->priv->focus_column);
10687
10688   gtk_tree_path_free (cursor_path);
10689
10690   return TRUE;
10691 }
10692
10693 static gboolean
10694 gtk_tree_view_real_toggle_cursor_row (GtkTreeView *tree_view)
10695 {
10696   GtkRBTree *new_tree = NULL;
10697   GtkRBNode *new_node = NULL;
10698   GtkRBTree *cursor_tree = NULL;
10699   GtkRBNode *cursor_node = NULL;
10700   GtkTreePath *cursor_path = NULL;
10701
10702   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10703     return FALSE;
10704
10705   cursor_path = NULL;
10706   if (tree_view->priv->cursor)
10707     cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
10708
10709   if (cursor_path == NULL)
10710     return FALSE;
10711
10712   _gtk_tree_view_find_node (tree_view, cursor_path,
10713                             &cursor_tree, &cursor_node);
10714   if (cursor_tree == NULL)
10715     {
10716       gtk_tree_path_free (cursor_path);
10717       return FALSE;
10718     }
10719
10720   _gtk_tree_selection_internal_select_node (tree_view->priv->selection,
10721                                             cursor_node,
10722                                             cursor_tree,
10723                                             cursor_path,
10724                                             GTK_TREE_SELECT_MODE_TOGGLE,
10725                                             FALSE);
10726
10727   /* We bail out if the original (tree, node) don't exist anymore after
10728    * handling the selection-changed callback.  We do return TRUE because
10729    * the key press has been handled at this point.
10730    */
10731   _gtk_tree_view_find_node (tree_view, cursor_path, &new_tree, &new_node);
10732
10733   if (cursor_tree != new_tree || cursor_node != new_node)
10734     return FALSE;
10735
10736   gtk_tree_view_clamp_node_visible (tree_view, cursor_tree, cursor_node);
10737
10738   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
10739   gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
10740   gtk_tree_path_free (cursor_path);
10741
10742   return TRUE;
10743 }
10744
10745 static gboolean
10746 gtk_tree_view_real_expand_collapse_cursor_row (GtkTreeView *tree_view,
10747                                                gboolean     logical,
10748                                                gboolean     expand,
10749                                                gboolean     open_all)
10750 {
10751   GtkTreePath *cursor_path = NULL;
10752   GtkRBTree *tree;
10753   GtkRBNode *node;
10754
10755   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10756     return FALSE;
10757
10758   cursor_path = NULL;
10759   if (tree_view->priv->cursor)
10760     cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
10761
10762   if (cursor_path == NULL)
10763     return FALSE;
10764
10765   if (_gtk_tree_view_find_node (tree_view, cursor_path, &tree, &node))
10766     return FALSE;
10767
10768   /* Don't handle the event if we aren't an expander */
10769   if (!((node->flags & GTK_RBNODE_IS_PARENT) == GTK_RBNODE_IS_PARENT))
10770     return FALSE;
10771
10772   if (!logical
10773       && gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL)
10774     expand = !expand;
10775
10776   if (expand)
10777     gtk_tree_view_real_expand_row (tree_view, cursor_path, tree, node, open_all, TRUE);
10778   else
10779     gtk_tree_view_real_collapse_row (tree_view, cursor_path, tree, node, TRUE);
10780
10781   gtk_tree_path_free (cursor_path);
10782
10783   return TRUE;
10784 }
10785
10786 static gboolean
10787 gtk_tree_view_real_select_cursor_parent (GtkTreeView *tree_view)
10788 {
10789   GtkRBTree *cursor_tree = NULL;
10790   GtkRBNode *cursor_node = NULL;
10791   GtkTreePath *cursor_path = NULL;
10792   GdkModifierType state;
10793
10794   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10795     goto out;
10796
10797   cursor_path = NULL;
10798   if (tree_view->priv->cursor)
10799     cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
10800
10801   if (cursor_path == NULL)
10802     goto out;
10803
10804   _gtk_tree_view_find_node (tree_view, cursor_path,
10805                             &cursor_tree, &cursor_node);
10806   if (cursor_tree == NULL)
10807     {
10808       gtk_tree_path_free (cursor_path);
10809       goto out;
10810     }
10811
10812   if (cursor_tree->parent_node)
10813     {
10814       gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
10815       cursor_node = cursor_tree->parent_node;
10816       cursor_tree = cursor_tree->parent_tree;
10817
10818       gtk_tree_path_up (cursor_path);
10819
10820       if (gtk_get_current_event_state (&state))
10821         {
10822           GdkModifierType modify_mod_mask;
10823
10824           modify_mod_mask =
10825             gtk_widget_get_modifier_mask (GTK_WIDGET (tree_view),
10826                                           GDK_MODIFIER_INTENT_MODIFY_SELECTION);
10827
10828           if ((state & modify_mod_mask) == modify_mod_mask)
10829             tree_view->priv->modify_selection_pressed = TRUE;
10830         }
10831
10832       gtk_tree_view_real_set_cursor (tree_view, cursor_path, TRUE, FALSE);
10833       gtk_tree_view_clamp_node_visible (tree_view, cursor_tree, cursor_node);
10834
10835       gtk_widget_grab_focus (GTK_WIDGET (tree_view));
10836       gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
10837       gtk_tree_path_free (cursor_path);
10838
10839       tree_view->priv->modify_selection_pressed = FALSE;
10840
10841       return TRUE;
10842     }
10843
10844  out:
10845
10846   tree_view->priv->search_entry_avoid_unhandled_binding = TRUE;
10847   return FALSE;
10848 }
10849
10850 static gboolean
10851 gtk_tree_view_search_entry_flush_timeout (GtkTreeView *tree_view)
10852 {
10853   gtk_tree_view_search_dialog_hide (tree_view->priv->search_window, tree_view, NULL);
10854   tree_view->priv->typeselect_flush_timeout = 0;
10855
10856   return FALSE;
10857 }
10858
10859 /* Cut and paste from gtkwindow.c */
10860 static void
10861 send_focus_change (GtkWidget *widget,
10862                    GdkDevice *device,
10863                    gboolean   in)
10864 {
10865   GdkDeviceManager *device_manager;
10866   GList *devices, *d;
10867
10868   device_manager = gdk_display_get_device_manager (gtk_widget_get_display (widget));
10869   devices = gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_MASTER);
10870   devices = g_list_concat (devices, gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_SLAVE));
10871   devices = g_list_concat (devices, gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_FLOATING));
10872
10873   for (d = devices; d; d = d->next)
10874     {
10875       GdkDevice *dev = d->data;
10876       GdkEvent *fevent;
10877       GdkWindow *window;
10878
10879       if (gdk_device_get_source (dev) != GDK_SOURCE_KEYBOARD)
10880         continue;
10881
10882       window = gtk_widget_get_window (widget);
10883
10884       /* Skip non-master keyboards that haven't
10885        * selected for events from this window
10886        */
10887       if (gdk_device_get_device_type (dev) != GDK_DEVICE_TYPE_MASTER &&
10888           !gdk_window_get_device_events (window, dev))
10889         continue;
10890
10891       fevent = gdk_event_new (GDK_FOCUS_CHANGE);
10892
10893       fevent->focus_change.type = GDK_FOCUS_CHANGE;
10894       fevent->focus_change.window = g_object_ref (window);
10895       fevent->focus_change.in = in;
10896       gdk_event_set_device (fevent, device);
10897
10898       gtk_widget_send_focus_change (widget, fevent);
10899
10900       gdk_event_free (fevent);
10901     }
10902
10903   g_list_free (devices);
10904 }
10905
10906 static void
10907 gtk_tree_view_ensure_interactive_directory (GtkTreeView *tree_view)
10908 {
10909   GtkWidget *frame, *vbox, *toplevel;
10910   GdkScreen *screen;
10911
10912   if (tree_view->priv->search_custom_entry_set)
10913     return;
10914
10915   toplevel = gtk_widget_get_toplevel (GTK_WIDGET (tree_view));
10916   screen = gtk_widget_get_screen (GTK_WIDGET (tree_view));
10917
10918    if (tree_view->priv->search_window != NULL)
10919      {
10920        if (gtk_window_has_group (GTK_WINDOW (toplevel)))
10921          gtk_window_group_add_window (gtk_window_get_group (GTK_WINDOW (toplevel)),
10922                                       GTK_WINDOW (tree_view->priv->search_window));
10923        else if (gtk_window_has_group (GTK_WINDOW (tree_view->priv->search_window)))
10924          gtk_window_group_remove_window (gtk_window_get_group (GTK_WINDOW (tree_view->priv->search_window)),
10925                                          GTK_WINDOW (tree_view->priv->search_window));
10926
10927        gtk_window_set_screen (GTK_WINDOW (tree_view->priv->search_window), screen);
10928
10929        return;
10930      }
10931
10932   tree_view->priv->search_window = gtk_window_new (GTK_WINDOW_POPUP);
10933   gtk_window_set_screen (GTK_WINDOW (tree_view->priv->search_window), screen);
10934
10935   if (gtk_window_has_group (GTK_WINDOW (toplevel)))
10936     gtk_window_group_add_window (gtk_window_get_group (GTK_WINDOW (toplevel)),
10937                                  GTK_WINDOW (tree_view->priv->search_window));
10938
10939   gtk_window_set_type_hint (GTK_WINDOW (tree_view->priv->search_window),
10940                             GDK_WINDOW_TYPE_HINT_UTILITY);
10941   gtk_window_set_modal (GTK_WINDOW (tree_view->priv->search_window), TRUE);
10942   g_signal_connect (tree_view->priv->search_window, "delete-event",
10943                     G_CALLBACK (gtk_tree_view_search_delete_event),
10944                     tree_view);
10945   g_signal_connect (tree_view->priv->search_window, "key-press-event",
10946                     G_CALLBACK (gtk_tree_view_search_key_press_event),
10947                     tree_view);
10948   g_signal_connect (tree_view->priv->search_window, "button-press-event",
10949                     G_CALLBACK (gtk_tree_view_search_button_press_event),
10950                     tree_view);
10951   g_signal_connect (tree_view->priv->search_window, "scroll-event",
10952                     G_CALLBACK (gtk_tree_view_search_scroll_event),
10953                     tree_view);
10954
10955   frame = gtk_frame_new (NULL);
10956   gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
10957   gtk_widget_show (frame);
10958   gtk_container_add (GTK_CONTAINER (tree_view->priv->search_window), frame);
10959
10960   vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
10961   gtk_widget_show (vbox);
10962   gtk_container_add (GTK_CONTAINER (frame), vbox);
10963   gtk_container_set_border_width (GTK_CONTAINER (vbox), 3);
10964
10965   /* add entry */
10966   tree_view->priv->search_entry = gtk_entry_new ();
10967   gtk_widget_show (tree_view->priv->search_entry);
10968   g_signal_connect (tree_view->priv->search_entry, "populate-popup",
10969                     G_CALLBACK (gtk_tree_view_search_disable_popdown),
10970                     tree_view);
10971   g_signal_connect (tree_view->priv->search_entry,
10972                     "activate", G_CALLBACK (gtk_tree_view_search_activate),
10973                     tree_view);
10974
10975   g_signal_connect (_gtk_entry_get_im_context (GTK_ENTRY (tree_view->priv->search_entry)),
10976                     "preedit-changed",
10977                     G_CALLBACK (gtk_tree_view_search_preedit_changed),
10978                     tree_view);
10979
10980   gtk_container_add (GTK_CONTAINER (vbox),
10981                      tree_view->priv->search_entry);
10982
10983   gtk_widget_realize (tree_view->priv->search_entry);
10984 }
10985
10986 /* Pops up the interactive search entry.  If keybinding is TRUE then the user
10987  * started this by typing the start_interactive_search keybinding.  Otherwise, it came from
10988  */
10989 static gboolean
10990 gtk_tree_view_real_start_interactive_search (GtkTreeView *tree_view,
10991                                              GdkDevice   *device,
10992                                              gboolean     keybinding)
10993 {
10994   /* We only start interactive search if we have focus or the columns
10995    * have focus.  If one of our children have focus, we don't want to
10996    * start the search.
10997    */
10998   GList *list;
10999   gboolean found_focus = FALSE;
11000   GtkWidgetClass *entry_parent_class;
11001
11002   if (!tree_view->priv->enable_search && !keybinding)
11003     return FALSE;
11004
11005   if (tree_view->priv->search_custom_entry_set)
11006     return FALSE;
11007
11008   if (tree_view->priv->search_window != NULL &&
11009       gtk_widget_get_visible (tree_view->priv->search_window))
11010     return TRUE;
11011
11012   for (list = tree_view->priv->columns; list; list = list->next)
11013     {
11014       GtkTreeViewColumn *column;
11015       GtkWidget         *button;
11016
11017       column = list->data;
11018       if (!gtk_tree_view_column_get_visible (column))
11019         continue;
11020
11021       button = gtk_tree_view_column_get_button (column);
11022       if (gtk_widget_has_focus (button))
11023         {
11024           found_focus = TRUE;
11025           break;
11026         }
11027     }
11028
11029   if (gtk_widget_has_focus (GTK_WIDGET (tree_view)))
11030     found_focus = TRUE;
11031
11032   if (!found_focus)
11033     return FALSE;
11034
11035   if (tree_view->priv->search_column < 0)
11036     return FALSE;
11037
11038   gtk_tree_view_ensure_interactive_directory (tree_view);
11039
11040   if (keybinding)
11041     gtk_entry_set_text (GTK_ENTRY (tree_view->priv->search_entry), "");
11042
11043   /* done, show it */
11044   tree_view->priv->search_position_func (tree_view, tree_view->priv->search_window, tree_view->priv->search_position_user_data);
11045   gtk_widget_show (tree_view->priv->search_window);
11046   if (tree_view->priv->search_entry_changed_id == 0)
11047     {
11048       tree_view->priv->search_entry_changed_id =
11049         g_signal_connect (tree_view->priv->search_entry, "changed",
11050                           G_CALLBACK (gtk_tree_view_search_init),
11051                           tree_view);
11052     }
11053
11054   tree_view->priv->typeselect_flush_timeout =
11055     gdk_threads_add_timeout (GTK_TREE_VIEW_SEARCH_DIALOG_TIMEOUT,
11056                    (GSourceFunc) gtk_tree_view_search_entry_flush_timeout,
11057                    tree_view);
11058
11059   /* Grab focus will select all the text.  We don't want that to happen, so we
11060    * call the parent instance and bypass the selection change.  This is probably
11061    * really non-kosher. */
11062   entry_parent_class = g_type_class_peek_parent (GTK_ENTRY_GET_CLASS (tree_view->priv->search_entry));
11063   (entry_parent_class->grab_focus) (tree_view->priv->search_entry);
11064
11065   /* send focus-in event */
11066   send_focus_change (tree_view->priv->search_entry, device, TRUE);
11067
11068   /* search first matching iter */
11069   gtk_tree_view_search_init (tree_view->priv->search_entry, tree_view);
11070
11071   return TRUE;
11072 }
11073
11074 static gboolean
11075 gtk_tree_view_start_interactive_search (GtkTreeView *tree_view)
11076 {
11077   return gtk_tree_view_real_start_interactive_search (tree_view,
11078                                                       gtk_get_current_event_device (),
11079                                                       TRUE);
11080 }
11081
11082 /* this function returns the new width of the column being resized given
11083  * the column and x position of the cursor; the x cursor position is passed
11084  * in as a pointer and automagicly corrected if it's beyond min/max limits
11085  */
11086 static gint
11087 gtk_tree_view_new_column_width (GtkTreeView *tree_view,
11088                                 gint       i,
11089                                 gint      *x)
11090 {
11091   GtkAllocation allocation;
11092   GtkTreeViewColumn *column;
11093   GtkRequisition button_req;
11094   gint max_width, min_width;
11095   gint width;
11096   gboolean rtl;
11097
11098   /* first translate the x position from widget->window
11099    * to clist->clist_window
11100    */
11101   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
11102   column = g_list_nth (tree_view->priv->columns, i)->data;
11103   gtk_widget_get_allocation (gtk_tree_view_column_get_button (column), &allocation);
11104   width = rtl ? (allocation.x + allocation.width - *x) : (*x - allocation.x);
11105
11106   /* Clamp down the value */
11107   min_width = gtk_tree_view_column_get_min_width (column);
11108   if (min_width == -1)
11109     {
11110       gtk_widget_get_preferred_size (gtk_tree_view_column_get_button (column), &button_req, NULL);
11111       width = MAX (button_req.width, width);
11112     }
11113   else
11114     width = MAX (min_width, width);
11115
11116   max_width = gtk_tree_view_column_get_max_width (column);
11117   if (max_width != -1)
11118     width = MIN (width, max_width);
11119
11120   *x = rtl ? (allocation.x + allocation.width - width) : (allocation.x + width);
11121
11122   return width;
11123 }
11124
11125
11126 /* FIXME this adjust_allocation is a big cut-and-paste from
11127  * GtkCList, needs to be some "official" way to do this
11128  * factored out.
11129  */
11130 typedef struct
11131 {
11132   GdkWindow *window;
11133   int dx;
11134   int dy;
11135 } ScrollData;
11136
11137 /* The window to which widget->window is relative */
11138 #define ALLOCATION_WINDOW(widget)               \
11139    (!gtk_widget_get_has_window (widget) ?                   \
11140     gtk_widget_get_window (widget) :                        \
11141     gdk_window_get_parent (gtk_widget_get_window (widget)))
11142
11143 static void
11144 adjust_allocation_recurse (GtkWidget *widget,
11145                            gpointer   data)
11146 {
11147   GtkAllocation allocation;
11148   ScrollData *scroll_data = data;
11149
11150   /* Need to really size allocate instead of just poking
11151    * into widget->allocation if the widget is not realized.
11152    * FIXME someone figure out why this was.
11153    */
11154   gtk_widget_get_allocation (widget, &allocation);
11155   if (!gtk_widget_get_realized (widget))
11156     {
11157       if (gtk_widget_get_visible (widget))
11158         {
11159           GdkRectangle tmp_rectangle = allocation;
11160           tmp_rectangle.x += scroll_data->dx;
11161           tmp_rectangle.y += scroll_data->dy;
11162
11163           gtk_widget_size_allocate (widget, &tmp_rectangle);
11164         }
11165     }
11166   else
11167     {
11168       if (ALLOCATION_WINDOW (widget) == scroll_data->window)
11169         {
11170           allocation.x += scroll_data->dx;
11171           allocation.y += scroll_data->dy;
11172           gtk_widget_set_allocation (widget, &allocation);
11173
11174           if (GTK_IS_CONTAINER (widget))
11175             gtk_container_forall (GTK_CONTAINER (widget),
11176                                   adjust_allocation_recurse,
11177                                   data);
11178         }
11179     }
11180 }
11181
11182 static void
11183 adjust_allocation (GtkWidget *widget,
11184                    int        dx,
11185                    int        dy)
11186 {
11187   ScrollData scroll_data;
11188
11189   if (gtk_widget_get_realized (widget))
11190     scroll_data.window = ALLOCATION_WINDOW (widget);
11191   else
11192     scroll_data.window = NULL;
11193
11194   scroll_data.dx = dx;
11195   scroll_data.dy = dy;
11196
11197   adjust_allocation_recurse (widget, &scroll_data);
11198 }
11199
11200 /* Callbacks */
11201 static void
11202 gtk_tree_view_adjustment_changed (GtkAdjustment *adjustment,
11203                                   GtkTreeView   *tree_view)
11204 {
11205   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
11206     {
11207       GtkStyleContext *context;
11208       gint dy;
11209
11210       gdk_window_move (tree_view->priv->bin_window,
11211                        - gtk_adjustment_get_value (tree_view->priv->hadjustment),
11212                        gtk_tree_view_get_effective_header_height (tree_view));
11213       gdk_window_move (tree_view->priv->header_window,
11214                        - gtk_adjustment_get_value (tree_view->priv->hadjustment),
11215                        0);
11216       dy = tree_view->priv->dy - (int) gtk_adjustment_get_value (tree_view->priv->vadjustment);
11217       if (dy)
11218         {
11219           update_prelight (tree_view,
11220                            tree_view->priv->event_last_x,
11221                            tree_view->priv->event_last_y - dy);
11222
11223           if (tree_view->priv->edited_column)
11224             {
11225               GList *list;
11226               GtkTreeViewChild *child = NULL;
11227               GtkCellEditable *edit_widget;
11228               GtkCellArea *area;
11229
11230               area        = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (tree_view->priv->edited_column));
11231               edit_widget = gtk_cell_area_get_edit_widget (area);
11232               if (GTK_IS_WIDGET (edit_widget))
11233                 {
11234                   adjust_allocation (GTK_WIDGET (edit_widget), 0, dy);
11235
11236                   for (list = tree_view->priv->children; list; list = list->next)
11237                     {
11238                       child = (GtkTreeViewChild *)list->data;
11239                       if (child->widget == GTK_WIDGET (edit_widget))
11240                         {
11241                           child->y += dy;
11242                           break;
11243                         }
11244                     }
11245                 }
11246             }
11247         }
11248       gdk_window_scroll (tree_view->priv->bin_window, 0, dy);
11249
11250       context = gtk_widget_get_style_context (GTK_WIDGET (tree_view));
11251       gtk_style_context_scroll_animations (context, tree_view->priv->bin_window, 0, dy);
11252
11253       if (tree_view->priv->dy != (int) gtk_adjustment_get_value (tree_view->priv->vadjustment))
11254         {
11255           /* update our dy and top_row */
11256           tree_view->priv->dy = (int) gtk_adjustment_get_value (tree_view->priv->vadjustment);
11257
11258           if (!tree_view->priv->in_top_row_to_dy)
11259             gtk_tree_view_dy_to_top_row (tree_view);
11260         }
11261
11262       gdk_window_process_updates (tree_view->priv->header_window, TRUE);
11263       gtk_tree_view_bin_process_updates (tree_view);
11264     }
11265 }
11266
11267 \f
11268
11269 /* Public methods
11270  */
11271
11272 /**
11273  * gtk_tree_view_new:
11274  *
11275  * Creates a new #GtkTreeView widget.
11276  *
11277  * Return value: A newly created #GtkTreeView widget.
11278  **/
11279 GtkWidget *
11280 gtk_tree_view_new (void)
11281 {
11282   return g_object_new (GTK_TYPE_TREE_VIEW, NULL);
11283 }
11284
11285 /**
11286  * gtk_tree_view_new_with_model:
11287  * @model: the model.
11288  *
11289  * Creates a new #GtkTreeView widget with the model initialized to @model.
11290  *
11291  * Return value: A newly created #GtkTreeView widget.
11292  **/
11293 GtkWidget *
11294 gtk_tree_view_new_with_model (GtkTreeModel *model)
11295 {
11296   return g_object_new (GTK_TYPE_TREE_VIEW, "model", model, NULL);
11297 }
11298
11299 /* Public Accessors
11300  */
11301
11302 /**
11303  * gtk_tree_view_get_model:
11304  * @tree_view: a #GtkTreeView
11305  *
11306  * Returns the model the #GtkTreeView is based on.  Returns %NULL if the
11307  * model is unset.
11308  *
11309  * Return value: (transfer none): A #GtkTreeModel, or %NULL if none is currently being used.
11310  **/
11311 GtkTreeModel *
11312 gtk_tree_view_get_model (GtkTreeView *tree_view)
11313 {
11314   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
11315
11316   return tree_view->priv->model;
11317 }
11318
11319 /**
11320  * gtk_tree_view_set_model:
11321  * @tree_view: A #GtkTreeNode.
11322  * @model: (allow-none): The model.
11323  *
11324  * Sets the model for a #GtkTreeView.  If the @tree_view already has a model
11325  * set, it will remove it before setting the new model.  If @model is %NULL,
11326  * then it will unset the old model.
11327  **/
11328 void
11329 gtk_tree_view_set_model (GtkTreeView  *tree_view,
11330                          GtkTreeModel *model)
11331 {
11332   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11333   g_return_if_fail (model == NULL || GTK_IS_TREE_MODEL (model));
11334
11335   if (model == tree_view->priv->model)
11336     return;
11337
11338   if (tree_view->priv->scroll_to_path)
11339     {
11340       gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
11341       tree_view->priv->scroll_to_path = NULL;
11342     }
11343
11344   if (tree_view->priv->rubber_band_status)
11345     gtk_tree_view_stop_rubber_band (tree_view);
11346
11347   if (tree_view->priv->model)
11348     {
11349       GList *tmplist = tree_view->priv->columns;
11350       GtkStyleContext *context;
11351
11352       gtk_tree_view_unref_and_check_selection_tree (tree_view, tree_view->priv->tree);
11353       gtk_tree_view_stop_editing (tree_view, TRUE);
11354
11355       context = gtk_widget_get_style_context (GTK_WIDGET (tree_view));
11356       gtk_style_context_cancel_animations (context, NULL);
11357
11358       g_signal_handlers_disconnect_by_func (tree_view->priv->model,
11359                                             gtk_tree_view_row_changed,
11360                                             tree_view);
11361       g_signal_handlers_disconnect_by_func (tree_view->priv->model,
11362                                             gtk_tree_view_row_inserted,
11363                                             tree_view);
11364       g_signal_handlers_disconnect_by_func (tree_view->priv->model,
11365                                             gtk_tree_view_row_has_child_toggled,
11366                                             tree_view);
11367       g_signal_handlers_disconnect_by_func (tree_view->priv->model,
11368                                             gtk_tree_view_row_deleted,
11369                                             tree_view);
11370       g_signal_handlers_disconnect_by_func (tree_view->priv->model,
11371                                             gtk_tree_view_rows_reordered,
11372                                             tree_view);
11373
11374       for (; tmplist; tmplist = tmplist->next)
11375         _gtk_tree_view_column_unset_model (tmplist->data,
11376                                            tree_view->priv->model);
11377
11378       if (tree_view->priv->tree)
11379         gtk_tree_view_free_rbtree (tree_view);
11380
11381       gtk_tree_row_reference_free (tree_view->priv->drag_dest_row);
11382       tree_view->priv->drag_dest_row = NULL;
11383       gtk_tree_row_reference_free (tree_view->priv->cursor);
11384       tree_view->priv->cursor = NULL;
11385       gtk_tree_row_reference_free (tree_view->priv->anchor);
11386       tree_view->priv->anchor = NULL;
11387       gtk_tree_row_reference_free (tree_view->priv->top_row);
11388       tree_view->priv->top_row = NULL;
11389       gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
11390       tree_view->priv->scroll_to_path = NULL;
11391
11392       tree_view->priv->scroll_to_column = NULL;
11393
11394       g_object_unref (tree_view->priv->model);
11395
11396       tree_view->priv->search_column = -1;
11397       tree_view->priv->fixed_height_check = 0;
11398       tree_view->priv->fixed_height = -1;
11399       tree_view->priv->dy = tree_view->priv->top_row_dy = 0;
11400       tree_view->priv->last_button_x = -1;
11401       tree_view->priv->last_button_y = -1;
11402     }
11403
11404   tree_view->priv->model = model;
11405
11406   if (tree_view->priv->model)
11407     {
11408       gint i;
11409       GtkTreePath *path;
11410       GtkTreeIter iter;
11411       GtkTreeModelFlags flags;
11412
11413       if (tree_view->priv->search_column == -1)
11414         {
11415           for (i = 0; i < gtk_tree_model_get_n_columns (model); i++)
11416             {
11417               GType type = gtk_tree_model_get_column_type (model, i);
11418
11419               if (g_value_type_transformable (type, G_TYPE_STRING))
11420                 {
11421                   tree_view->priv->search_column = i;
11422                   break;
11423                 }
11424             }
11425         }
11426
11427       g_object_ref (tree_view->priv->model);
11428       g_signal_connect (tree_view->priv->model,
11429                         "row-changed",
11430                         G_CALLBACK (gtk_tree_view_row_changed),
11431                         tree_view);
11432       g_signal_connect (tree_view->priv->model,
11433                         "row-inserted",
11434                         G_CALLBACK (gtk_tree_view_row_inserted),
11435                         tree_view);
11436       g_signal_connect (tree_view->priv->model,
11437                         "row-has-child-toggled",
11438                         G_CALLBACK (gtk_tree_view_row_has_child_toggled),
11439                         tree_view);
11440       g_signal_connect (tree_view->priv->model,
11441                         "row-deleted",
11442                         G_CALLBACK (gtk_tree_view_row_deleted),
11443                         tree_view);
11444       g_signal_connect (tree_view->priv->model,
11445                         "rows-reordered",
11446                         G_CALLBACK (gtk_tree_view_rows_reordered),
11447                         tree_view);
11448
11449       flags = gtk_tree_model_get_flags (tree_view->priv->model);
11450       if ((flags & GTK_TREE_MODEL_LIST_ONLY) == GTK_TREE_MODEL_LIST_ONLY)
11451         tree_view->priv->is_list = TRUE;
11452       else
11453         tree_view->priv->is_list = FALSE;
11454
11455       path = gtk_tree_path_new_first ();
11456       if (gtk_tree_model_get_iter (tree_view->priv->model, &iter, path))
11457         {
11458           tree_view->priv->tree = _gtk_rbtree_new ();
11459           gtk_tree_view_build_tree (tree_view, tree_view->priv->tree, &iter, 1, FALSE);
11460         }
11461       gtk_tree_path_free (path);
11462
11463       /*  FIXME: do I need to do this? gtk_tree_view_create_buttons (tree_view); */
11464       install_presize_handler (tree_view);
11465     }
11466
11467   g_object_notify (G_OBJECT (tree_view), "model");
11468
11469   if (tree_view->priv->selection)
11470   _gtk_tree_selection_emit_changed (tree_view->priv->selection);
11471
11472   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
11473     gtk_widget_queue_resize (GTK_WIDGET (tree_view));
11474 }
11475
11476 /**
11477  * gtk_tree_view_get_selection:
11478  * @tree_view: A #GtkTreeView.
11479  *
11480  * Gets the #GtkTreeSelection associated with @tree_view.
11481  *
11482  * Return value: (transfer none): A #GtkTreeSelection object.
11483  **/
11484 GtkTreeSelection *
11485 gtk_tree_view_get_selection (GtkTreeView *tree_view)
11486 {
11487   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
11488
11489   return tree_view->priv->selection;
11490 }
11491
11492 /**
11493  * gtk_tree_view_get_hadjustment:
11494  * @tree_view: A #GtkTreeView
11495  *
11496  * Gets the #GtkAdjustment currently being used for the horizontal aspect.
11497  *
11498  * Return value: (transfer none): A #GtkAdjustment object, or %NULL
11499  *     if none is currently being used.
11500  *
11501  * Deprecated: 3.0: Use gtk_scrollable_get_hadjustment()
11502  **/
11503 GtkAdjustment *
11504 gtk_tree_view_get_hadjustment (GtkTreeView *tree_view)
11505 {
11506   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
11507
11508   return gtk_tree_view_do_get_hadjustment (tree_view);
11509 }
11510
11511 static GtkAdjustment *
11512 gtk_tree_view_do_get_hadjustment (GtkTreeView *tree_view)
11513 {
11514   return tree_view->priv->hadjustment;
11515 }
11516
11517 /**
11518  * gtk_tree_view_set_hadjustment:
11519  * @tree_view: A #GtkTreeView
11520  * @adjustment: (allow-none): The #GtkAdjustment to set, or %NULL
11521  *
11522  * Sets the #GtkAdjustment for the current horizontal aspect.
11523  *
11524  * Deprecated: 3.0: Use gtk_scrollable_set_hadjustment()
11525  **/
11526 void
11527 gtk_tree_view_set_hadjustment (GtkTreeView   *tree_view,
11528                                GtkAdjustment *adjustment)
11529 {
11530   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11531   g_return_if_fail (adjustment == NULL || GTK_IS_ADJUSTMENT (adjustment));
11532
11533   gtk_tree_view_do_set_hadjustment (tree_view, adjustment);
11534 }
11535
11536 static void
11537 gtk_tree_view_do_set_hadjustment (GtkTreeView   *tree_view,
11538                                   GtkAdjustment *adjustment)
11539 {
11540   GtkTreeViewPrivate *priv = tree_view->priv;
11541
11542   if (adjustment && priv->hadjustment == adjustment)
11543     return;
11544
11545   if (priv->hadjustment != NULL)
11546     {
11547       g_signal_handlers_disconnect_by_func (priv->hadjustment,
11548                                             gtk_tree_view_adjustment_changed,
11549                                             tree_view);
11550       g_object_unref (priv->hadjustment);
11551     }
11552
11553   if (adjustment == NULL)
11554     adjustment = gtk_adjustment_new (0.0, 0.0, 0.0,
11555                                      0.0, 0.0, 0.0);
11556
11557   g_signal_connect (adjustment, "value-changed",
11558                     G_CALLBACK (gtk_tree_view_adjustment_changed), tree_view);
11559   priv->hadjustment = g_object_ref_sink (adjustment);
11560   /* FIXME: Adjustment should probably be populated here with fresh values, but
11561    * internal details are too complicated for me to decipher right now.
11562    */
11563   gtk_tree_view_adjustment_changed (NULL, tree_view);
11564
11565   g_object_notify (G_OBJECT (tree_view), "hadjustment");
11566 }
11567
11568 /**
11569  * gtk_tree_view_get_vadjustment:
11570  * @tree_view: A #GtkTreeView
11571  *
11572  * Gets the #GtkAdjustment currently being used for the vertical aspect.
11573  *
11574  * Return value: (transfer none): A #GtkAdjustment object, or %NULL
11575  *     if none is currently being used.
11576  *
11577  * Deprecated: 3.0: Use gtk_scrollable_get_vadjustment()
11578  **/
11579 GtkAdjustment *
11580 gtk_tree_view_get_vadjustment (GtkTreeView *tree_view)
11581 {
11582   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
11583
11584   return gtk_tree_view_do_get_vadjustment (tree_view);
11585 }
11586
11587 static GtkAdjustment *
11588 gtk_tree_view_do_get_vadjustment (GtkTreeView *tree_view)
11589 {
11590   return tree_view->priv->vadjustment;
11591 }
11592
11593 /**
11594  * gtk_tree_view_set_vadjustment:
11595  * @tree_view: A #GtkTreeView
11596  * @adjustment: (allow-none): The #GtkAdjustment to set, or %NULL
11597  *
11598  * Sets the #GtkAdjustment for the current vertical aspect.
11599  *
11600  * Deprecated: 3.0: Use gtk_scrollable_set_vadjustment()
11601  **/
11602 void
11603 gtk_tree_view_set_vadjustment (GtkTreeView   *tree_view,
11604                                GtkAdjustment *adjustment)
11605 {
11606   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11607   g_return_if_fail (adjustment == NULL || GTK_IS_ADJUSTMENT (adjustment));
11608
11609   gtk_tree_view_do_set_vadjustment (tree_view, adjustment);
11610 }
11611
11612 static void
11613 gtk_tree_view_do_set_vadjustment (GtkTreeView   *tree_view,
11614                                   GtkAdjustment *adjustment)
11615 {
11616   GtkTreeViewPrivate *priv = tree_view->priv;
11617
11618   if (adjustment && priv->vadjustment == adjustment)
11619     return;
11620
11621   if (priv->vadjustment != NULL)
11622     {
11623       g_signal_handlers_disconnect_by_func (priv->vadjustment,
11624                                             gtk_tree_view_adjustment_changed,
11625                                             tree_view);
11626       g_object_unref (priv->vadjustment);
11627     }
11628
11629   if (adjustment == NULL)
11630     adjustment = gtk_adjustment_new (0.0, 0.0, 0.0,
11631                                      0.0, 0.0, 0.0);
11632
11633   g_signal_connect (adjustment, "value-changed",
11634                     G_CALLBACK (gtk_tree_view_adjustment_changed), tree_view);
11635   priv->vadjustment = g_object_ref_sink (adjustment);
11636   /* FIXME: Adjustment should probably be populated here with fresh values, but
11637    * internal details are too complicated for me to decipher right now.
11638    */
11639   gtk_tree_view_adjustment_changed (NULL, tree_view);
11640   g_object_notify (G_OBJECT (tree_view), "vadjustment");
11641 }
11642
11643 /* Column and header operations */
11644
11645 /**
11646  * gtk_tree_view_get_headers_visible:
11647  * @tree_view: A #GtkTreeView.
11648  *
11649  * Returns %TRUE if the headers on the @tree_view are visible.
11650  *
11651  * Return value: Whether the headers are visible or not.
11652  **/
11653 gboolean
11654 gtk_tree_view_get_headers_visible (GtkTreeView *tree_view)
11655 {
11656   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
11657
11658   return tree_view->priv->headers_visible;
11659 }
11660
11661 /**
11662  * gtk_tree_view_set_headers_visible:
11663  * @tree_view: A #GtkTreeView.
11664  * @headers_visible: %TRUE if the headers are visible
11665  *
11666  * Sets the visibility state of the headers.
11667  **/
11668 void
11669 gtk_tree_view_set_headers_visible (GtkTreeView *tree_view,
11670                                    gboolean     headers_visible)
11671 {
11672   gint x, y;
11673   GList *list;
11674   GtkTreeViewColumn *column;
11675   GtkAllocation allocation;
11676   GtkWidget *button;
11677
11678   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11679
11680   headers_visible = !! headers_visible;
11681
11682   if (tree_view->priv->headers_visible == headers_visible)
11683     return;
11684
11685   tree_view->priv->headers_visible = headers_visible == TRUE;
11686
11687   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
11688     {
11689       gdk_window_get_position (tree_view->priv->bin_window, &x, &y);
11690       if (headers_visible)
11691         {
11692           gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
11693           gdk_window_move_resize (tree_view->priv->bin_window,
11694                                   x, y  + gtk_tree_view_get_effective_header_height (tree_view),
11695                                   tree_view->priv->width, allocation.height -  + gtk_tree_view_get_effective_header_height (tree_view));
11696
11697           if (gtk_widget_get_mapped (GTK_WIDGET (tree_view)))
11698             gtk_tree_view_map_buttons (tree_view);
11699         }
11700       else
11701         {
11702           gdk_window_move_resize (tree_view->priv->bin_window, x, y, tree_view->priv->width, tree_view->priv->height);
11703
11704           for (list = tree_view->priv->columns; list; list = list->next)
11705             {
11706               column = list->data;
11707               button = gtk_tree_view_column_get_button (column);
11708
11709               gtk_widget_hide (button);
11710               gtk_widget_unmap (button);
11711             }
11712           gdk_window_hide (tree_view->priv->header_window);
11713         }
11714     }
11715
11716   gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
11717   gtk_adjustment_configure (tree_view->priv->vadjustment,
11718                             gtk_adjustment_get_value (tree_view->priv->vadjustment),
11719                             0,
11720                             tree_view->priv->height,
11721                             gtk_adjustment_get_step_increment (tree_view->priv->vadjustment),
11722                             (allocation.height - gtk_tree_view_get_effective_header_height (tree_view)) / 2,
11723                             allocation.height - gtk_tree_view_get_effective_header_height (tree_view));
11724
11725   gtk_widget_queue_resize (GTK_WIDGET (tree_view));
11726
11727   g_object_notify (G_OBJECT (tree_view), "headers-visible");
11728 }
11729
11730 /**
11731  * gtk_tree_view_columns_autosize:
11732  * @tree_view: A #GtkTreeView.
11733  *
11734  * Resizes all columns to their optimal width. Only works after the
11735  * treeview has been realized.
11736  **/
11737 void
11738 gtk_tree_view_columns_autosize (GtkTreeView *tree_view)
11739 {
11740   gboolean dirty = FALSE;
11741   GList *list;
11742   GtkTreeViewColumn *column;
11743
11744   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11745
11746   for (list = tree_view->priv->columns; list; list = list->next)
11747     {
11748       column = list->data;
11749       if (gtk_tree_view_column_get_sizing (column) == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
11750         continue;
11751       _gtk_tree_view_column_cell_set_dirty (column, TRUE);
11752       dirty = TRUE;
11753     }
11754
11755   if (dirty)
11756     gtk_widget_queue_resize (GTK_WIDGET (tree_view));
11757 }
11758
11759 /**
11760  * gtk_tree_view_set_headers_clickable:
11761  * @tree_view: A #GtkTreeView.
11762  * @setting: %TRUE if the columns are clickable.
11763  *
11764  * Allow the column title buttons to be clicked.
11765  **/
11766 void
11767 gtk_tree_view_set_headers_clickable (GtkTreeView *tree_view,
11768                                      gboolean   setting)
11769 {
11770   GList *list;
11771
11772   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11773
11774   for (list = tree_view->priv->columns; list; list = list->next)
11775     gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (list->data), setting);
11776
11777   g_object_notify (G_OBJECT (tree_view), "headers-clickable");
11778 }
11779
11780
11781 /**
11782  * gtk_tree_view_get_headers_clickable:
11783  * @tree_view: A #GtkTreeView.
11784  *
11785  * Returns whether all header columns are clickable.
11786  *
11787  * Return value: %TRUE if all header columns are clickable, otherwise %FALSE
11788  *
11789  * Since: 2.10
11790  **/
11791 gboolean
11792 gtk_tree_view_get_headers_clickable (GtkTreeView *tree_view)
11793 {
11794   GList *list;
11795
11796   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
11797
11798   for (list = tree_view->priv->columns; list; list = list->next)
11799     if (!gtk_tree_view_column_get_clickable (GTK_TREE_VIEW_COLUMN (list->data)))
11800       return FALSE;
11801
11802   return TRUE;
11803 }
11804
11805 /**
11806  * gtk_tree_view_set_rules_hint
11807  * @tree_view: a #GtkTreeView
11808  * @setting: %TRUE if the tree requires reading across rows
11809  *
11810  * This function tells GTK+ that the user interface for your
11811  * application requires users to read across tree rows and associate
11812  * cells with one another. By default, GTK+ will then render the tree
11813  * with alternating row colors. Do <emphasis>not</emphasis> use it
11814  * just because you prefer the appearance of the ruled tree; that's a
11815  * question for the theme. Some themes will draw tree rows in
11816  * alternating colors even when rules are turned off, and users who
11817  * prefer that appearance all the time can choose those themes. You
11818  * should call this function only as a <emphasis>semantic</emphasis>
11819  * hint to the theme engine that your tree makes alternating colors
11820  * useful from a functional standpoint (since it has lots of columns,
11821  * generally).
11822  *
11823  **/
11824 void
11825 gtk_tree_view_set_rules_hint (GtkTreeView  *tree_view,
11826                               gboolean      setting)
11827 {
11828   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11829
11830   setting = setting != FALSE;
11831
11832   if (tree_view->priv->has_rules != setting)
11833     {
11834       tree_view->priv->has_rules = setting;
11835       gtk_widget_queue_draw (GTK_WIDGET (tree_view));
11836     }
11837
11838   g_object_notify (G_OBJECT (tree_view), "rules-hint");
11839 }
11840
11841 /**
11842  * gtk_tree_view_get_rules_hint
11843  * @tree_view: a #GtkTreeView
11844  *
11845  * Gets the setting set by gtk_tree_view_set_rules_hint().
11846  *
11847  * Return value: %TRUE if rules are useful for the user of this tree
11848  **/
11849 gboolean
11850 gtk_tree_view_get_rules_hint (GtkTreeView  *tree_view)
11851 {
11852   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
11853
11854   return tree_view->priv->has_rules;
11855 }
11856
11857 /* Public Column functions
11858  */
11859
11860 /**
11861  * gtk_tree_view_append_column:
11862  * @tree_view: A #GtkTreeView.
11863  * @column: The #GtkTreeViewColumn to add.
11864  *
11865  * Appends @column to the list of columns. If @tree_view has "fixed_height"
11866  * mode enabled, then @column must have its "sizing" property set to be
11867  * GTK_TREE_VIEW_COLUMN_FIXED.
11868  *
11869  * Return value: The number of columns in @tree_view after appending.
11870  **/
11871 gint
11872 gtk_tree_view_append_column (GtkTreeView       *tree_view,
11873                              GtkTreeViewColumn *column)
11874 {
11875   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
11876   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (column), -1);
11877   g_return_val_if_fail (gtk_tree_view_column_get_tree_view (column) == NULL, -1);
11878
11879   return gtk_tree_view_insert_column (tree_view, column, -1);
11880 }
11881
11882 void
11883 _gtk_tree_view_reset_header_styles (GtkTreeView *tree_view)
11884 {
11885   GList *columns;
11886
11887   for (columns = tree_view->priv->columns; columns; columns = columns->next)
11888     {
11889       GtkTreeViewColumn *column = columns->data;
11890       GtkWidget *header_widget;
11891
11892       if (gtk_tree_view_column_get_visible (column))
11893         continue;
11894
11895       header_widget = gtk_tree_view_column_get_widget (column);
11896
11897       if (!header_widget)
11898         header_widget = gtk_tree_view_column_get_button (column);
11899
11900       gtk_widget_reset_style (header_widget);
11901     }
11902 }
11903
11904
11905 /**
11906  * gtk_tree_view_remove_column:
11907  * @tree_view: A #GtkTreeView.
11908  * @column: The #GtkTreeViewColumn to remove.
11909  *
11910  * Removes @column from @tree_view.
11911  *
11912  * Return value: The number of columns in @tree_view after removing.
11913  **/
11914 gint
11915 gtk_tree_view_remove_column (GtkTreeView       *tree_view,
11916                              GtkTreeViewColumn *column)
11917 {
11918   guint position;
11919
11920   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
11921   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (column), -1);
11922   g_return_val_if_fail (gtk_tree_view_column_get_tree_view (column) == GTK_WIDGET (tree_view), -1);
11923
11924   if (tree_view->priv->focus_column == column)
11925     tree_view->priv->focus_column = NULL;
11926
11927   if (tree_view->priv->edited_column == column)
11928     {
11929       gtk_tree_view_stop_editing (tree_view, TRUE);
11930
11931       /* no need to, but just to be sure ... */
11932       tree_view->priv->edited_column = NULL;
11933     }
11934
11935   if (tree_view->priv->expander_column == column)
11936     tree_view->priv->expander_column = NULL;
11937
11938   g_signal_handlers_disconnect_by_func (column,
11939                                         G_CALLBACK (column_sizing_notify),
11940                                         tree_view);
11941
11942   _gtk_tree_view_column_unset_tree_view (column);
11943
11944   position = g_list_index (tree_view->priv->columns, column);
11945
11946   tree_view->priv->columns = g_list_remove (tree_view->priv->columns, column);
11947   tree_view->priv->n_columns--;
11948
11949   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
11950     {
11951       GList *list;
11952
11953       _gtk_tree_view_column_unrealize_button (column);
11954       for (list = tree_view->priv->columns; list; list = list->next)
11955         {
11956           GtkTreeViewColumn *tmp_column;
11957
11958           tmp_column = GTK_TREE_VIEW_COLUMN (list->data);
11959           if (gtk_tree_view_column_get_visible (tmp_column))
11960             _gtk_tree_view_column_cell_set_dirty (tmp_column, TRUE);
11961         }
11962
11963       if (tree_view->priv->n_columns == 0 &&
11964           gtk_tree_view_get_headers_visible (tree_view))
11965         gdk_window_hide (tree_view->priv->header_window);
11966
11967       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
11968     }
11969
11970   _gtk_tree_view_reset_header_styles (tree_view);
11971
11972   _gtk_tree_view_accessible_remove_column (tree_view, column, position);
11973
11974   g_object_unref (column);
11975   g_signal_emit (tree_view, tree_view_signals[COLUMNS_CHANGED], 0);
11976
11977   return tree_view->priv->n_columns;
11978 }
11979
11980 /**
11981  * gtk_tree_view_insert_column:
11982  * @tree_view: A #GtkTreeView.
11983  * @column: The #GtkTreeViewColumn to be inserted.
11984  * @position: The position to insert @column in.
11985  *
11986  * This inserts the @column into the @tree_view at @position.  If @position is
11987  * -1, then the column is inserted at the end. If @tree_view has
11988  * "fixed_height" mode enabled, then @column must have its "sizing" property
11989  * set to be GTK_TREE_VIEW_COLUMN_FIXED.
11990  *
11991  * Return value: The number of columns in @tree_view after insertion.
11992  **/
11993 gint
11994 gtk_tree_view_insert_column (GtkTreeView       *tree_view,
11995                              GtkTreeViewColumn *column,
11996                              gint               position)
11997 {
11998   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
11999   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (column), -1);
12000   g_return_val_if_fail (gtk_tree_view_column_get_tree_view (column) == NULL, -1);
12001
12002   if (tree_view->priv->fixed_height_mode)
12003     g_return_val_if_fail (gtk_tree_view_column_get_sizing (column)
12004                           == GTK_TREE_VIEW_COLUMN_FIXED, -1);
12005
12006   if (position < 0 || position > tree_view->priv->n_columns)
12007     position = tree_view->priv->n_columns;
12008
12009   g_object_ref_sink (column);
12010
12011   if (tree_view->priv->n_columns == 0 &&
12012       gtk_widget_get_realized (GTK_WIDGET (tree_view)) &&
12013       gtk_tree_view_get_headers_visible (tree_view))
12014     {
12015       gdk_window_show (tree_view->priv->header_window);
12016     }
12017
12018   g_signal_connect (column, "notify::sizing",
12019                     G_CALLBACK (column_sizing_notify), tree_view);
12020
12021   tree_view->priv->columns = g_list_insert (tree_view->priv->columns,
12022                                             column, position);
12023   tree_view->priv->n_columns++;
12024
12025   _gtk_tree_view_column_set_tree_view (column, tree_view);
12026
12027   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
12028     {
12029       GList *list;
12030
12031       _gtk_tree_view_column_realize_button (column);
12032
12033       for (list = tree_view->priv->columns; list; list = list->next)
12034         {
12035           column = GTK_TREE_VIEW_COLUMN (list->data);
12036           if (gtk_tree_view_column_get_visible (column))
12037             _gtk_tree_view_column_cell_set_dirty (column, TRUE);
12038         }
12039       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
12040     }
12041
12042   _gtk_tree_view_reset_header_styles (tree_view);
12043
12044   _gtk_tree_view_accessible_add_column (tree_view, column, position);
12045
12046   g_signal_emit (tree_view, tree_view_signals[COLUMNS_CHANGED], 0);
12047
12048   return tree_view->priv->n_columns;
12049 }
12050
12051 /**
12052  * gtk_tree_view_insert_column_with_attributes:
12053  * @tree_view: A #GtkTreeView
12054  * @position: The position to insert the new column in
12055  * @title: The title to set the header to
12056  * @cell: The #GtkCellRenderer
12057  * @...: A %NULL-terminated list of attributes
12058  *
12059  * Creates a new #GtkTreeViewColumn and inserts it into the @tree_view at
12060  * @position.  If @position is -1, then the newly created column is inserted at
12061  * the end.  The column is initialized with the attributes given. If @tree_view
12062  * has "fixed_height" mode enabled, then the new column will have its sizing
12063  * property set to be GTK_TREE_VIEW_COLUMN_FIXED.
12064  *
12065  * Return value: The number of columns in @tree_view after insertion.
12066  **/
12067 gint
12068 gtk_tree_view_insert_column_with_attributes (GtkTreeView     *tree_view,
12069                                              gint             position,
12070                                              const gchar     *title,
12071                                              GtkCellRenderer *cell,
12072                                              ...)
12073 {
12074   GtkTreeViewColumn *column;
12075   gchar *attribute;
12076   va_list args;
12077   gint column_id;
12078
12079   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
12080
12081   column = gtk_tree_view_column_new ();
12082   if (tree_view->priv->fixed_height_mode)
12083     gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED);
12084
12085   gtk_tree_view_column_set_title (column, title);
12086   gtk_tree_view_column_pack_start (column, cell, TRUE);
12087
12088   va_start (args, cell);
12089
12090   attribute = va_arg (args, gchar *);
12091
12092   while (attribute != NULL)
12093     {
12094       column_id = va_arg (args, gint);
12095       gtk_tree_view_column_add_attribute (column, cell, attribute, column_id);
12096       attribute = va_arg (args, gchar *);
12097     }
12098
12099   va_end (args);
12100
12101   return gtk_tree_view_insert_column (tree_view, column, position);
12102 }
12103
12104 /**
12105  * gtk_tree_view_insert_column_with_data_func:
12106  * @tree_view: a #GtkTreeView
12107  * @position: Position to insert, -1 for append
12108  * @title: column title
12109  * @cell: cell renderer for column
12110  * @func: function to set attributes of cell renderer
12111  * @data: data for @func
12112  * @dnotify: destroy notifier for @data
12113  *
12114  * Convenience function that inserts a new column into the #GtkTreeView
12115  * with the given cell renderer and a #GtkCellDataFunc to set cell renderer
12116  * attributes (normally using data from the model). See also
12117  * gtk_tree_view_column_set_cell_data_func(), gtk_tree_view_column_pack_start().
12118  * If @tree_view has "fixed_height" mode enabled, then the new column will have its
12119  * "sizing" property set to be GTK_TREE_VIEW_COLUMN_FIXED.
12120  *
12121  * Return value: number of columns in the tree view post-insert
12122  **/
12123 gint
12124 gtk_tree_view_insert_column_with_data_func  (GtkTreeView               *tree_view,
12125                                              gint                       position,
12126                                              const gchar               *title,
12127                                              GtkCellRenderer           *cell,
12128                                              GtkTreeCellDataFunc        func,
12129                                              gpointer                   data,
12130                                              GDestroyNotify             dnotify)
12131 {
12132   GtkTreeViewColumn *column;
12133
12134   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
12135
12136   column = gtk_tree_view_column_new ();
12137   if (tree_view->priv->fixed_height_mode)
12138     gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED);
12139
12140   gtk_tree_view_column_set_title (column, title);
12141   gtk_tree_view_column_pack_start (column, cell, TRUE);
12142   gtk_tree_view_column_set_cell_data_func (column, cell, func, data, dnotify);
12143
12144   return gtk_tree_view_insert_column (tree_view, column, position);
12145 }
12146
12147 /**
12148  * gtk_tree_view_get_n_columns:
12149  * @tree_view: a #GtkTreeView
12150  *
12151  * Queries the number of columns in the given @tree_view.
12152  *
12153  * Returns: The number of columns in the @tree_view
12154  *
12155  * Since: 3.4
12156  **/
12157 guint
12158 gtk_tree_view_get_n_columns (GtkTreeView *tree_view)
12159 {
12160   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), 0);
12161
12162   return tree_view->priv->n_columns;
12163 }
12164
12165 /**
12166  * gtk_tree_view_get_column:
12167  * @tree_view: A #GtkTreeView.
12168  * @n: The position of the column, counting from 0.
12169  *
12170  * Gets the #GtkTreeViewColumn at the given position in the #tree_view.
12171  *
12172  * Return value: (transfer none): The #GtkTreeViewColumn, or %NULL if the
12173  *     position is outside the range of columns.
12174  **/
12175 GtkTreeViewColumn *
12176 gtk_tree_view_get_column (GtkTreeView *tree_view,
12177                           gint         n)
12178 {
12179   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
12180
12181   if (n < 0 || n >= tree_view->priv->n_columns)
12182     return NULL;
12183
12184   if (tree_view->priv->columns == NULL)
12185     return NULL;
12186
12187   return GTK_TREE_VIEW_COLUMN (g_list_nth (tree_view->priv->columns, n)->data);
12188 }
12189
12190 /**
12191  * gtk_tree_view_get_columns:
12192  * @tree_view: A #GtkTreeView
12193  *
12194  * Returns a #GList of all the #GtkTreeViewColumn s currently in @tree_view.
12195  * The returned list must be freed with g_list_free ().
12196  *
12197  * Return value: (element-type GtkTreeViewColumn) (transfer container): A list of #GtkTreeViewColumn s
12198  **/
12199 GList *
12200 gtk_tree_view_get_columns (GtkTreeView *tree_view)
12201 {
12202   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
12203
12204   return g_list_copy (tree_view->priv->columns);
12205 }
12206
12207 /**
12208  * gtk_tree_view_move_column_after:
12209  * @tree_view: A #GtkTreeView
12210  * @column: The #GtkTreeViewColumn to be moved.
12211  * @base_column: (allow-none): The #GtkTreeViewColumn to be moved relative to, or %NULL.
12212  *
12213  * Moves @column to be after to @base_column.  If @base_column is %NULL, then
12214  * @column is placed in the first position.
12215  **/
12216 void
12217 gtk_tree_view_move_column_after (GtkTreeView       *tree_view,
12218                                  GtkTreeViewColumn *column,
12219                                  GtkTreeViewColumn *base_column)
12220 {
12221   GList *column_list_el, *base_el = NULL;
12222
12223   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12224
12225   column_list_el = g_list_find (tree_view->priv->columns, column);
12226   g_return_if_fail (column_list_el != NULL);
12227
12228   if (base_column)
12229     {
12230       base_el = g_list_find (tree_view->priv->columns, base_column);
12231       g_return_if_fail (base_el != NULL);
12232     }
12233
12234   if (column_list_el->prev == base_el)
12235     return;
12236
12237   tree_view->priv->columns = g_list_remove_link (tree_view->priv->columns, column_list_el);
12238   if (base_el == NULL)
12239     {
12240       column_list_el->prev = NULL;
12241       column_list_el->next = tree_view->priv->columns;
12242       if (column_list_el->next)
12243         column_list_el->next->prev = column_list_el;
12244       tree_view->priv->columns = column_list_el;
12245     }
12246   else
12247     {
12248       column_list_el->prev = base_el;
12249       column_list_el->next = base_el->next;
12250       if (column_list_el->next)
12251         column_list_el->next->prev = column_list_el;
12252       base_el->next = column_list_el;
12253     }
12254
12255   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
12256     {
12257       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
12258       gtk_tree_view_size_allocate_columns (GTK_WIDGET (tree_view), NULL);
12259     }
12260
12261   _gtk_tree_view_reset_header_styles (tree_view);
12262
12263   _gtk_tree_view_accessible_reorder_column (tree_view, column);
12264
12265   g_signal_emit (tree_view, tree_view_signals[COLUMNS_CHANGED], 0);
12266 }
12267
12268 /**
12269  * gtk_tree_view_set_expander_column:
12270  * @tree_view: A #GtkTreeView
12271  * @column: %NULL, or the column to draw the expander arrow at.
12272  *
12273  * Sets the column to draw the expander arrow at. It must be in @tree_view.
12274  * If @column is %NULL, then the expander arrow is always at the first
12275  * visible column.
12276  *
12277  * If you do not want expander arrow to appear in your tree, set the
12278  * expander column to a hidden column.
12279  **/
12280 void
12281 gtk_tree_view_set_expander_column (GtkTreeView       *tree_view,
12282                                    GtkTreeViewColumn *column)
12283 {
12284   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12285   g_return_if_fail (column == NULL || GTK_IS_TREE_VIEW_COLUMN (column));
12286   g_return_if_fail (column == NULL || gtk_tree_view_column_get_tree_view (column) == GTK_WIDGET (tree_view));
12287
12288   if (tree_view->priv->expander_column != column)
12289     {
12290       tree_view->priv->expander_column = column;
12291       g_object_notify (G_OBJECT (tree_view), "expander-column");
12292     }
12293 }
12294
12295 /**
12296  * gtk_tree_view_get_expander_column:
12297  * @tree_view: A #GtkTreeView
12298  *
12299  * Returns the column that is the current expander column.
12300  * This column has the expander arrow drawn next to it.
12301  *
12302  * Return value: (transfer none): The expander column.
12303  **/
12304 GtkTreeViewColumn *
12305 gtk_tree_view_get_expander_column (GtkTreeView *tree_view)
12306 {
12307   GList *list;
12308
12309   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
12310
12311   for (list = tree_view->priv->columns; list; list = list->next)
12312     if (gtk_tree_view_is_expander_column (tree_view, GTK_TREE_VIEW_COLUMN (list->data)))
12313       return (GtkTreeViewColumn *) list->data;
12314   return NULL;
12315 }
12316
12317
12318 /**
12319  * gtk_tree_view_set_column_drag_function:
12320  * @tree_view: A #GtkTreeView.
12321  * @func: (allow-none): A function to determine which columns are reorderable, or %NULL.
12322  * @user_data: (allow-none): User data to be passed to @func, or %NULL
12323  * @destroy: (allow-none): Destroy notifier for @user_data, or %NULL
12324  *
12325  * Sets a user function for determining where a column may be dropped when
12326  * dragged.  This function is called on every column pair in turn at the
12327  * beginning of a column drag to determine where a drop can take place.  The
12328  * arguments passed to @func are: the @tree_view, the #GtkTreeViewColumn being
12329  * dragged, the two #GtkTreeViewColumn s determining the drop spot, and
12330  * @user_data.  If either of the #GtkTreeViewColumn arguments for the drop spot
12331  * are %NULL, then they indicate an edge.  If @func is set to be %NULL, then
12332  * @tree_view reverts to the default behavior of allowing all columns to be
12333  * dropped everywhere.
12334  **/
12335 void
12336 gtk_tree_view_set_column_drag_function (GtkTreeView               *tree_view,
12337                                         GtkTreeViewColumnDropFunc  func,
12338                                         gpointer                   user_data,
12339                                         GDestroyNotify             destroy)
12340 {
12341   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12342
12343   if (tree_view->priv->column_drop_func_data_destroy)
12344     tree_view->priv->column_drop_func_data_destroy (tree_view->priv->column_drop_func_data);
12345
12346   tree_view->priv->column_drop_func = func;
12347   tree_view->priv->column_drop_func_data = user_data;
12348   tree_view->priv->column_drop_func_data_destroy = destroy;
12349 }
12350
12351 /**
12352  * gtk_tree_view_scroll_to_point:
12353  * @tree_view: a #GtkTreeView
12354  * @tree_x: X coordinate of new top-left pixel of visible area, or -1
12355  * @tree_y: Y coordinate of new top-left pixel of visible area, or -1
12356  *
12357  * Scrolls the tree view such that the top-left corner of the visible
12358  * area is @tree_x, @tree_y, where @tree_x and @tree_y are specified
12359  * in tree coordinates.  The @tree_view must be realized before
12360  * this function is called.  If it isn't, you probably want to be
12361  * using gtk_tree_view_scroll_to_cell().
12362  *
12363  * If either @tree_x or @tree_y are -1, then that direction isn't scrolled.
12364  **/
12365 void
12366 gtk_tree_view_scroll_to_point (GtkTreeView *tree_view,
12367                                gint         tree_x,
12368                                gint         tree_y)
12369 {
12370   GtkAdjustment *hadj;
12371   GtkAdjustment *vadj;
12372
12373   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12374   g_return_if_fail (gtk_widget_get_realized (GTK_WIDGET (tree_view)));
12375
12376   hadj = tree_view->priv->hadjustment;
12377   vadj = tree_view->priv->vadjustment;
12378
12379   if (tree_x != -1)
12380     gtk_adjustment_set_value (hadj, tree_x);
12381   if (tree_y != -1)
12382     gtk_adjustment_set_value (vadj, tree_y);
12383 }
12384
12385 /**
12386  * gtk_tree_view_scroll_to_cell:
12387  * @tree_view: A #GtkTreeView.
12388  * @path: (allow-none): The path of the row to move to, or %NULL.
12389  * @column: (allow-none): The #GtkTreeViewColumn to move horizontally to, or %NULL.
12390  * @use_align: whether to use alignment arguments, or %FALSE.
12391  * @row_align: The vertical alignment of the row specified by @path.
12392  * @col_align: The horizontal alignment of the column specified by @column.
12393  *
12394  * Moves the alignments of @tree_view to the position specified by @column and
12395  * @path.  If @column is %NULL, then no horizontal scrolling occurs.  Likewise,
12396  * if @path is %NULL no vertical scrolling occurs.  At a minimum, one of @column
12397  * or @path need to be non-%NULL.  @row_align determines where the row is
12398  * placed, and @col_align determines where @column is placed.  Both are expected
12399  * to be between 0.0 and 1.0. 0.0 means left/top alignment, 1.0 means
12400  * right/bottom alignment, 0.5 means center.
12401  *
12402  * If @use_align is %FALSE, then the alignment arguments are ignored, and the
12403  * tree does the minimum amount of work to scroll the cell onto the screen.
12404  * This means that the cell will be scrolled to the edge closest to its current
12405  * position.  If the cell is currently visible on the screen, nothing is done.
12406  *
12407  * This function only works if the model is set, and @path is a valid row on the
12408  * model.  If the model changes before the @tree_view is realized, the centered
12409  * path will be modified to reflect this change.
12410  **/
12411 void
12412 gtk_tree_view_scroll_to_cell (GtkTreeView       *tree_view,
12413                               GtkTreePath       *path,
12414                               GtkTreeViewColumn *column,
12415                               gboolean           use_align,
12416                               gfloat             row_align,
12417                               gfloat             col_align)
12418 {
12419   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12420   g_return_if_fail (tree_view->priv->model != NULL);
12421   g_return_if_fail (tree_view->priv->tree != NULL);
12422   g_return_if_fail (row_align >= 0.0 && row_align <= 1.0);
12423   g_return_if_fail (col_align >= 0.0 && col_align <= 1.0);
12424   g_return_if_fail (path != NULL || column != NULL);
12425
12426 #if 0
12427   g_print ("gtk_tree_view_scroll_to_cell:\npath: %s\ncolumn: %s\nuse_align: %d\nrow_align: %f\ncol_align: %f\n",
12428            gtk_tree_path_to_string (path), column?"non-null":"null", use_align, row_align, col_align);
12429 #endif
12430   row_align = CLAMP (row_align, 0.0, 1.0);
12431   col_align = CLAMP (col_align, 0.0, 1.0);
12432
12433
12434   /* Note: Despite the benefits that come from having one code path for the
12435    * scrolling code, we short-circuit validate_visible_area's immplementation as
12436    * it is much slower than just going to the point.
12437    */
12438   if (!gtk_widget_get_visible (GTK_WIDGET (tree_view)) ||
12439       !gtk_widget_get_realized (GTK_WIDGET (tree_view)) ||
12440       _gtk_widget_get_alloc_needed (GTK_WIDGET (tree_view)) ||
12441       GTK_RBNODE_FLAG_SET (tree_view->priv->tree->root, GTK_RBNODE_DESCENDANTS_INVALID))
12442     {
12443       if (tree_view->priv->scroll_to_path)
12444         gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
12445
12446       tree_view->priv->scroll_to_path = NULL;
12447       tree_view->priv->scroll_to_column = NULL;
12448
12449       if (path)
12450         tree_view->priv->scroll_to_path = gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view), tree_view->priv->model, path);
12451       if (column)
12452         tree_view->priv->scroll_to_column = column;
12453       tree_view->priv->scroll_to_use_align = use_align;
12454       tree_view->priv->scroll_to_row_align = row_align;
12455       tree_view->priv->scroll_to_col_align = col_align;
12456
12457       install_presize_handler (tree_view);
12458     }
12459   else
12460     {
12461       GdkRectangle cell_rect;
12462       GdkRectangle vis_rect;
12463       gint dest_x, dest_y;
12464
12465       gtk_tree_view_get_background_area (tree_view, path, column, &cell_rect);
12466       gtk_tree_view_get_visible_rect (tree_view, &vis_rect);
12467
12468       cell_rect.y = TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, cell_rect.y);
12469
12470       dest_x = vis_rect.x;
12471       dest_y = vis_rect.y;
12472
12473       if (column)
12474         {
12475           if (use_align)
12476             {
12477               dest_x = cell_rect.x - ((vis_rect.width - cell_rect.width) * col_align);
12478             }
12479           else
12480             {
12481               if (cell_rect.x < vis_rect.x)
12482                 dest_x = cell_rect.x;
12483               if (cell_rect.x + cell_rect.width > vis_rect.x + vis_rect.width)
12484                 dest_x = cell_rect.x + cell_rect.width - vis_rect.width;
12485             }
12486         }
12487
12488       if (path)
12489         {
12490           if (use_align)
12491             {
12492               dest_y = cell_rect.y - ((vis_rect.height - cell_rect.height) * row_align);
12493               dest_y = MAX (dest_y, 0);
12494             }
12495           else
12496             {
12497               if (cell_rect.y < vis_rect.y)
12498                 dest_y = cell_rect.y;
12499               if (cell_rect.y + cell_rect.height > vis_rect.y + vis_rect.height)
12500                 dest_y = cell_rect.y + cell_rect.height - vis_rect.height;
12501             }
12502         }
12503
12504       gtk_tree_view_scroll_to_point (tree_view, dest_x, dest_y);
12505     }
12506 }
12507
12508 /**
12509  * gtk_tree_view_row_activated:
12510  * @tree_view: A #GtkTreeView
12511  * @path: The #GtkTreePath to be activated.
12512  * @column: The #GtkTreeViewColumn to be activated.
12513  *
12514  * Activates the cell determined by @path and @column.
12515  **/
12516 void
12517 gtk_tree_view_row_activated (GtkTreeView       *tree_view,
12518                              GtkTreePath       *path,
12519                              GtkTreeViewColumn *column)
12520 {
12521   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12522
12523   g_signal_emit (tree_view, tree_view_signals[ROW_ACTIVATED], 0, path, column);
12524 }
12525
12526
12527 static void
12528 gtk_tree_view_expand_all_emission_helper (GtkRBTree *tree,
12529                                           GtkRBNode *node,
12530                                           gpointer   data)
12531 {
12532   GtkTreeView *tree_view = data;
12533
12534   if ((node->flags & GTK_RBNODE_IS_PARENT) == GTK_RBNODE_IS_PARENT &&
12535       node->children)
12536     {
12537       GtkTreePath *path;
12538       GtkTreeIter iter;
12539
12540       path = _gtk_tree_view_find_path (tree_view, tree, node);
12541       gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
12542
12543       g_signal_emit (tree_view, tree_view_signals[ROW_EXPANDED], 0, &iter, path);
12544
12545       gtk_tree_path_free (path);
12546     }
12547
12548   if (node->children)
12549     _gtk_rbtree_traverse (node->children,
12550                           node->children->root,
12551                           G_PRE_ORDER,
12552                           gtk_tree_view_expand_all_emission_helper,
12553                           tree_view);
12554 }
12555
12556 /**
12557  * gtk_tree_view_expand_all:
12558  * @tree_view: A #GtkTreeView.
12559  *
12560  * Recursively expands all nodes in the @tree_view.
12561  **/
12562 void
12563 gtk_tree_view_expand_all (GtkTreeView *tree_view)
12564 {
12565   GtkTreePath *path;
12566   GtkRBTree *tree;
12567   GtkRBNode *node;
12568
12569   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12570
12571   if (tree_view->priv->tree == NULL)
12572     return;
12573
12574   path = gtk_tree_path_new_first ();
12575   _gtk_tree_view_find_node (tree_view, path, &tree, &node);
12576
12577   while (node)
12578     {
12579       gtk_tree_view_real_expand_row (tree_view, path, tree, node, TRUE, FALSE);
12580       node = _gtk_rbtree_next (tree, node);
12581       gtk_tree_path_next (path);
12582   }
12583
12584   gtk_tree_path_free (path);
12585 }
12586
12587 /**
12588  * gtk_tree_view_collapse_all:
12589  * @tree_view: A #GtkTreeView.
12590  *
12591  * Recursively collapses all visible, expanded nodes in @tree_view.
12592  **/
12593 void
12594 gtk_tree_view_collapse_all (GtkTreeView *tree_view)
12595 {
12596   GtkRBTree *tree;
12597   GtkRBNode *node;
12598   GtkTreePath *path;
12599   gint *indices;
12600
12601   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12602
12603   if (tree_view->priv->tree == NULL)
12604     return;
12605
12606   path = gtk_tree_path_new ();
12607   gtk_tree_path_down (path);
12608   indices = gtk_tree_path_get_indices (path);
12609
12610   tree = tree_view->priv->tree;
12611   node = _gtk_rbtree_first (tree);
12612
12613   while (node)
12614     {
12615       if (node->children)
12616         gtk_tree_view_real_collapse_row (tree_view, path, tree, node, FALSE);
12617       indices[0]++;
12618       node = _gtk_rbtree_next (tree, node);
12619     }
12620
12621   gtk_tree_path_free (path);
12622 }
12623
12624 /**
12625  * gtk_tree_view_expand_to_path:
12626  * @tree_view: A #GtkTreeView.
12627  * @path: path to a row.
12628  *
12629  * Expands the row at @path. This will also expand all parent rows of
12630  * @path as necessary.
12631  *
12632  * Since: 2.2
12633  **/
12634 void
12635 gtk_tree_view_expand_to_path (GtkTreeView *tree_view,
12636                               GtkTreePath *path)
12637 {
12638   gint i, depth;
12639   gint *indices;
12640   GtkTreePath *tmp;
12641
12642   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12643   g_return_if_fail (path != NULL);
12644
12645   depth = gtk_tree_path_get_depth (path);
12646   indices = gtk_tree_path_get_indices (path);
12647
12648   tmp = gtk_tree_path_new ();
12649   g_return_if_fail (tmp != NULL);
12650
12651   for (i = 0; i < depth; i++)
12652     {
12653       gtk_tree_path_append_index (tmp, indices[i]);
12654       gtk_tree_view_expand_row (tree_view, tmp, FALSE);
12655     }
12656
12657   gtk_tree_path_free (tmp);
12658 }
12659
12660 /* FIXME the bool return values for expand_row and collapse_row are
12661  * not analagous; they should be TRUE if the row had children and
12662  * was not already in the requested state.
12663  */
12664
12665
12666 static gboolean
12667 gtk_tree_view_real_expand_row (GtkTreeView *tree_view,
12668                                GtkTreePath *path,
12669                                GtkRBTree   *tree,
12670                                GtkRBNode   *node,
12671                                gboolean     open_all,
12672                                gboolean     animate)
12673 {
12674   GtkTreeIter iter;
12675   GtkTreeIter temp;
12676   gboolean expand;
12677
12678   if (animate)
12679     g_object_get (gtk_widget_get_settings (GTK_WIDGET (tree_view)),
12680                   "gtk-enable-animations", &animate,
12681                   NULL);
12682
12683   remove_auto_expand_timeout (tree_view);
12684
12685   if (node->children && !open_all)
12686     return FALSE;
12687
12688   if (! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT))
12689     return FALSE;
12690
12691   gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
12692   if (! gtk_tree_model_iter_has_child (tree_view->priv->model, &iter))
12693     return FALSE;
12694
12695
12696    if (node->children && open_all)
12697     {
12698       gboolean retval = FALSE;
12699       GtkTreePath *tmp_path = gtk_tree_path_copy (path);
12700
12701       gtk_tree_path_append_index (tmp_path, 0);
12702       tree = node->children;
12703       node = _gtk_rbtree_first (tree);
12704       /* try to expand the children */
12705       do
12706         {
12707          gboolean t;
12708          t = gtk_tree_view_real_expand_row (tree_view, tmp_path, tree, node,
12709                                             TRUE, animate);
12710          if (t)
12711            retval = TRUE;
12712
12713          gtk_tree_path_next (tmp_path);
12714          node = _gtk_rbtree_next (tree, node);
12715        }
12716       while (node != NULL);
12717
12718       gtk_tree_path_free (tmp_path);
12719
12720       return retval;
12721     }
12722
12723   g_signal_emit (tree_view, tree_view_signals[TEST_EXPAND_ROW], 0, &iter, path, &expand);
12724
12725   if (!gtk_tree_model_iter_has_child (tree_view->priv->model, &iter))
12726     return FALSE;
12727
12728   if (expand)
12729     return FALSE;
12730
12731   node->children = _gtk_rbtree_new ();
12732   node->children->parent_tree = tree;
12733   node->children->parent_node = node;
12734
12735   gtk_tree_model_iter_children (tree_view->priv->model, &temp, &iter);
12736
12737   gtk_tree_view_build_tree (tree_view,
12738                             node->children,
12739                             &temp,
12740                             gtk_tree_path_get_depth (path) + 1,
12741                             open_all);
12742
12743   if (animate)
12744     {
12745       GtkStyleContext *context;
12746
12747       context = gtk_widget_get_style_context (GTK_WIDGET (tree_view));
12748
12749       gtk_style_context_save (context);
12750       gtk_style_context_add_class (context, GTK_STYLE_CLASS_EXPANDER);
12751
12752       gtk_style_context_notify_state_change (context, tree_view->priv->bin_window,
12753                                              node, GTK_STATE_ACTIVE, TRUE);
12754
12755       _gtk_style_context_invalidate_animation_areas (context);
12756       gtk_style_context_restore (context);
12757     }
12758
12759   install_presize_handler (tree_view);
12760
12761   g_signal_emit (tree_view, tree_view_signals[ROW_EXPANDED], 0, &iter, path);
12762   if (open_all && node->children)
12763     {
12764       _gtk_rbtree_traverse (node->children,
12765                             node->children->root,
12766                             G_PRE_ORDER,
12767                             gtk_tree_view_expand_all_emission_helper,
12768                             tree_view);
12769     }
12770   return TRUE;
12771 }
12772
12773
12774 /**
12775  * gtk_tree_view_expand_row:
12776  * @tree_view: a #GtkTreeView
12777  * @path: path to a row
12778  * @open_all: whether to recursively expand, or just expand immediate children
12779  *
12780  * Opens the row so its children are visible.
12781  *
12782  * Return value: %TRUE if the row existed and had children
12783  **/
12784 gboolean
12785 gtk_tree_view_expand_row (GtkTreeView *tree_view,
12786                           GtkTreePath *path,
12787                           gboolean     open_all)
12788 {
12789   GtkRBTree *tree;
12790   GtkRBNode *node;
12791
12792   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
12793   g_return_val_if_fail (tree_view->priv->model != NULL, FALSE);
12794   g_return_val_if_fail (path != NULL, FALSE);
12795
12796   if (_gtk_tree_view_find_node (tree_view,
12797                                 path,
12798                                 &tree,
12799                                 &node))
12800     return FALSE;
12801
12802   if (tree != NULL)
12803     return gtk_tree_view_real_expand_row (tree_view, path, tree, node, open_all, FALSE);
12804   else
12805     return FALSE;
12806 }
12807
12808 static gboolean
12809 gtk_tree_view_real_collapse_row (GtkTreeView *tree_view,
12810                                  GtkTreePath *path,
12811                                  GtkRBTree   *tree,
12812                                  GtkRBNode   *node,
12813                                  gboolean     animate)
12814 {
12815   GtkTreeIter iter;
12816   GtkTreeIter children;
12817   gboolean collapse;
12818   gint x, y;
12819   GList *list;
12820   GdkWindow *child;
12821
12822   if (animate)
12823     g_object_get (gtk_widget_get_settings (GTK_WIDGET (tree_view)),
12824                   "gtk-enable-animations", &animate,
12825                   NULL);
12826
12827   remove_auto_expand_timeout (tree_view);
12828
12829   if (node->children == NULL)
12830     return FALSE;
12831   gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
12832
12833   g_signal_emit (tree_view, tree_view_signals[TEST_COLLAPSE_ROW], 0, &iter, path, &collapse);
12834
12835   if (collapse)
12836     return FALSE;
12837
12838   /* if the prelighted node is a child of us, we want to unprelight it.  We have
12839    * a chance to prelight the correct node below */
12840
12841   if (tree_view->priv->prelight_tree)
12842     {
12843       GtkRBTree *parent_tree;
12844       GtkRBNode *parent_node;
12845
12846       parent_tree = tree_view->priv->prelight_tree->parent_tree;
12847       parent_node = tree_view->priv->prelight_tree->parent_node;
12848       while (parent_tree)
12849         {
12850           if (parent_tree == tree && parent_node == node)
12851             {
12852               ensure_unprelighted (tree_view);
12853               break;
12854             }
12855           parent_node = parent_tree->parent_node;
12856           parent_tree = parent_tree->parent_tree;
12857         }
12858     }
12859
12860   TREE_VIEW_INTERNAL_ASSERT (gtk_tree_model_iter_children (tree_view->priv->model, &children, &iter), FALSE);
12861
12862   for (list = tree_view->priv->columns; list; list = list->next)
12863     {
12864       GtkTreeViewColumn *column = list->data;
12865
12866       if (gtk_tree_view_column_get_visible (column) == FALSE)
12867         continue;
12868       if (gtk_tree_view_column_get_sizing (column) == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
12869         _gtk_tree_view_column_cell_set_dirty (column, TRUE);
12870     }
12871
12872   if (tree_view->priv->destroy_count_func)
12873     {
12874       GtkTreePath *child_path;
12875       gint child_count = 0;
12876       child_path = gtk_tree_path_copy (path);
12877       gtk_tree_path_down (child_path);
12878       if (node->children)
12879         _gtk_rbtree_traverse (node->children, node->children->root, G_POST_ORDER, count_children_helper, &child_count);
12880       tree_view->priv->destroy_count_func (tree_view, child_path, child_count, tree_view->priv->destroy_count_data);
12881       gtk_tree_path_free (child_path);
12882     }
12883
12884   if (gtk_tree_row_reference_valid (tree_view->priv->cursor))
12885     {
12886       GtkTreePath *cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
12887
12888       if (gtk_tree_path_is_ancestor (path, cursor_path))
12889         {
12890           gtk_tree_row_reference_free (tree_view->priv->cursor);
12891           tree_view->priv->cursor = gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view),
12892                                                                       tree_view->priv->model,
12893                                                                       path);
12894         }
12895       gtk_tree_path_free (cursor_path);
12896     }
12897
12898   if (gtk_tree_row_reference_valid (tree_view->priv->anchor))
12899     {
12900       GtkTreePath *anchor_path = gtk_tree_row_reference_get_path (tree_view->priv->anchor);
12901       if (gtk_tree_path_is_ancestor (path, anchor_path))
12902         {
12903           gtk_tree_row_reference_free (tree_view->priv->anchor);
12904           tree_view->priv->anchor = NULL;
12905         }
12906       gtk_tree_path_free (anchor_path);
12907     }
12908
12909   /* Stop a pending double click */
12910   tree_view->priv->last_button_x = -1;
12911   tree_view->priv->last_button_y = -1;
12912
12913   _gtk_tree_view_accessible_remove (tree_view, node->children, NULL);
12914
12915   if (gtk_tree_view_unref_and_check_selection_tree (tree_view, node->children))
12916     {
12917       _gtk_rbtree_remove (node->children);
12918       g_signal_emit_by_name (tree_view->priv->selection, "changed");
12919     }
12920   else
12921     _gtk_rbtree_remove (node->children);
12922
12923   if (animate)
12924     {
12925       GtkStyleContext *context;
12926
12927       context = gtk_widget_get_style_context (GTK_WIDGET (tree_view));
12928
12929       gtk_style_context_save (context);
12930       gtk_style_context_add_class (context, GTK_STYLE_CLASS_EXPANDER);
12931
12932       gtk_style_context_notify_state_change (context, tree_view->priv->bin_window,
12933                                              node, GTK_STATE_ACTIVE, FALSE);
12934
12935       _gtk_style_context_invalidate_animation_areas (context);
12936       gtk_style_context_restore (context);
12937     }
12938
12939   if (gtk_widget_get_mapped (GTK_WIDGET (tree_view)))
12940     {
12941       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
12942     }
12943
12944   g_signal_emit (tree_view, tree_view_signals[ROW_COLLAPSED], 0, &iter, path);
12945
12946   if (gtk_widget_get_mapped (GTK_WIDGET (tree_view)))
12947     {
12948       /* now that we've collapsed all rows, we want to try to set the prelight
12949        * again. To do this, we fake a motion event and send it to ourselves. */
12950
12951       child = gdk_window_get_device_position (gdk_window_get_parent (tree_view->priv->bin_window),
12952                                               gdk_device_manager_get_client_pointer (
12953                                                 gdk_display_get_device_manager (
12954                                                   gtk_widget_get_display (GTK_WIDGET (tree_view)))),
12955                                               &x, &y, NULL);
12956       if (child == tree_view->priv->bin_window)
12957         {
12958           GdkEventMotion event;
12959           gint child_x, child_y;
12960
12961           gdk_window_get_position (child, &child_x, &child_y);
12962
12963           event.window = tree_view->priv->bin_window;
12964           event.x = x - child_x;
12965           event.y = y - child_y;
12966
12967           /* despite the fact this isn't a real event, I'm almost positive it will
12968            * never trigger a drag event.  maybe_drag is the only function that uses
12969            * more than just event.x and event.y. */
12970           gtk_tree_view_motion_bin_window (GTK_WIDGET (tree_view), &event);
12971         }
12972     }
12973
12974   return TRUE;
12975 }
12976
12977 /**
12978  * gtk_tree_view_collapse_row:
12979  * @tree_view: a #GtkTreeView
12980  * @path: path to a row in the @tree_view
12981  *
12982  * Collapses a row (hides its child rows, if they exist).
12983  *
12984  * Return value: %TRUE if the row was collapsed.
12985  **/
12986 gboolean
12987 gtk_tree_view_collapse_row (GtkTreeView *tree_view,
12988                             GtkTreePath *path)
12989 {
12990   GtkRBTree *tree;
12991   GtkRBNode *node;
12992
12993   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
12994   g_return_val_if_fail (tree_view->priv->tree != NULL, FALSE);
12995   g_return_val_if_fail (path != NULL, FALSE);
12996
12997   if (_gtk_tree_view_find_node (tree_view,
12998                                 path,
12999                                 &tree,
13000                                 &node))
13001     return FALSE;
13002
13003   if (tree == NULL || node->children == NULL)
13004     return FALSE;
13005
13006   return gtk_tree_view_real_collapse_row (tree_view, path, tree, node, FALSE);
13007 }
13008
13009 static void
13010 gtk_tree_view_map_expanded_rows_helper (GtkTreeView            *tree_view,
13011                                         GtkRBTree              *tree,
13012                                         GtkTreePath            *path,
13013                                         GtkTreeViewMappingFunc  func,
13014                                         gpointer                user_data)
13015 {
13016   GtkRBNode *node;
13017
13018   if (tree == NULL || tree->root == NULL)
13019     return;
13020
13021   node = _gtk_rbtree_first (tree);
13022
13023   while (node)
13024     {
13025       if (node->children)
13026         {
13027           (* func) (tree_view, path, user_data);
13028           gtk_tree_path_down (path);
13029           gtk_tree_view_map_expanded_rows_helper (tree_view, node->children, path, func, user_data);
13030           gtk_tree_path_up (path);
13031         }
13032       gtk_tree_path_next (path);
13033       node = _gtk_rbtree_next (tree, node);
13034     }
13035 }
13036
13037 /**
13038  * gtk_tree_view_map_expanded_rows:
13039  * @tree_view: A #GtkTreeView
13040  * @func: (scope call): A function to be called
13041  * @data: User data to be passed to the function.
13042  *
13043  * Calls @func on all expanded rows.
13044  **/
13045 void
13046 gtk_tree_view_map_expanded_rows (GtkTreeView            *tree_view,
13047                                  GtkTreeViewMappingFunc  func,
13048                                  gpointer                user_data)
13049 {
13050   GtkTreePath *path;
13051
13052   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13053   g_return_if_fail (func != NULL);
13054
13055   path = gtk_tree_path_new_first ();
13056
13057   gtk_tree_view_map_expanded_rows_helper (tree_view,
13058                                           tree_view->priv->tree,
13059                                           path, func, user_data);
13060
13061   gtk_tree_path_free (path);
13062 }
13063
13064 /**
13065  * gtk_tree_view_row_expanded:
13066  * @tree_view: A #GtkTreeView.
13067  * @path: A #GtkTreePath to test expansion state.
13068  *
13069  * Returns %TRUE if the node pointed to by @path is expanded in @tree_view.
13070  *
13071  * Return value: %TRUE if #path is expanded.
13072  **/
13073 gboolean
13074 gtk_tree_view_row_expanded (GtkTreeView *tree_view,
13075                             GtkTreePath *path)
13076 {
13077   GtkRBTree *tree;
13078   GtkRBNode *node;
13079
13080   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
13081   g_return_val_if_fail (path != NULL, FALSE);
13082
13083   _gtk_tree_view_find_node (tree_view, path, &tree, &node);
13084
13085   if (node == NULL)
13086     return FALSE;
13087
13088   return (node->children != NULL);
13089 }
13090
13091 /**
13092  * gtk_tree_view_get_reorderable:
13093  * @tree_view: a #GtkTreeView
13094  *
13095  * Retrieves whether the user can reorder the tree via drag-and-drop. See
13096  * gtk_tree_view_set_reorderable().
13097  *
13098  * Return value: %TRUE if the tree can be reordered.
13099  **/
13100 gboolean
13101 gtk_tree_view_get_reorderable (GtkTreeView *tree_view)
13102 {
13103   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
13104
13105   return tree_view->priv->reorderable;
13106 }
13107
13108 /**
13109  * gtk_tree_view_set_reorderable:
13110  * @tree_view: A #GtkTreeView.
13111  * @reorderable: %TRUE, if the tree can be reordered.
13112  *
13113  * This function is a convenience function to allow you to reorder
13114  * models that support the #GtkTreeDragSourceIface and the
13115  * #GtkTreeDragDestIface.  Both #GtkTreeStore and #GtkListStore support
13116  * these.  If @reorderable is %TRUE, then the user can reorder the
13117  * model by dragging and dropping rows. The developer can listen to
13118  * these changes by connecting to the model's row_inserted and
13119  * row_deleted signals. The reordering is implemented by setting up
13120  * the tree view as a drag source and destination. Therefore, drag and
13121  * drop can not be used in a reorderable view for any other purpose.
13122  *
13123  * This function does not give you any degree of control over the order -- any
13124  * reordering is allowed.  If more control is needed, you should probably
13125  * handle drag and drop manually.
13126  **/
13127 void
13128 gtk_tree_view_set_reorderable (GtkTreeView *tree_view,
13129                                gboolean     reorderable)
13130 {
13131   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13132
13133   reorderable = reorderable != FALSE;
13134
13135   if (tree_view->priv->reorderable == reorderable)
13136     return;
13137
13138   if (reorderable)
13139     {
13140       const GtkTargetEntry row_targets[] = {
13141         { "GTK_TREE_MODEL_ROW", GTK_TARGET_SAME_WIDGET, 0 }
13142       };
13143
13144       gtk_tree_view_enable_model_drag_source (tree_view,
13145                                               GDK_BUTTON1_MASK,
13146                                               row_targets,
13147                                               G_N_ELEMENTS (row_targets),
13148                                               GDK_ACTION_MOVE);
13149       gtk_tree_view_enable_model_drag_dest (tree_view,
13150                                             row_targets,
13151                                             G_N_ELEMENTS (row_targets),
13152                                             GDK_ACTION_MOVE);
13153     }
13154   else
13155     {
13156       gtk_tree_view_unset_rows_drag_source (tree_view);
13157       gtk_tree_view_unset_rows_drag_dest (tree_view);
13158     }
13159
13160   tree_view->priv->reorderable = reorderable;
13161
13162   g_object_notify (G_OBJECT (tree_view), "reorderable");
13163 }
13164
13165 static void
13166 gtk_tree_view_real_set_cursor (GtkTreeView     *tree_view,
13167                                GtkTreePath     *path,
13168                                gboolean         clear_and_select,
13169                                gboolean         clamp_node)
13170 {
13171   GtkRBTree *tree = NULL;
13172   GtkRBNode *node = NULL;
13173
13174   if (gtk_tree_row_reference_valid (tree_view->priv->cursor))
13175     {
13176       GtkTreePath *cursor_path;
13177       cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
13178       gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
13179       gtk_tree_path_free (cursor_path);
13180     }
13181
13182   gtk_tree_row_reference_free (tree_view->priv->cursor);
13183   tree_view->priv->cursor = NULL;
13184
13185   /* One cannot set the cursor on a separator.   Also, if
13186    * _gtk_tree_view_find_node returns TRUE, it ran out of tree
13187    * before finding the tree and node belonging to path.  The
13188    * path maps to a non-existing path and we will silently bail out.
13189    * We unset tree and node to avoid further processing.
13190    */
13191   if (!row_is_separator (tree_view, NULL, path)
13192       && _gtk_tree_view_find_node (tree_view, path, &tree, &node) == FALSE)
13193     {
13194       tree_view->priv->cursor =
13195           gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view),
13196                                             tree_view->priv->model,
13197                                             path);
13198     }
13199   else
13200     {
13201       tree = NULL;
13202       node = NULL;
13203     }
13204
13205   if (tree != NULL)
13206     {
13207       GtkRBTree *new_tree = NULL;
13208       GtkRBNode *new_node = NULL;
13209
13210       if (clear_and_select && !tree_view->priv->modify_selection_pressed)
13211         {
13212           GtkTreeSelectMode mode = 0;
13213
13214           if (tree_view->priv->extend_selection_pressed)
13215             mode |= GTK_TREE_SELECT_MODE_EXTEND;
13216
13217           _gtk_tree_selection_internal_select_node (tree_view->priv->selection,
13218                                                     node, tree, path, mode,
13219                                                     FALSE);
13220         }
13221
13222       /* We have to re-find tree and node here again, somebody might have
13223        * cleared the node or the whole tree in the GtkTreeSelection::changed
13224        * callback. If the nodes differ we bail out here.
13225        */
13226       _gtk_tree_view_find_node (tree_view, path, &new_tree, &new_node);
13227
13228       if (tree != new_tree || node != new_node)
13229         return;
13230
13231       if (clamp_node)
13232         {
13233           gtk_tree_view_clamp_node_visible (tree_view, tree, node);
13234           _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
13235         }
13236     }
13237
13238   g_signal_emit (tree_view, tree_view_signals[CURSOR_CHANGED], 0);
13239 }
13240
13241 /**
13242  * gtk_tree_view_get_cursor:
13243  * @tree_view: A #GtkTreeView
13244  * @path: (out) (transfer full) (allow-none): A pointer to be filled with the current cursor path, or %NULL
13245  * @focus_column: (out) (transfer none) (allow-none): A pointer to be filled with the current focus column, or %NULL
13246  *
13247  * Fills in @path and @focus_column with the current path and focus column.  If
13248  * the cursor isn't currently set, then *@path will be %NULL.  If no column
13249  * currently has focus, then *@focus_column will be %NULL.
13250  *
13251  * The returned #GtkTreePath must be freed with gtk_tree_path_free() when
13252  * you are done with it.
13253  **/
13254 void
13255 gtk_tree_view_get_cursor (GtkTreeView        *tree_view,
13256                           GtkTreePath       **path,
13257                           GtkTreeViewColumn **focus_column)
13258 {
13259   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13260
13261   if (path)
13262     {
13263       if (gtk_tree_row_reference_valid (tree_view->priv->cursor))
13264         *path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
13265       else
13266         *path = NULL;
13267     }
13268
13269   if (focus_column)
13270     {
13271       *focus_column = tree_view->priv->focus_column;
13272     }
13273 }
13274
13275 /**
13276  * gtk_tree_view_set_cursor:
13277  * @tree_view: A #GtkTreeView
13278  * @path: A #GtkTreePath
13279  * @focus_column: (allow-none): A #GtkTreeViewColumn, or %NULL
13280  * @start_editing: %TRUE if the specified cell should start being edited.
13281  *
13282  * Sets the current keyboard focus to be at @path, and selects it.  This is
13283  * useful when you want to focus the user's attention on a particular row.  If
13284  * @focus_column is not %NULL, then focus is given to the column specified by
13285  * it. Additionally, if @focus_column is specified, and @start_editing is
13286  * %TRUE, then editing should be started in the specified cell.
13287  * This function is often followed by @gtk_widget_grab_focus (@tree_view)
13288  * in order to give keyboard focus to the widget.  Please note that editing
13289  * can only happen when the widget is realized.
13290  *
13291  * If @path is invalid for @model, the current cursor (if any) will be unset
13292  * and the function will return without failing.
13293  **/
13294 void
13295 gtk_tree_view_set_cursor (GtkTreeView       *tree_view,
13296                           GtkTreePath       *path,
13297                           GtkTreeViewColumn *focus_column,
13298                           gboolean           start_editing)
13299 {
13300   gtk_tree_view_set_cursor_on_cell (tree_view, path, focus_column,
13301                                     NULL, start_editing);
13302 }
13303
13304 /**
13305  * gtk_tree_view_set_cursor_on_cell:
13306  * @tree_view: A #GtkTreeView
13307  * @path: A #GtkTreePath
13308  * @focus_column: (allow-none): A #GtkTreeViewColumn, or %NULL
13309  * @focus_cell: (allow-none): A #GtkCellRenderer, or %NULL
13310  * @start_editing: %TRUE if the specified cell should start being edited.
13311  *
13312  * Sets the current keyboard focus to be at @path, and selects it.  This is
13313  * useful when you want to focus the user's attention on a particular row.  If
13314  * @focus_column is not %NULL, then focus is given to the column specified by
13315  * it. If @focus_column and @focus_cell are not %NULL, and @focus_column
13316  * contains 2 or more editable or activatable cells, then focus is given to
13317  * the cell specified by @focus_cell. Additionally, if @focus_column is
13318  * specified, and @start_editing is %TRUE, then editing should be started in
13319  * the specified cell.  This function is often followed by
13320  * @gtk_widget_grab_focus (@tree_view) in order to give keyboard focus to the
13321  * widget.  Please note that editing can only happen when the widget is
13322  * realized.
13323  *
13324  * If @path is invalid for @model, the current cursor (if any) will be unset
13325  * and the function will return without failing.
13326  *
13327  * Since: 2.2
13328  **/
13329 void
13330 gtk_tree_view_set_cursor_on_cell (GtkTreeView       *tree_view,
13331                                   GtkTreePath       *path,
13332                                   GtkTreeViewColumn *focus_column,
13333                                   GtkCellRenderer   *focus_cell,
13334                                   gboolean           start_editing)
13335 {
13336   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13337   g_return_if_fail (path != NULL);
13338   g_return_if_fail (focus_column == NULL || GTK_IS_TREE_VIEW_COLUMN (focus_column));
13339
13340   if (!tree_view->priv->model)
13341     return;
13342
13343   if (focus_cell)
13344     {
13345       g_return_if_fail (focus_column);
13346       g_return_if_fail (GTK_IS_CELL_RENDERER (focus_cell));
13347     }
13348
13349   /* cancel the current editing, if it exists */
13350   if (tree_view->priv->edited_column &&
13351       gtk_cell_area_get_edit_widget
13352       (gtk_cell_layout_get_area (GTK_CELL_LAYOUT (tree_view->priv->edited_column))))
13353     gtk_tree_view_stop_editing (tree_view, TRUE);
13354
13355   gtk_tree_view_real_set_cursor (tree_view, path, TRUE, TRUE);
13356
13357   if (focus_column &&
13358       gtk_tree_view_column_get_visible (focus_column))
13359     {
13360       GList *list;
13361       gboolean column_in_tree = FALSE;
13362
13363       for (list = tree_view->priv->columns; list; list = list->next)
13364         if (list->data == focus_column)
13365           {
13366             column_in_tree = TRUE;
13367             break;
13368           }
13369       g_return_if_fail (column_in_tree);
13370       tree_view->priv->focus_column = focus_column;
13371       if (focus_cell)
13372         gtk_tree_view_column_focus_cell (focus_column, focus_cell);
13373       if (start_editing)
13374         gtk_tree_view_start_editing (tree_view, path, TRUE);
13375     }
13376 }
13377
13378 /**
13379  * gtk_tree_view_get_bin_window:
13380  * @tree_view: A #GtkTreeView
13381  *
13382  * Returns the window that @tree_view renders to.
13383  * This is used primarily to compare to <literal>event->window</literal>
13384  * to confirm that the event on @tree_view is on the right window.
13385  *
13386  * Return value: (transfer none): A #GdkWindow, or %NULL when @tree_view
13387  *     hasn't been realized yet
13388  **/
13389 GdkWindow *
13390 gtk_tree_view_get_bin_window (GtkTreeView *tree_view)
13391 {
13392   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
13393
13394   return tree_view->priv->bin_window;
13395 }
13396
13397 /**
13398  * gtk_tree_view_get_path_at_pos:
13399  * @tree_view: A #GtkTreeView.
13400  * @x: The x position to be identified (relative to bin_window).
13401  * @y: The y position to be identified (relative to bin_window).
13402  * @path: (out) (allow-none): A pointer to a #GtkTreePath pointer to be filled in, or %NULL
13403  * @column: (out) (transfer none) (allow-none): A pointer to a #GtkTreeViewColumn pointer to be filled in, or %NULL
13404  * @cell_x: (out) (allow-none): A pointer where the X coordinate relative to the cell can be placed, or %NULL
13405  * @cell_y: (out) (allow-none): A pointer where the Y coordinate relative to the cell can be placed, or %NULL
13406  *
13407  * Finds the path at the point (@x, @y), relative to bin_window coordinates
13408  * (please see gtk_tree_view_get_bin_window()).
13409  * That is, @x and @y are relative to an events coordinates. @x and @y must
13410  * come from an event on the @tree_view only where <literal>event->window ==
13411  * gtk_tree_view_get_bin_window (<!-- -->)</literal>. It is primarily for
13412  * things like popup menus. If @path is non-%NULL, then it will be filled
13413  * with the #GtkTreePath at that point.  This path should be freed with
13414  * gtk_tree_path_free().  If @column is non-%NULL, then it will be filled
13415  * with the column at that point.  @cell_x and @cell_y return the coordinates
13416  * relative to the cell background (i.e. the @background_area passed to
13417  * gtk_cell_renderer_render()).  This function is only meaningful if
13418  * @tree_view is realized.  Therefore this function will always return %FALSE
13419  * if @tree_view is not realized or does not have a model.
13420  *
13421  * For converting widget coordinates (eg. the ones you get from
13422  * GtkWidget::query-tooltip), please see
13423  * gtk_tree_view_convert_widget_to_bin_window_coords().
13424  *
13425  * Return value: %TRUE if a row exists at that coordinate.
13426  **/
13427 gboolean
13428 gtk_tree_view_get_path_at_pos (GtkTreeView        *tree_view,
13429                                gint                x,
13430                                gint                y,
13431                                GtkTreePath       **path,
13432                                GtkTreeViewColumn **column,
13433                                gint               *cell_x,
13434                                gint               *cell_y)
13435 {
13436   GtkRBTree *tree;
13437   GtkRBNode *node;
13438   gint y_offset;
13439
13440   g_return_val_if_fail (tree_view != NULL, FALSE);
13441
13442   if (path)
13443     *path = NULL;
13444   if (column)
13445     *column = NULL;
13446
13447   if (tree_view->priv->bin_window == NULL)
13448     return FALSE;
13449
13450   if (tree_view->priv->tree == NULL)
13451     return FALSE;
13452
13453   if (x > gtk_adjustment_get_upper (tree_view->priv->hadjustment))
13454     return FALSE;
13455
13456   if (x < 0 || y < 0)
13457     return FALSE;
13458
13459   if (column || cell_x)
13460     {
13461       GtkTreeViewColumn *tmp_column;
13462       GtkTreeViewColumn *last_column = NULL;
13463       GList *list;
13464       gint remaining_x = x;
13465       gboolean found = FALSE;
13466       gboolean rtl;
13467       gint width;
13468
13469       rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
13470       for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
13471            list;
13472            list = (rtl ? list->prev : list->next))
13473         {
13474           tmp_column = list->data;
13475
13476           if (gtk_tree_view_column_get_visible (tmp_column) == FALSE)
13477             continue;
13478
13479           last_column = tmp_column;
13480           width = gtk_tree_view_column_get_width (tmp_column);
13481           if (remaining_x <= width)
13482             {
13483               found = TRUE;
13484
13485               if (column)
13486                 *column = tmp_column;
13487
13488               if (cell_x)
13489                 *cell_x = remaining_x;
13490
13491               break;
13492             }
13493           remaining_x -= width;
13494         }
13495
13496       /* If found is FALSE and there is a last_column, then it the remainder
13497        * space is in that area
13498        */
13499       if (!found)
13500         {
13501           if (last_column)
13502             {
13503               if (column)
13504                 *column = last_column;
13505
13506               if (cell_x)
13507                 *cell_x = gtk_tree_view_column_get_width (last_column) + remaining_x;
13508             }
13509           else
13510             {
13511               return FALSE;
13512             }
13513         }
13514     }
13515
13516   y_offset = _gtk_rbtree_find_offset (tree_view->priv->tree,
13517                                       TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, y),
13518                                       &tree, &node);
13519
13520   if (tree == NULL)
13521     return FALSE;
13522
13523   if (cell_y)
13524     *cell_y = y_offset;
13525
13526   if (path)
13527     *path = _gtk_tree_view_find_path (tree_view, tree, node);
13528
13529   return TRUE;
13530 }
13531
13532
13533 static inline gint
13534 gtk_tree_view_get_cell_area_height (GtkTreeView *tree_view,
13535                                     GtkRBNode   *node,
13536                                     gint         vertical_separator)
13537 {
13538   int height;
13539
13540   /* The "cell" areas are the cell_area passed in to gtk_cell_renderer_render(),
13541    * i.e. just the cells, no spacing.
13542    *
13543    * The cell area height is at least expander_size - vertical_separator.
13544    * For regular nodes, the height is then at least expander_size. We should
13545    * be able to enforce the expander_size minimum here, because this
13546    * function will not be called for irregular (e.g. separator) rows.
13547    */
13548   height = gtk_tree_view_get_row_height (tree_view, node);
13549   if (height < tree_view->priv->expander_size)
13550     height = tree_view->priv->expander_size;
13551
13552   return height - vertical_separator;
13553 }
13554
13555 static inline gint
13556 gtk_tree_view_get_cell_area_y_offset (GtkTreeView *tree_view,
13557                                       GtkRBTree   *tree,
13558                                       GtkRBNode   *node,
13559                                       gint         vertical_separator)
13560 {
13561   int offset;
13562
13563   offset = gtk_tree_view_get_row_y_offset (tree_view, tree, node);
13564   offset += vertical_separator / 2;
13565
13566   return offset;
13567 }
13568
13569 /**
13570  * gtk_tree_view_get_cell_area:
13571  * @tree_view: a #GtkTreeView
13572  * @path: (allow-none): a #GtkTreePath for the row, or %NULL to get only horizontal coordinates
13573  * @column: (allow-none): a #GtkTreeViewColumn for the column, or %NULL to get only vertical coordinates
13574  * @rect: (out): rectangle to fill with cell rect
13575  *
13576  * Fills the bounding rectangle in bin_window coordinates for the cell at the
13577  * row specified by @path and the column specified by @column.  If @path is
13578  * %NULL, or points to a path not currently displayed, the @y and @height fields
13579  * of the rectangle will be filled with 0. If @column is %NULL, the @x and @width
13580  * fields will be filled with 0.  The sum of all cell rects does not cover the
13581  * entire tree; there are extra pixels in between rows, for example. The
13582  * returned rectangle is equivalent to the @cell_area passed to
13583  * gtk_cell_renderer_render().  This function is only valid if @tree_view is
13584  * realized.
13585  **/
13586 void
13587 gtk_tree_view_get_cell_area (GtkTreeView        *tree_view,
13588                              GtkTreePath        *path,
13589                              GtkTreeViewColumn  *column,
13590                              GdkRectangle       *rect)
13591 {
13592   GtkRBTree *tree = NULL;
13593   GtkRBNode *node = NULL;
13594   gint vertical_separator;
13595   gint horizontal_separator;
13596
13597   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13598   g_return_if_fail (column == NULL || GTK_IS_TREE_VIEW_COLUMN (column));
13599   g_return_if_fail (rect != NULL);
13600   g_return_if_fail (!column || gtk_tree_view_column_get_tree_view (column) == (GtkWidget *) tree_view);
13601   g_return_if_fail (gtk_widget_get_realized (GTK_WIDGET (tree_view)));
13602
13603   gtk_widget_style_get (GTK_WIDGET (tree_view),
13604                         "vertical-separator", &vertical_separator,
13605                         "horizontal-separator", &horizontal_separator,
13606                         NULL);
13607
13608   rect->x = 0;
13609   rect->y = 0;
13610   rect->width = 0;
13611   rect->height = 0;
13612
13613   if (column)
13614     {
13615       rect->x = gtk_tree_view_column_get_x_offset (column) + horizontal_separator/2;
13616       rect->width = gtk_tree_view_column_get_width (column) - horizontal_separator;
13617     }
13618
13619   if (path)
13620     {
13621       gboolean ret = _gtk_tree_view_find_node (tree_view, path, &tree, &node);
13622
13623       /* Get vertical coords */
13624       if ((!ret && tree == NULL) || ret)
13625         return;
13626
13627       if (row_is_separator (tree_view, NULL, path))
13628         {
13629           /* There isn't really a "cell area" for separator, so we
13630            * return the y, height values for background area instead.
13631            */
13632           rect->y = gtk_tree_view_get_row_y_offset (tree_view, tree, node);
13633           rect->height = gtk_tree_view_get_row_height (tree_view, node);
13634         }
13635       else
13636         {
13637           rect->y = gtk_tree_view_get_cell_area_y_offset (tree_view, tree, node,
13638                                                           vertical_separator);
13639           rect->height = gtk_tree_view_get_cell_area_height (tree_view, node,
13640                                                              vertical_separator);
13641         }
13642
13643       if (column &&
13644           gtk_tree_view_is_expander_column (tree_view, column))
13645         {
13646           gint depth = gtk_tree_path_get_depth (path);
13647           gboolean rtl;
13648
13649           rtl = gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL;
13650
13651           if (!rtl)
13652             rect->x += (depth - 1) * tree_view->priv->level_indentation;
13653           rect->width -= (depth - 1) * tree_view->priv->level_indentation;
13654
13655           if (gtk_tree_view_draw_expanders (tree_view))
13656             {
13657               if (!rtl)
13658                 rect->x += depth * tree_view->priv->expander_size;
13659               rect->width -= depth * tree_view->priv->expander_size;
13660             }
13661
13662           rect->width = MAX (rect->width, 0);
13663         }
13664     }
13665 }
13666
13667 static inline gint
13668 gtk_tree_view_get_row_height (GtkTreeView *tree_view,
13669                               GtkRBNode   *node)
13670 {
13671   int height;
13672
13673   /* The "background" areas of all rows/cells add up to cover the entire tree.
13674    * The background includes all inter-row and inter-cell spacing.
13675    *
13676    * If the row pointed at by node does not have a height set, we default
13677    * to expander_size, which is the minimum height for regular nodes.
13678    * Non-regular nodes (e.g. separators) can have a height set smaller
13679    * than expander_size and should not be overruled here.
13680    */
13681   height = GTK_RBNODE_GET_HEIGHT (node);
13682   if (height <= 0)
13683     height = tree_view->priv->expander_size;
13684
13685   return height;
13686 }
13687
13688 static inline gint
13689 gtk_tree_view_get_row_y_offset (GtkTreeView *tree_view,
13690                                 GtkRBTree   *tree,
13691                                 GtkRBNode   *node)
13692 {
13693   int offset;
13694
13695   offset = _gtk_rbtree_node_find_offset (tree, node);
13696
13697   return RBTREE_Y_TO_TREE_WINDOW_Y (tree_view, offset);
13698 }
13699
13700 /**
13701  * gtk_tree_view_get_background_area:
13702  * @tree_view: a #GtkTreeView
13703  * @path: (allow-none): a #GtkTreePath for the row, or %NULL to get only horizontal coordinates
13704  * @column: (allow-none): a #GtkTreeViewColumn for the column, or %NULL to get only vertical coordiantes
13705  * @rect: (out): rectangle to fill with cell background rect
13706  *
13707  * Fills the bounding rectangle in bin_window coordinates for the cell at the
13708  * row specified by @path and the column specified by @column.  If @path is
13709  * %NULL, or points to a node not found in the tree, the @y and @height fields of
13710  * the rectangle will be filled with 0. If @column is %NULL, the @x and @width
13711  * fields will be filled with 0.  The returned rectangle is equivalent to the
13712  * @background_area passed to gtk_cell_renderer_render().  These background
13713  * areas tile to cover the entire bin window.  Contrast with the @cell_area,
13714  * returned by gtk_tree_view_get_cell_area(), which returns only the cell
13715  * itself, excluding surrounding borders and the tree expander area.
13716  *
13717  **/
13718 void
13719 gtk_tree_view_get_background_area (GtkTreeView        *tree_view,
13720                                    GtkTreePath        *path,
13721                                    GtkTreeViewColumn  *column,
13722                                    GdkRectangle       *rect)
13723 {
13724   GtkRBTree *tree = NULL;
13725   GtkRBNode *node = NULL;
13726
13727   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13728   g_return_if_fail (column == NULL || GTK_IS_TREE_VIEW_COLUMN (column));
13729   g_return_if_fail (rect != NULL);
13730
13731   rect->x = 0;
13732   rect->y = 0;
13733   rect->width = 0;
13734   rect->height = 0;
13735
13736   if (path)
13737     {
13738       /* Get vertical coords */
13739
13740       if (!_gtk_tree_view_find_node (tree_view, path, &tree, &node) &&
13741           tree == NULL)
13742         return;
13743
13744       rect->y = gtk_tree_view_get_row_y_offset (tree_view, tree, node);
13745       rect->height = gtk_tree_view_get_row_height (tree_view, node);
13746     }
13747
13748   if (column)
13749     {
13750       gint x2 = 0;
13751
13752       gtk_tree_view_get_background_xrange (tree_view, tree, column, &rect->x, &x2);
13753       rect->width = x2 - rect->x;
13754     }
13755 }
13756
13757 /**
13758  * gtk_tree_view_get_visible_rect:
13759  * @tree_view: a #GtkTreeView
13760  * @visible_rect: (out): rectangle to fill
13761  *
13762  * Fills @visible_rect with the currently-visible region of the
13763  * buffer, in tree coordinates. Convert to bin_window coordinates with
13764  * gtk_tree_view_convert_tree_to_bin_window_coords().
13765  * Tree coordinates start at 0,0 for row 0 of the tree, and cover the entire
13766  * scrollable area of the tree.
13767  **/
13768 void
13769 gtk_tree_view_get_visible_rect (GtkTreeView  *tree_view,
13770                                 GdkRectangle *visible_rect)
13771 {
13772   GtkAllocation allocation;
13773   GtkWidget *widget;
13774
13775   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13776
13777   widget = GTK_WIDGET (tree_view);
13778
13779   if (visible_rect)
13780     {
13781       gtk_widget_get_allocation (widget, &allocation);
13782       visible_rect->x = gtk_adjustment_get_value (tree_view->priv->hadjustment);
13783       visible_rect->y = gtk_adjustment_get_value (tree_view->priv->vadjustment);
13784       visible_rect->width = allocation.width;
13785       visible_rect->height = allocation.height - gtk_tree_view_get_effective_header_height (tree_view);
13786     }
13787 }
13788
13789 /**
13790  * gtk_tree_view_convert_widget_to_tree_coords:
13791  * @tree_view: a #GtkTreeView
13792  * @wx: X coordinate relative to the widget
13793  * @wy: Y coordinate relative to the widget
13794  * @tx: (out): return location for tree X coordinate
13795  * @ty: (out): return location for tree Y coordinate
13796  *
13797  * Converts widget coordinates to coordinates for the
13798  * tree (the full scrollable area of the tree).
13799  *
13800  * Since: 2.12
13801  **/
13802 void
13803 gtk_tree_view_convert_widget_to_tree_coords (GtkTreeView *tree_view,
13804                                              gint         wx,
13805                                              gint         wy,
13806                                              gint        *tx,
13807                                              gint        *ty)
13808 {
13809   gint x, y;
13810
13811   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13812
13813   gtk_tree_view_convert_widget_to_bin_window_coords (tree_view,
13814                                                      wx, wy,
13815                                                      &x, &y);
13816   gtk_tree_view_convert_bin_window_to_tree_coords (tree_view,
13817                                                    x, y,
13818                                                    tx, ty);
13819 }
13820
13821 /**
13822  * gtk_tree_view_convert_tree_to_widget_coords:
13823  * @tree_view: a #GtkTreeView
13824  * @tx: X coordinate relative to the tree
13825  * @ty: Y coordinate relative to the tree
13826  * @wx: (out): return location for widget X coordinate
13827  * @wy: (out): return location for widget Y coordinate
13828  *
13829  * Converts tree coordinates (coordinates in full scrollable area of the tree)
13830  * to widget coordinates.
13831  *
13832  * Since: 2.12
13833  **/
13834 void
13835 gtk_tree_view_convert_tree_to_widget_coords (GtkTreeView *tree_view,
13836                                              gint         tx,
13837                                              gint         ty,
13838                                              gint        *wx,
13839                                              gint        *wy)
13840 {
13841   gint x, y;
13842
13843   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13844
13845   gtk_tree_view_convert_tree_to_bin_window_coords (tree_view,
13846                                                    tx, ty,
13847                                                    &x, &y);
13848   gtk_tree_view_convert_bin_window_to_widget_coords (tree_view,
13849                                                      x, y,
13850                                                      wx, wy);
13851 }
13852
13853 /**
13854  * gtk_tree_view_convert_widget_to_bin_window_coords:
13855  * @tree_view: a #GtkTreeView
13856  * @wx: X coordinate relative to the widget
13857  * @wy: Y coordinate relative to the widget
13858  * @bx: (out): return location for bin_window X coordinate
13859  * @by: (out): return location for bin_window Y coordinate
13860  *
13861  * Converts widget coordinates to coordinates for the bin_window
13862  * (see gtk_tree_view_get_bin_window()).
13863  *
13864  * Since: 2.12
13865  **/
13866 void
13867 gtk_tree_view_convert_widget_to_bin_window_coords (GtkTreeView *tree_view,
13868                                                    gint         wx,
13869                                                    gint         wy,
13870                                                    gint        *bx,
13871                                                    gint        *by)
13872 {
13873   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13874
13875   if (bx)
13876     *bx = wx + gtk_adjustment_get_value (tree_view->priv->hadjustment);
13877   if (by)
13878     *by = wy - gtk_tree_view_get_effective_header_height (tree_view);
13879 }
13880
13881 /**
13882  * gtk_tree_view_convert_bin_window_to_widget_coords:
13883  * @tree_view: a #GtkTreeView
13884  * @bx: bin_window X coordinate
13885  * @by: bin_window Y coordinate
13886  * @wx: (out): return location for widget X coordinate
13887  * @wy: (out): return location for widget Y coordinate
13888  *
13889  * Converts bin_window coordinates (see gtk_tree_view_get_bin_window())
13890  * to widget relative coordinates.
13891  *
13892  * Since: 2.12
13893  **/
13894 void
13895 gtk_tree_view_convert_bin_window_to_widget_coords (GtkTreeView *tree_view,
13896                                                    gint         bx,
13897                                                    gint         by,
13898                                                    gint        *wx,
13899                                                    gint        *wy)
13900 {
13901   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13902
13903   if (wx)
13904     *wx = bx - gtk_adjustment_get_value (tree_view->priv->hadjustment);
13905   if (wy)
13906     *wy = by + gtk_tree_view_get_effective_header_height (tree_view);
13907 }
13908
13909 /**
13910  * gtk_tree_view_convert_tree_to_bin_window_coords:
13911  * @tree_view: a #GtkTreeView
13912  * @tx: tree X coordinate
13913  * @ty: tree Y coordinate
13914  * @bx: (out): return location for X coordinate relative to bin_window
13915  * @by: (out): return location for Y coordinate relative to bin_window
13916  *
13917  * Converts tree coordinates (coordinates in full scrollable area of the tree)
13918  * to bin_window coordinates.
13919  *
13920  * Since: 2.12
13921  **/
13922 void
13923 gtk_tree_view_convert_tree_to_bin_window_coords (GtkTreeView *tree_view,
13924                                                  gint         tx,
13925                                                  gint         ty,
13926                                                  gint        *bx,
13927                                                  gint        *by)
13928 {
13929   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13930
13931   if (bx)
13932     *bx = tx;
13933   if (by)
13934     *by = ty - tree_view->priv->dy;
13935 }
13936
13937 /**
13938  * gtk_tree_view_convert_bin_window_to_tree_coords:
13939  * @tree_view: a #GtkTreeView
13940  * @bx: X coordinate relative to bin_window
13941  * @by: Y coordinate relative to bin_window
13942  * @tx: (out): return location for tree X coordinate
13943  * @ty: (out): return location for tree Y coordinate
13944  *
13945  * Converts bin_window coordinates to coordinates for the
13946  * tree (the full scrollable area of the tree).
13947  *
13948  * Since: 2.12
13949  **/
13950 void
13951 gtk_tree_view_convert_bin_window_to_tree_coords (GtkTreeView *tree_view,
13952                                                  gint         bx,
13953                                                  gint         by,
13954                                                  gint        *tx,
13955                                                  gint        *ty)
13956 {
13957   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13958
13959   if (tx)
13960     *tx = bx;
13961   if (ty)
13962     *ty = by + tree_view->priv->dy;
13963 }
13964
13965
13966
13967 /**
13968  * gtk_tree_view_get_visible_range:
13969  * @tree_view: A #GtkTreeView
13970  * @start_path: (out) (allow-none): Return location for start of region,
13971  *              or %NULL.
13972  * @end_path: (out) (allow-none): Return location for end of region, or %NULL.
13973  *
13974  * Sets @start_path and @end_path to be the first and last visible path.
13975  * Note that there may be invisible paths in between.
13976  *
13977  * The paths should be freed with gtk_tree_path_free() after use.
13978  *
13979  * Returns: %TRUE, if valid paths were placed in @start_path and @end_path.
13980  *
13981  * Since: 2.8
13982  **/
13983 gboolean
13984 gtk_tree_view_get_visible_range (GtkTreeView  *tree_view,
13985                                  GtkTreePath **start_path,
13986                                  GtkTreePath **end_path)
13987 {
13988   GtkRBTree *tree;
13989   GtkRBNode *node;
13990   gboolean retval;
13991
13992   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
13993
13994   if (!tree_view->priv->tree)
13995     return FALSE;
13996
13997   retval = TRUE;
13998
13999   if (start_path)
14000     {
14001       _gtk_rbtree_find_offset (tree_view->priv->tree,
14002                                TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, 0),
14003                                &tree, &node);
14004       if (node)
14005         *start_path = _gtk_tree_view_find_path (tree_view, tree, node);
14006       else
14007         retval = FALSE;
14008     }
14009
14010   if (end_path)
14011     {
14012       gint y;
14013
14014       if (tree_view->priv->height < gtk_adjustment_get_page_size (tree_view->priv->vadjustment))
14015         y = tree_view->priv->height - 1;
14016       else
14017         y = TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, gtk_adjustment_get_page_size (tree_view->priv->vadjustment)) - 1;
14018
14019       _gtk_rbtree_find_offset (tree_view->priv->tree, y, &tree, &node);
14020       if (node)
14021         *end_path = _gtk_tree_view_find_path (tree_view, tree, node);
14022       else
14023         retval = FALSE;
14024     }
14025
14026   return retval;
14027 }
14028
14029 /**
14030  * gtk_tree_view_is_blank_at_pos:
14031  * @tree_view: A #GtkTreeView
14032  * @x: The x position to be identified (relative to bin_window)
14033  * @y: The y position to be identified (relative to bin_window)
14034  * @path: (out) (allow-none): A pointer to a #GtkTreePath pointer to be filled in, or %NULL
14035  * @column: (out) (allow-none): A pointer to a #GtkTreeViewColumn pointer to be filled in, or %NULL
14036  * @cell_x: (out) (allow-none): A pointer where the X coordinate relative to the cell can be placed, or %NULL
14037  * @cell_y: (out) (allow-none): A pointer where the Y coordinate relative to the cell can be placed, or %NULL
14038  *
14039  * Determine whether the point (@x, @y) in @tree_view is blank, that is no
14040  * cell content nor an expander arrow is drawn at the location. If so, the
14041  * location can be considered as the background. You might wish to take
14042  * special action on clicks on the background, such as clearing a current
14043  * selection, having a custom context menu or starting rubber banding.
14044  *
14045  * The @x and @y coordinate that are provided must be relative to bin_window
14046  * coordinates.  That is, @x and @y must come from an event on @tree_view
14047  * where <literal>event->window == gtk_tree_view_get_bin_window (<!-- -->)</literal>.
14048  *
14049  * For converting widget coordinates (eg. the ones you get from
14050  * GtkWidget::query-tooltip), please see
14051  * gtk_tree_view_convert_widget_to_bin_window_coords().
14052  *
14053  * The @path, @column, @cell_x and @cell_y arguments will be filled in
14054  * likewise as for gtk_tree_view_get_path_at_pos().  Please see
14055  * gtk_tree_view_get_path_at_pos() for more information.
14056  *
14057  * Return value: %TRUE if the area at the given coordinates is blank,
14058  * %FALSE otherwise.
14059  *
14060  * Since: 3.0
14061  */
14062 gboolean
14063 gtk_tree_view_is_blank_at_pos (GtkTreeView       *tree_view,
14064                                gint                x,
14065                                gint                y,
14066                                GtkTreePath       **path,
14067                                GtkTreeViewColumn **column,
14068                                gint               *cell_x,
14069                                gint               *cell_y)
14070 {
14071   GtkRBTree *tree;
14072   GtkRBNode *node;
14073   GtkTreeIter iter;
14074   GtkTreePath *real_path;
14075   GtkTreeViewColumn *real_column;
14076   GdkRectangle cell_area, background_area;
14077
14078   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
14079
14080   if (!gtk_tree_view_get_path_at_pos (tree_view, x, y,
14081                                       &real_path, &real_column,
14082                                       cell_x, cell_y))
14083     /* If there's no path here, it is blank */
14084     return TRUE;
14085
14086   if (path)
14087     *path = real_path;
14088
14089   if (column)
14090     *column = real_column;
14091
14092   gtk_tree_model_get_iter (tree_view->priv->model, &iter, real_path);
14093   _gtk_tree_view_find_node (tree_view, real_path, &tree, &node);
14094
14095   /* Check if there's an expander arrow at (x, y) */
14096   if (real_column == tree_view->priv->expander_column
14097       && gtk_tree_view_draw_expanders (tree_view))
14098     {
14099       gboolean over_arrow;
14100
14101       over_arrow = coords_are_over_arrow (tree_view, tree, node, x, y);
14102
14103       if (over_arrow)
14104         {
14105           if (!path)
14106             gtk_tree_path_free (real_path);
14107           return FALSE;
14108         }
14109     }
14110
14111   /* Otherwise, have the column see if there's a cell at (x, y) */
14112   gtk_tree_view_column_cell_set_cell_data (real_column,
14113                                            tree_view->priv->model,
14114                                            &iter,
14115                                            GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT),
14116                                            node->children ? TRUE : FALSE);
14117
14118   gtk_tree_view_get_background_area (tree_view, real_path, real_column,
14119                                      &background_area);
14120   gtk_tree_view_get_cell_area (tree_view, real_path, real_column,
14121                                &cell_area);
14122
14123   if (!path)
14124     gtk_tree_path_free (real_path);
14125
14126   return _gtk_tree_view_column_is_blank_at_pos (real_column,
14127                                                 &cell_area,
14128                                                 &background_area,
14129                                                 x, y);
14130 }
14131
14132 static void
14133 unset_reorderable (GtkTreeView *tree_view)
14134 {
14135   if (tree_view->priv->reorderable)
14136     {
14137       tree_view->priv->reorderable = FALSE;
14138       g_object_notify (G_OBJECT (tree_view), "reorderable");
14139     }
14140 }
14141
14142 /**
14143  * gtk_tree_view_enable_model_drag_source:
14144  * @tree_view: a #GtkTreeView
14145  * @start_button_mask: Mask of allowed buttons to start drag
14146  * @targets: (array length=n_targets): the table of targets that the drag will support
14147  * @n_targets: the number of items in @targets
14148  * @actions: the bitmask of possible actions for a drag from this
14149  *    widget
14150  *
14151  * Turns @tree_view into a drag source for automatic DND. Calling this
14152  * method sets #GtkTreeView:reorderable to %FALSE.
14153  **/
14154 void
14155 gtk_tree_view_enable_model_drag_source (GtkTreeView              *tree_view,
14156                                         GdkModifierType           start_button_mask,
14157                                         const GtkTargetEntry     *targets,
14158                                         gint                      n_targets,
14159                                         GdkDragAction             actions)
14160 {
14161   TreeViewDragInfo *di;
14162
14163   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14164
14165   gtk_drag_source_set (GTK_WIDGET (tree_view),
14166                        0,
14167                        targets,
14168                        n_targets,
14169                        actions);
14170
14171   di = ensure_info (tree_view);
14172
14173   di->start_button_mask = start_button_mask;
14174   di->source_actions = actions;
14175   di->source_set = TRUE;
14176
14177   unset_reorderable (tree_view);
14178 }
14179
14180 /**
14181  * gtk_tree_view_enable_model_drag_dest:
14182  * @tree_view: a #GtkTreeView
14183  * @targets: (array length=n_targets): the table of targets that
14184  *           the drag will support
14185  * @n_targets: the number of items in @targets
14186  * @actions: the bitmask of possible actions for a drag from this
14187  *    widget
14188  *
14189  * Turns @tree_view into a drop destination for automatic DND. Calling
14190  * this method sets #GtkTreeView:reorderable to %FALSE.
14191  **/
14192 void
14193 gtk_tree_view_enable_model_drag_dest (GtkTreeView              *tree_view,
14194                                       const GtkTargetEntry     *targets,
14195                                       gint                      n_targets,
14196                                       GdkDragAction             actions)
14197 {
14198   TreeViewDragInfo *di;
14199
14200   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14201
14202   gtk_drag_dest_set (GTK_WIDGET (tree_view),
14203                      0,
14204                      targets,
14205                      n_targets,
14206                      actions);
14207
14208   di = ensure_info (tree_view);
14209   di->dest_set = TRUE;
14210
14211   unset_reorderable (tree_view);
14212 }
14213
14214 /**
14215  * gtk_tree_view_unset_rows_drag_source:
14216  * @tree_view: a #GtkTreeView
14217  *
14218  * Undoes the effect of
14219  * gtk_tree_view_enable_model_drag_source(). Calling this method sets
14220  * #GtkTreeView:reorderable to %FALSE.
14221  **/
14222 void
14223 gtk_tree_view_unset_rows_drag_source (GtkTreeView *tree_view)
14224 {
14225   TreeViewDragInfo *di;
14226
14227   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14228
14229   di = get_info (tree_view);
14230
14231   if (di)
14232     {
14233       if (di->source_set)
14234         {
14235           gtk_drag_source_unset (GTK_WIDGET (tree_view));
14236           di->source_set = FALSE;
14237         }
14238
14239       if (!di->dest_set && !di->source_set)
14240         remove_info (tree_view);
14241     }
14242
14243   unset_reorderable (tree_view);
14244 }
14245
14246 /**
14247  * gtk_tree_view_unset_rows_drag_dest:
14248  * @tree_view: a #GtkTreeView
14249  *
14250  * Undoes the effect of
14251  * gtk_tree_view_enable_model_drag_dest(). Calling this method sets
14252  * #GtkTreeView:reorderable to %FALSE.
14253  **/
14254 void
14255 gtk_tree_view_unset_rows_drag_dest (GtkTreeView *tree_view)
14256 {
14257   TreeViewDragInfo *di;
14258
14259   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14260
14261   di = get_info (tree_view);
14262
14263   if (di)
14264     {
14265       if (di->dest_set)
14266         {
14267           gtk_drag_dest_unset (GTK_WIDGET (tree_view));
14268           di->dest_set = FALSE;
14269         }
14270
14271       if (!di->dest_set && !di->source_set)
14272         remove_info (tree_view);
14273     }
14274
14275   unset_reorderable (tree_view);
14276 }
14277
14278 /**
14279  * gtk_tree_view_set_drag_dest_row:
14280  * @tree_view: a #GtkTreeView
14281  * @path: (allow-none): The path of the row to highlight, or %NULL
14282  * @pos: Specifies whether to drop before, after or into the row
14283  *
14284  * Sets the row that is highlighted for feedback.
14285  * If @path is %NULL, an existing highlight is removed.
14286  */
14287 void
14288 gtk_tree_view_set_drag_dest_row (GtkTreeView            *tree_view,
14289                                  GtkTreePath            *path,
14290                                  GtkTreeViewDropPosition pos)
14291 {
14292   GtkTreePath *current_dest;
14293
14294   /* Note; this function is exported to allow a custom DND
14295    * implementation, so it can't touch TreeViewDragInfo
14296    */
14297
14298   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14299
14300   current_dest = NULL;
14301
14302   if (tree_view->priv->drag_dest_row)
14303     {
14304       current_dest = gtk_tree_row_reference_get_path (tree_view->priv->drag_dest_row);
14305       gtk_tree_row_reference_free (tree_view->priv->drag_dest_row);
14306     }
14307
14308   /* special case a drop on an empty model */
14309   tree_view->priv->empty_view_drop = 0;
14310
14311   if (pos == GTK_TREE_VIEW_DROP_BEFORE && path
14312       && gtk_tree_path_get_depth (path) == 1
14313       && gtk_tree_path_get_indices (path)[0] == 0)
14314     {
14315       gint n_children;
14316
14317       n_children = gtk_tree_model_iter_n_children (tree_view->priv->model,
14318                                                    NULL);
14319
14320       if (!n_children)
14321         tree_view->priv->empty_view_drop = 1;
14322     }
14323
14324   tree_view->priv->drag_dest_pos = pos;
14325
14326   if (path)
14327     {
14328       tree_view->priv->drag_dest_row =
14329         gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view), tree_view->priv->model, path);
14330       gtk_tree_view_queue_draw_path (tree_view, path, NULL);
14331     }
14332   else
14333     tree_view->priv->drag_dest_row = NULL;
14334
14335   if (current_dest)
14336     {
14337       GtkRBTree *tree, *new_tree;
14338       GtkRBNode *node, *new_node;
14339
14340       _gtk_tree_view_find_node (tree_view, current_dest, &tree, &node);
14341       _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
14342
14343       if (tree && node)
14344         {
14345           _gtk_rbtree_next_full (tree, node, &new_tree, &new_node);
14346           if (new_tree && new_node)
14347             _gtk_tree_view_queue_draw_node (tree_view, new_tree, new_node, NULL);
14348
14349           _gtk_rbtree_prev_full (tree, node, &new_tree, &new_node);
14350           if (new_tree && new_node)
14351             _gtk_tree_view_queue_draw_node (tree_view, new_tree, new_node, NULL);
14352         }
14353       gtk_tree_path_free (current_dest);
14354     }
14355 }
14356
14357 /**
14358  * gtk_tree_view_get_drag_dest_row:
14359  * @tree_view: a #GtkTreeView
14360  * @path: (out) (allow-none): Return location for the path of the highlighted row, or %NULL.
14361  * @pos: (out) (allow-none): Return location for the drop position, or %NULL
14362  *
14363  * Gets information about the row that is highlighted for feedback.
14364  **/
14365 void
14366 gtk_tree_view_get_drag_dest_row (GtkTreeView              *tree_view,
14367                                  GtkTreePath             **path,
14368                                  GtkTreeViewDropPosition  *pos)
14369 {
14370   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14371
14372   if (path)
14373     {
14374       if (tree_view->priv->drag_dest_row)
14375         *path = gtk_tree_row_reference_get_path (tree_view->priv->drag_dest_row);
14376       else
14377         {
14378           if (tree_view->priv->empty_view_drop)
14379             *path = gtk_tree_path_new_from_indices (0, -1);
14380           else
14381             *path = NULL;
14382         }
14383     }
14384
14385   if (pos)
14386     *pos = tree_view->priv->drag_dest_pos;
14387 }
14388
14389 /**
14390  * gtk_tree_view_get_dest_row_at_pos:
14391  * @tree_view: a #GtkTreeView
14392  * @drag_x: the position to determine the destination row for
14393  * @drag_y: the position to determine the destination row for
14394  * @path: (out) (allow-none): Return location for the path of the highlighted row, or %NULL.
14395  * @pos: (out) (allow-none): Return location for the drop position, or %NULL
14396  *
14397  * Determines the destination row for a given position.  @drag_x and
14398  * @drag_y are expected to be in widget coordinates.  This function is only
14399  * meaningful if @tree_view is realized.  Therefore this function will always
14400  * return %FALSE if @tree_view is not realized or does not have a model.
14401  *
14402  * Return value: whether there is a row at the given position, %TRUE if this
14403  * is indeed the case.
14404  **/
14405 gboolean
14406 gtk_tree_view_get_dest_row_at_pos (GtkTreeView             *tree_view,
14407                                    gint                     drag_x,
14408                                    gint                     drag_y,
14409                                    GtkTreePath            **path,
14410                                    GtkTreeViewDropPosition *pos)
14411 {
14412   gint cell_y;
14413   gint bin_x, bin_y;
14414   gdouble offset_into_row;
14415   gdouble third;
14416   GdkRectangle cell;
14417   GtkTreeViewColumn *column = NULL;
14418   GtkTreePath *tmp_path = NULL;
14419
14420   /* Note; this function is exported to allow a custom DND
14421    * implementation, so it can't touch TreeViewDragInfo
14422    */
14423
14424   g_return_val_if_fail (tree_view != NULL, FALSE);
14425   g_return_val_if_fail (drag_x >= 0, FALSE);
14426   g_return_val_if_fail (drag_y >= 0, FALSE);
14427
14428   if (path)
14429     *path = NULL;
14430
14431   if (tree_view->priv->bin_window == NULL)
14432     return FALSE;
14433
14434   if (tree_view->priv->tree == NULL)
14435     return FALSE;
14436
14437   /* If in the top third of a row, we drop before that row; if
14438    * in the bottom third, drop after that row; if in the middle,
14439    * and the row has children, drop into the row.
14440    */
14441   gtk_tree_view_convert_widget_to_bin_window_coords (tree_view, drag_x, drag_y,
14442                                                      &bin_x, &bin_y);
14443
14444   if (!gtk_tree_view_get_path_at_pos (tree_view,
14445                                       bin_x,
14446                                       bin_y,
14447                                       &tmp_path,
14448                                       &column,
14449                                       NULL,
14450                                       &cell_y))
14451     return FALSE;
14452
14453   gtk_tree_view_get_background_area (tree_view, tmp_path, column,
14454                                      &cell);
14455
14456   offset_into_row = cell_y;
14457
14458   if (path)
14459     *path = tmp_path;
14460   else
14461     gtk_tree_path_free (tmp_path);
14462
14463   tmp_path = NULL;
14464
14465   third = cell.height / 3.0;
14466
14467   if (pos)
14468     {
14469       if (offset_into_row < third)
14470         {
14471           *pos = GTK_TREE_VIEW_DROP_BEFORE;
14472         }
14473       else if (offset_into_row < (cell.height / 2.0))
14474         {
14475           *pos = GTK_TREE_VIEW_DROP_INTO_OR_BEFORE;
14476         }
14477       else if (offset_into_row < third * 2.0)
14478         {
14479           *pos = GTK_TREE_VIEW_DROP_INTO_OR_AFTER;
14480         }
14481       else
14482         {
14483           *pos = GTK_TREE_VIEW_DROP_AFTER;
14484         }
14485     }
14486
14487   return TRUE;
14488 }
14489
14490
14491
14492 /* KEEP IN SYNC WITH GTK_TREE_VIEW_BIN_EXPOSE */
14493 /**
14494  * gtk_tree_view_create_row_drag_icon:
14495  * @tree_view: a #GtkTreeView
14496  * @path: a #GtkTreePath in @tree_view
14497  *
14498  * Creates a #cairo_surface_t representation of the row at @path.
14499  * This image is used for a drag icon.
14500  *
14501  * Return value: (transfer full): a newly-allocated surface of the drag icon.
14502  **/
14503 cairo_surface_t *
14504 gtk_tree_view_create_row_drag_icon (GtkTreeView  *tree_view,
14505                                     GtkTreePath  *path)
14506 {
14507   GtkTreeIter   iter;
14508   GtkRBTree    *tree;
14509   GtkRBNode    *node;
14510   GtkStyleContext *context;
14511   GtkStateFlags state;
14512   gint cell_offset;
14513   GList *list;
14514   GdkRectangle background_area;
14515   GtkWidget *widget;
14516   gint depth;
14517   /* start drawing inside the black outline */
14518   gint x = 1, y = 1;
14519   cairo_surface_t *surface;
14520   gint bin_window_width;
14521   gboolean is_separator = FALSE;
14522   gboolean rtl, allow_rules;
14523   cairo_t *cr;
14524
14525   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
14526   g_return_val_if_fail (path != NULL, NULL);
14527
14528   widget = GTK_WIDGET (tree_view);
14529
14530   if (!gtk_widget_get_realized (widget))
14531     return NULL;
14532
14533   depth = gtk_tree_path_get_depth (path);
14534
14535   _gtk_tree_view_find_node (tree_view,
14536                             path,
14537                             &tree,
14538                             &node);
14539
14540   if (tree == NULL)
14541     return NULL;
14542
14543   if (!gtk_tree_model_get_iter (tree_view->priv->model,
14544                                 &iter,
14545                                 path))
14546     return NULL;
14547
14548   context = gtk_widget_get_style_context (widget);
14549
14550   gtk_style_context_save (context);
14551
14552   state = gtk_widget_get_state_flags (widget);
14553   gtk_style_context_set_state (context, state);
14554
14555   gtk_style_context_add_class (context, GTK_STYLE_CLASS_VIEW);
14556   gtk_style_context_add_region (context, GTK_STYLE_REGION_COLUMN, 0);
14557
14558   gtk_widget_style_get (widget,
14559                         "allow-rules", &allow_rules,
14560                         NULL);
14561
14562   if (allow_rules && tree_view->priv->has_rules)
14563     {
14564       GtkRegionFlags row_flags;
14565
14566       if ((_gtk_rbtree_node_get_index (tree, node) % 2))
14567         row_flags = GTK_REGION_ODD;
14568       else
14569         row_flags = GTK_REGION_EVEN;
14570
14571       gtk_style_context_add_region (context, GTK_STYLE_REGION_ROW, row_flags);
14572     }
14573
14574   is_separator = row_is_separator (tree_view, &iter, NULL);
14575
14576   cell_offset = x;
14577
14578   background_area.y = y;
14579   background_area.height = gtk_tree_view_get_row_height (tree_view, node);
14580
14581   bin_window_width = gdk_window_get_width (tree_view->priv->bin_window);
14582
14583   surface = gdk_window_create_similar_surface (tree_view->priv->bin_window,
14584                                                CAIRO_CONTENT_COLOR,
14585                                                bin_window_width + 2,
14586                                                background_area.height + 2);
14587
14588   cr = cairo_create (surface);
14589
14590   gtk_render_background (context, cr, 0, 0,
14591                          bin_window_width + 2,
14592                          background_area.height + 2);
14593
14594   rtl = gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL;
14595
14596   for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
14597       list;
14598       list = (rtl ? list->prev : list->next))
14599     {
14600       GtkTreeViewColumn *column = list->data;
14601       GdkRectangle cell_area;
14602       gint vertical_separator;
14603
14604       if (!gtk_tree_view_column_get_visible (column))
14605         continue;
14606
14607       gtk_tree_view_column_cell_set_cell_data (column, tree_view->priv->model, &iter,
14608                                                GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT),
14609                                                node->children?TRUE:FALSE);
14610
14611       background_area.x = cell_offset;
14612       background_area.width = gtk_tree_view_column_get_width (column);
14613
14614       gtk_widget_style_get (widget,
14615                             "vertical-separator", &vertical_separator,
14616                             NULL);
14617
14618       cell_area = background_area;
14619
14620       cell_area.y += vertical_separator / 2;
14621       cell_area.height -= vertical_separator;
14622
14623       if (gtk_tree_view_is_expander_column (tree_view, column))
14624         {
14625           if (!rtl)
14626             cell_area.x += (depth - 1) * tree_view->priv->level_indentation;
14627           cell_area.width -= (depth - 1) * tree_view->priv->level_indentation;
14628
14629           if (gtk_tree_view_draw_expanders (tree_view))
14630             {
14631               if (!rtl)
14632                 cell_area.x += depth * tree_view->priv->expander_size;
14633               cell_area.width -= depth * tree_view->priv->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 void
14694 gtk_tree_view_set_destroy_count_func (GtkTreeView             *tree_view,
14695                                       GtkTreeDestroyCountFunc  func,
14696                                       gpointer                 data,
14697                                       GDestroyNotify           destroy)
14698 {
14699   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14700
14701   if (tree_view->priv->destroy_count_destroy)
14702     tree_view->priv->destroy_count_destroy (tree_view->priv->destroy_count_data);
14703
14704   tree_view->priv->destroy_count_func = func;
14705   tree_view->priv->destroy_count_data = data;
14706   tree_view->priv->destroy_count_destroy = destroy;
14707 }
14708
14709
14710 /*
14711  * Interactive search
14712  */
14713
14714 /**
14715  * gtk_tree_view_set_enable_search:
14716  * @tree_view: A #GtkTreeView
14717  * @enable_search: %TRUE, if the user can search interactively
14718  *
14719  * If @enable_search is set, then the user can type in text to search through
14720  * the tree interactively (this is sometimes called "typeahead find").
14721  *
14722  * Note that even if this is %FALSE, the user can still initiate a search
14723  * using the "start-interactive-search" key binding.
14724  */
14725 void
14726 gtk_tree_view_set_enable_search (GtkTreeView *tree_view,
14727                                  gboolean     enable_search)
14728 {
14729   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14730
14731   enable_search = !!enable_search;
14732
14733   if (tree_view->priv->enable_search != enable_search)
14734     {
14735        tree_view->priv->enable_search = enable_search;
14736        g_object_notify (G_OBJECT (tree_view), "enable-search");
14737     }
14738 }
14739
14740 /**
14741  * gtk_tree_view_get_enable_search:
14742  * @tree_view: A #GtkTreeView
14743  *
14744  * Returns whether or not the tree allows to start interactive searching
14745  * by typing in text.
14746  *
14747  * Return value: whether or not to let the user search interactively
14748  */
14749 gboolean
14750 gtk_tree_view_get_enable_search (GtkTreeView *tree_view)
14751 {
14752   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
14753
14754   return tree_view->priv->enable_search;
14755 }
14756
14757
14758 /**
14759  * gtk_tree_view_get_search_column:
14760  * @tree_view: A #GtkTreeView
14761  *
14762  * Gets the column searched on by the interactive search code.
14763  *
14764  * Return value: the column the interactive search code searches in.
14765  */
14766 gint
14767 gtk_tree_view_get_search_column (GtkTreeView *tree_view)
14768 {
14769   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
14770
14771   return (tree_view->priv->search_column);
14772 }
14773
14774 /**
14775  * gtk_tree_view_set_search_column:
14776  * @tree_view: A #GtkTreeView
14777  * @column: the column of the model to search in, or -1 to disable searching
14778  *
14779  * Sets @column as the column where the interactive search code should
14780  * search in for the current model.
14781  *
14782  * If the search column is set, users can use the "start-interactive-search"
14783  * key binding to bring up search popup. The enable-search property controls
14784  * whether simply typing text will also start an interactive search.
14785  *
14786  * Note that @column refers to a column of the current model. The search
14787  * column is reset to -1 when the model is changed.
14788  */
14789 void
14790 gtk_tree_view_set_search_column (GtkTreeView *tree_view,
14791                                  gint         column)
14792 {
14793   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14794   g_return_if_fail (column >= -1);
14795
14796   if (tree_view->priv->search_column == column)
14797     return;
14798
14799   tree_view->priv->search_column = column;
14800   g_object_notify (G_OBJECT (tree_view), "search-column");
14801 }
14802
14803 /**
14804  * gtk_tree_view_get_search_equal_func: (skip)
14805  * @tree_view: A #GtkTreeView
14806  *
14807  * Returns the compare function currently in use.
14808  *
14809  * Return value: the currently used compare function for the search code.
14810  */
14811
14812 GtkTreeViewSearchEqualFunc
14813 gtk_tree_view_get_search_equal_func (GtkTreeView *tree_view)
14814 {
14815   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
14816
14817   return tree_view->priv->search_equal_func;
14818 }
14819
14820 /**
14821  * gtk_tree_view_set_search_equal_func:
14822  * @tree_view: A #GtkTreeView
14823  * @search_equal_func: the compare function to use during the search
14824  * @search_user_data: (allow-none): user data to pass to @search_equal_func, or %NULL
14825  * @search_destroy: (allow-none): Destroy notifier for @search_user_data, or %NULL
14826  *
14827  * Sets the compare function for the interactive search capabilities; note
14828  * that somewhat like strcmp() returning 0 for equality
14829  * #GtkTreeViewSearchEqualFunc returns %FALSE on matches.
14830  **/
14831 void
14832 gtk_tree_view_set_search_equal_func (GtkTreeView                *tree_view,
14833                                      GtkTreeViewSearchEqualFunc  search_equal_func,
14834                                      gpointer                    search_user_data,
14835                                      GDestroyNotify              search_destroy)
14836 {
14837   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14838   g_return_if_fail (search_equal_func != NULL);
14839
14840   if (tree_view->priv->search_destroy)
14841     tree_view->priv->search_destroy (tree_view->priv->search_user_data);
14842
14843   tree_view->priv->search_equal_func = search_equal_func;
14844   tree_view->priv->search_user_data = search_user_data;
14845   tree_view->priv->search_destroy = search_destroy;
14846   if (tree_view->priv->search_equal_func == NULL)
14847     tree_view->priv->search_equal_func = gtk_tree_view_search_equal_func;
14848 }
14849
14850 /**
14851  * gtk_tree_view_get_search_entry:
14852  * @tree_view: A #GtkTreeView
14853  *
14854  * Returns the #GtkEntry which is currently in use as interactive search
14855  * entry for @tree_view.  In case the built-in entry is being used, %NULL
14856  * will be returned.
14857  *
14858  * Return value: (transfer none): the entry currently in use as search entry.
14859  *
14860  * Since: 2.10
14861  */
14862 GtkEntry *
14863 gtk_tree_view_get_search_entry (GtkTreeView *tree_view)
14864 {
14865   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
14866
14867   if (tree_view->priv->search_custom_entry_set)
14868     return GTK_ENTRY (tree_view->priv->search_entry);
14869
14870   return NULL;
14871 }
14872
14873 /**
14874  * gtk_tree_view_set_search_entry:
14875  * @tree_view: A #GtkTreeView
14876  * @entry: (allow-none): the entry the interactive search code of @tree_view should use or %NULL
14877  *
14878  * Sets the entry which the interactive search code will use for this
14879  * @tree_view.  This is useful when you want to provide a search entry
14880  * in our interface at all time at a fixed position.  Passing %NULL for
14881  * @entry will make the interactive search code use the built-in popup
14882  * entry again.
14883  *
14884  * Since: 2.10
14885  */
14886 void
14887 gtk_tree_view_set_search_entry (GtkTreeView *tree_view,
14888                                 GtkEntry    *entry)
14889 {
14890   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14891   g_return_if_fail (entry == NULL || GTK_IS_ENTRY (entry));
14892
14893   if (tree_view->priv->search_custom_entry_set)
14894     {
14895       if (tree_view->priv->search_entry_changed_id)
14896         {
14897           g_signal_handler_disconnect (tree_view->priv->search_entry,
14898                                        tree_view->priv->search_entry_changed_id);
14899           tree_view->priv->search_entry_changed_id = 0;
14900         }
14901       g_signal_handlers_disconnect_by_func (tree_view->priv->search_entry,
14902                                             G_CALLBACK (gtk_tree_view_search_key_press_event),
14903                                             tree_view);
14904
14905       g_object_unref (tree_view->priv->search_entry);
14906     }
14907   else if (tree_view->priv->search_window)
14908     {
14909       gtk_widget_destroy (tree_view->priv->search_window);
14910
14911       tree_view->priv->search_window = NULL;
14912     }
14913
14914   if (entry)
14915     {
14916       tree_view->priv->search_entry = g_object_ref (entry);
14917       tree_view->priv->search_custom_entry_set = TRUE;
14918
14919       if (tree_view->priv->search_entry_changed_id == 0)
14920         {
14921           tree_view->priv->search_entry_changed_id =
14922             g_signal_connect (tree_view->priv->search_entry, "changed",
14923                               G_CALLBACK (gtk_tree_view_search_init),
14924                               tree_view);
14925         }
14926
14927         g_signal_connect (tree_view->priv->search_entry, "key-press-event",
14928                           G_CALLBACK (gtk_tree_view_search_key_press_event),
14929                           tree_view);
14930
14931         gtk_tree_view_search_init (tree_view->priv->search_entry, tree_view);
14932     }
14933   else
14934     {
14935       tree_view->priv->search_entry = NULL;
14936       tree_view->priv->search_custom_entry_set = FALSE;
14937     }
14938 }
14939
14940 /**
14941  * gtk_tree_view_set_search_position_func:
14942  * @tree_view: A #GtkTreeView
14943  * @func: (allow-none): the function to use to position the search dialog, or %NULL
14944  *    to use the default search position function
14945  * @data: (allow-none): user data to pass to @func, or %NULL
14946  * @destroy: (allow-none): Destroy notifier for @data, or %NULL
14947  *
14948  * Sets the function to use when positioning the search dialog.
14949  *
14950  * Since: 2.10
14951  **/
14952 void
14953 gtk_tree_view_set_search_position_func (GtkTreeView                   *tree_view,
14954                                         GtkTreeViewSearchPositionFunc  func,
14955                                         gpointer                       user_data,
14956                                         GDestroyNotify                 destroy)
14957 {
14958   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14959
14960   if (tree_view->priv->search_position_destroy)
14961     tree_view->priv->search_position_destroy (tree_view->priv->search_position_user_data);
14962
14963   tree_view->priv->search_position_func = func;
14964   tree_view->priv->search_position_user_data = user_data;
14965   tree_view->priv->search_position_destroy = destroy;
14966   if (tree_view->priv->search_position_func == NULL)
14967     tree_view->priv->search_position_func = gtk_tree_view_search_position_func;
14968 }
14969
14970 /**
14971  * gtk_tree_view_get_search_position_func: (skip)
14972  * @tree_view: A #GtkTreeView
14973  *
14974  * Returns the positioning function currently in use.
14975  *
14976  * Return value: the currently used function for positioning the search dialog.
14977  *
14978  * Since: 2.10
14979  */
14980 GtkTreeViewSearchPositionFunc
14981 gtk_tree_view_get_search_position_func (GtkTreeView *tree_view)
14982 {
14983   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
14984
14985   return tree_view->priv->search_position_func;
14986 }
14987
14988
14989 static void
14990 gtk_tree_view_search_dialog_hide (GtkWidget   *search_dialog,
14991                                   GtkTreeView *tree_view,
14992                                   GdkDevice   *device)
14993 {
14994   if (tree_view->priv->disable_popdown)
14995     return;
14996
14997   if (tree_view->priv->search_entry_changed_id)
14998     {
14999       g_signal_handler_disconnect (tree_view->priv->search_entry,
15000                                    tree_view->priv->search_entry_changed_id);
15001       tree_view->priv->search_entry_changed_id = 0;
15002     }
15003   if (tree_view->priv->typeselect_flush_timeout)
15004     {
15005       g_source_remove (tree_view->priv->typeselect_flush_timeout);
15006       tree_view->priv->typeselect_flush_timeout = 0;
15007     }
15008
15009   if (gtk_widget_get_visible (search_dialog))
15010     {
15011       /* send focus-in event */
15012       send_focus_change (GTK_WIDGET (tree_view->priv->search_entry), device, FALSE);
15013       gtk_widget_hide (search_dialog);
15014       gtk_entry_set_text (GTK_ENTRY (tree_view->priv->search_entry), "");
15015       send_focus_change (GTK_WIDGET (tree_view), device, TRUE);
15016     }
15017 }
15018
15019 static void
15020 gtk_tree_view_search_position_func (GtkTreeView *tree_view,
15021                                     GtkWidget   *search_dialog,
15022                                     gpointer     user_data)
15023 {
15024   gint x, y;
15025   gint tree_x, tree_y;
15026   gint tree_width, tree_height;
15027   GdkWindow *tree_window = gtk_widget_get_window (GTK_WIDGET (tree_view));
15028   GdkScreen *screen = gdk_window_get_screen (tree_window);
15029   GtkRequisition requisition;
15030   gint monitor_num;
15031   GdkRectangle monitor;
15032
15033   monitor_num = gdk_screen_get_monitor_at_window (screen, tree_window);
15034   gdk_screen_get_monitor_geometry (screen, monitor_num, &monitor);
15035
15036   gtk_widget_realize (search_dialog);
15037
15038   gdk_window_get_origin (tree_window, &tree_x, &tree_y);
15039   tree_width = gdk_window_get_width (tree_window);
15040   tree_height = gdk_window_get_height (tree_window);
15041   gtk_widget_get_preferred_size (search_dialog, &requisition, NULL);
15042
15043   if (tree_x + tree_width > gdk_screen_get_width (screen))
15044     x = gdk_screen_get_width (screen) - requisition.width;
15045   else if (tree_x + tree_width - requisition.width < 0)
15046     x = 0;
15047   else
15048     x = tree_x + tree_width - requisition.width;
15049
15050   if (tree_y + tree_height + requisition.height > gdk_screen_get_height (screen))
15051     y = gdk_screen_get_height (screen) - requisition.height;
15052   else if (tree_y + tree_height < 0) /* isn't really possible ... */
15053     y = 0;
15054   else
15055     y = tree_y + tree_height;
15056
15057   gtk_window_move (GTK_WINDOW (search_dialog), x, y);
15058 }
15059
15060 static void
15061 gtk_tree_view_search_disable_popdown (GtkEntry *entry,
15062                                       GtkMenu  *menu,
15063                                       gpointer  data)
15064 {
15065   GtkTreeView *tree_view = (GtkTreeView *)data;
15066
15067   tree_view->priv->disable_popdown = 1;
15068   g_signal_connect (menu, "hide",
15069                     G_CALLBACK (gtk_tree_view_search_enable_popdown), data);
15070 }
15071
15072 /* Because we're visible but offscreen, we just set a flag in the preedit
15073  * callback.
15074  */
15075 static void
15076 gtk_tree_view_search_preedit_changed (GtkIMContext *im_context,
15077                                       GtkTreeView  *tree_view)
15078 {
15079   tree_view->priv->imcontext_changed = 1;
15080   if (tree_view->priv->typeselect_flush_timeout)
15081     {
15082       g_source_remove (tree_view->priv->typeselect_flush_timeout);
15083       tree_view->priv->typeselect_flush_timeout =
15084         gdk_threads_add_timeout (GTK_TREE_VIEW_SEARCH_DIALOG_TIMEOUT,
15085                        (GSourceFunc) gtk_tree_view_search_entry_flush_timeout,
15086                        tree_view);
15087     }
15088
15089 }
15090
15091 static void
15092 gtk_tree_view_search_activate (GtkEntry    *entry,
15093                                GtkTreeView *tree_view)
15094 {
15095   GtkTreePath *path;
15096   GtkRBNode *node;
15097   GtkRBTree *tree;
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 (gtk_tree_row_reference_valid (tree_view->priv->cursor))
15106     {
15107       path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
15108
15109       _gtk_tree_view_find_node (tree_view, path, &tree, &node);
15110
15111       if (node && GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
15112         gtk_tree_view_row_activated (tree_view, path, tree_view->priv->focus_column);
15113
15114       gtk_tree_path_free (path);
15115     }
15116 }
15117
15118 static gboolean
15119 gtk_tree_view_real_search_enable_popdown (gpointer data)
15120 {
15121   GtkTreeView *tree_view = (GtkTreeView *)data;
15122
15123   tree_view->priv->disable_popdown = 0;
15124
15125   return FALSE;
15126 }
15127
15128 static void
15129 gtk_tree_view_search_enable_popdown (GtkWidget *widget,
15130                                      gpointer   data)
15131 {
15132   gdk_threads_add_timeout_full (G_PRIORITY_HIGH, 200, gtk_tree_view_real_search_enable_popdown, g_object_ref (data), g_object_unref);
15133 }
15134
15135 static gboolean
15136 gtk_tree_view_search_delete_event (GtkWidget *widget,
15137                                    GdkEventAny *event,
15138                                    GtkTreeView *tree_view)
15139 {
15140   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
15141
15142   gtk_tree_view_search_dialog_hide (widget, tree_view, NULL);
15143
15144   return TRUE;
15145 }
15146
15147 static gboolean
15148 gtk_tree_view_search_button_press_event (GtkWidget *widget,
15149                                          GdkEventButton *event,
15150                                          GtkTreeView *tree_view)
15151 {
15152   GdkDevice *keyb_device;
15153
15154   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
15155
15156   keyb_device = gdk_device_get_associated_device (event->device);
15157   gtk_tree_view_search_dialog_hide (widget, tree_view, keyb_device);
15158
15159   if (event->window == tree_view->priv->bin_window)
15160     gtk_tree_view_button_press (GTK_WIDGET (tree_view), event);
15161
15162   return TRUE;
15163 }
15164
15165 static gboolean
15166 gtk_tree_view_search_scroll_event (GtkWidget *widget,
15167                                    GdkEventScroll *event,
15168                                    GtkTreeView *tree_view)
15169 {
15170   gboolean retval = FALSE;
15171
15172   if (event->direction == GDK_SCROLL_UP)
15173     {
15174       gtk_tree_view_search_move (widget, tree_view, TRUE);
15175       retval = TRUE;
15176     }
15177   else if (event->direction == GDK_SCROLL_DOWN)
15178     {
15179       gtk_tree_view_search_move (widget, tree_view, FALSE);
15180       retval = TRUE;
15181     }
15182
15183   /* renew the flush timeout */
15184   if (retval && tree_view->priv->typeselect_flush_timeout
15185       && !tree_view->priv->search_custom_entry_set)
15186     {
15187       g_source_remove (tree_view->priv->typeselect_flush_timeout);
15188       tree_view->priv->typeselect_flush_timeout =
15189         gdk_threads_add_timeout (GTK_TREE_VIEW_SEARCH_DIALOG_TIMEOUT,
15190                        (GSourceFunc) gtk_tree_view_search_entry_flush_timeout,
15191                        tree_view);
15192     }
15193
15194   return retval;
15195 }
15196
15197 static gboolean
15198 gtk_tree_view_search_key_press_event (GtkWidget *widget,
15199                                       GdkEventKey *event,
15200                                       GtkTreeView *tree_view)
15201 {
15202   GdkModifierType default_accel;
15203   gboolean        retval = FALSE;
15204
15205   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
15206   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
15207
15208   /* close window and cancel the search */
15209   if (!tree_view->priv->search_custom_entry_set
15210       && (event->keyval == GDK_KEY_Escape ||
15211           event->keyval == GDK_KEY_Tab ||
15212             event->keyval == GDK_KEY_KP_Tab ||
15213             event->keyval == GDK_KEY_ISO_Left_Tab))
15214     {
15215       gtk_tree_view_search_dialog_hide (widget, tree_view,
15216                                         gdk_event_get_device ((GdkEvent *) event));
15217       return TRUE;
15218     }
15219
15220   default_accel = gtk_widget_get_modifier_mask (widget,
15221                                                 GDK_MODIFIER_INTENT_PRIMARY_ACCELERATOR);
15222
15223   /* select previous matching iter */
15224   if (event->keyval == GDK_KEY_Up || event->keyval == GDK_KEY_KP_Up)
15225     {
15226       if (!gtk_tree_view_search_move (widget, tree_view, TRUE))
15227         gtk_widget_error_bell (widget);
15228
15229       retval = TRUE;
15230     }
15231
15232   if (((event->state & (default_accel | GDK_SHIFT_MASK)) == (default_accel | GDK_SHIFT_MASK))
15233       && (event->keyval == GDK_KEY_g || event->keyval == GDK_KEY_G))
15234     {
15235       if (!gtk_tree_view_search_move (widget, tree_view, TRUE))
15236         gtk_widget_error_bell (widget);
15237
15238       retval = TRUE;
15239     }
15240
15241   /* select next matching iter */
15242   if (event->keyval == GDK_KEY_Down || event->keyval == GDK_KEY_KP_Down)
15243     {
15244       if (!gtk_tree_view_search_move (widget, tree_view, FALSE))
15245         gtk_widget_error_bell (widget);
15246
15247       retval = TRUE;
15248     }
15249
15250   if (((event->state & (default_accel | GDK_SHIFT_MASK)) == default_accel)
15251       && (event->keyval == GDK_KEY_g || event->keyval == GDK_KEY_G))
15252     {
15253       if (!gtk_tree_view_search_move (widget, tree_view, FALSE))
15254         gtk_widget_error_bell (widget);
15255
15256       retval = TRUE;
15257     }
15258
15259   /* renew the flush timeout */
15260   if (retval && tree_view->priv->typeselect_flush_timeout
15261       && !tree_view->priv->search_custom_entry_set)
15262     {
15263       g_source_remove (tree_view->priv->typeselect_flush_timeout);
15264       tree_view->priv->typeselect_flush_timeout =
15265         gdk_threads_add_timeout (GTK_TREE_VIEW_SEARCH_DIALOG_TIMEOUT,
15266                        (GSourceFunc) gtk_tree_view_search_entry_flush_timeout,
15267                        tree_view);
15268     }
15269
15270   return retval;
15271 }
15272
15273 /*  this function returns FALSE if there is a search string but
15274  *  nothing was found, and TRUE otherwise.
15275  */
15276 static gboolean
15277 gtk_tree_view_search_move (GtkWidget   *window,
15278                            GtkTreeView *tree_view,
15279                            gboolean     up)
15280 {
15281   gboolean ret;
15282   gint len;
15283   gint count = 0;
15284   const gchar *text;
15285   GtkTreeIter iter;
15286   GtkTreeModel *model;
15287   GtkTreeSelection *selection;
15288
15289   text = gtk_entry_get_text (GTK_ENTRY (tree_view->priv->search_entry));
15290
15291   g_return_val_if_fail (text != NULL, FALSE);
15292
15293   len = strlen (text);
15294
15295   if (up && tree_view->priv->selected_iter == 1)
15296     return strlen (text) < 1;
15297
15298   len = strlen (text);
15299
15300   if (len < 1)
15301     return TRUE;
15302
15303   model = gtk_tree_view_get_model (tree_view);
15304   selection = gtk_tree_view_get_selection (tree_view);
15305
15306   /* search */
15307   gtk_tree_selection_unselect_all (selection);
15308   if (!gtk_tree_model_get_iter_first (model, &iter))
15309     return TRUE;
15310
15311   ret = gtk_tree_view_search_iter (model, selection, &iter, text,
15312                                    &count, up?((tree_view->priv->selected_iter) - 1):((tree_view->priv->selected_iter + 1)));
15313
15314   if (ret)
15315     {
15316       /* found */
15317       tree_view->priv->selected_iter += up?(-1):(1);
15318       return TRUE;
15319     }
15320   else
15321     {
15322       /* return to old iter */
15323       count = 0;
15324       gtk_tree_model_get_iter_first (model, &iter);
15325       gtk_tree_view_search_iter (model, selection,
15326                                  &iter, text,
15327                                  &count, tree_view->priv->selected_iter);
15328       return FALSE;
15329     }
15330 }
15331
15332 static gboolean
15333 gtk_tree_view_search_equal_func (GtkTreeModel *model,
15334                                  gint          column,
15335                                  const gchar  *key,
15336                                  GtkTreeIter  *iter,
15337                                  gpointer      search_data)
15338 {
15339   gboolean retval = TRUE;
15340   const gchar *str;
15341   gchar *normalized_string;
15342   gchar *normalized_key;
15343   gchar *case_normalized_string = NULL;
15344   gchar *case_normalized_key = NULL;
15345   GValue value = G_VALUE_INIT;
15346   GValue transformed = G_VALUE_INIT;
15347
15348   gtk_tree_model_get_value (model, iter, column, &value);
15349
15350   g_value_init (&transformed, G_TYPE_STRING);
15351
15352   if (!g_value_transform (&value, &transformed))
15353     {
15354       g_value_unset (&value);
15355       return TRUE;
15356     }
15357
15358   g_value_unset (&value);
15359
15360   str = g_value_get_string (&transformed);
15361   if (!str)
15362     {
15363       g_value_unset (&transformed);
15364       return TRUE;
15365     }
15366
15367   normalized_string = g_utf8_normalize (str, -1, G_NORMALIZE_ALL);
15368   normalized_key = g_utf8_normalize (key, -1, G_NORMALIZE_ALL);
15369
15370   if (normalized_string && normalized_key)
15371     {
15372       case_normalized_string = g_utf8_casefold (normalized_string, -1);
15373       case_normalized_key = g_utf8_casefold (normalized_key, -1);
15374
15375       if (strncmp (case_normalized_key, case_normalized_string, strlen (case_normalized_key)) == 0)
15376         retval = FALSE;
15377     }
15378
15379   g_value_unset (&transformed);
15380   g_free (normalized_key);
15381   g_free (normalized_string);
15382   g_free (case_normalized_key);
15383   g_free (case_normalized_string);
15384
15385   return retval;
15386 }
15387
15388 static gboolean
15389 gtk_tree_view_search_iter (GtkTreeModel     *model,
15390                            GtkTreeSelection *selection,
15391                            GtkTreeIter      *iter,
15392                            const gchar      *text,
15393                            gint             *count,
15394                            gint              n)
15395 {
15396   GtkRBTree *tree = NULL;
15397   GtkRBNode *node = NULL;
15398   GtkTreePath *path;
15399
15400   GtkTreeView *tree_view = gtk_tree_selection_get_tree_view (selection);
15401
15402   path = gtk_tree_model_get_path (model, iter);
15403   _gtk_tree_view_find_node (tree_view, path, &tree, &node);
15404
15405   do
15406     {
15407       if (! tree_view->priv->search_equal_func (model, tree_view->priv->search_column, text, iter, tree_view->priv->search_user_data))
15408         {
15409           (*count)++;
15410           if (*count == n)
15411             {
15412               gtk_tree_view_scroll_to_cell (tree_view, path, NULL,
15413                                             TRUE, 0.5, 0.0);
15414               gtk_tree_selection_select_iter (selection, iter);
15415               gtk_tree_view_real_set_cursor (tree_view, path, FALSE, TRUE);
15416
15417               if (path)
15418                 gtk_tree_path_free (path);
15419
15420               return TRUE;
15421             }
15422         }
15423
15424       if (node->children)
15425         {
15426           gboolean has_child;
15427           GtkTreeIter tmp;
15428
15429           tree = node->children;
15430           node = _gtk_rbtree_first (tree);
15431
15432           tmp = *iter;
15433           has_child = gtk_tree_model_iter_children (model, iter, &tmp);
15434           gtk_tree_path_down (path);
15435
15436           /* sanity check */
15437           TREE_VIEW_INTERNAL_ASSERT (has_child, FALSE);
15438         }
15439       else
15440         {
15441           gboolean done = FALSE;
15442
15443           do
15444             {
15445               node = _gtk_rbtree_next (tree, node);
15446
15447               if (node)
15448                 {
15449                   gboolean has_next;
15450
15451                   has_next = gtk_tree_model_iter_next (model, iter);
15452
15453                   done = TRUE;
15454                   gtk_tree_path_next (path);
15455
15456                   /* sanity check */
15457                   TREE_VIEW_INTERNAL_ASSERT (has_next, FALSE);
15458                 }
15459               else
15460                 {
15461                   gboolean has_parent;
15462                   GtkTreeIter tmp_iter = *iter;
15463
15464                   node = tree->parent_node;
15465                   tree = tree->parent_tree;
15466
15467                   if (!tree)
15468                     {
15469                       if (path)
15470                         gtk_tree_path_free (path);
15471
15472                       /* we've run out of tree, done with this func */
15473                       return FALSE;
15474                     }
15475
15476                   has_parent = gtk_tree_model_iter_parent (model,
15477                                                            iter,
15478                                                            &tmp_iter);
15479                   gtk_tree_path_up (path);
15480
15481                   /* sanity check */
15482                   TREE_VIEW_INTERNAL_ASSERT (has_parent, FALSE);
15483                 }
15484             }
15485           while (!done);
15486         }
15487     }
15488   while (1);
15489
15490   return FALSE;
15491 }
15492
15493 static void
15494 gtk_tree_view_search_init (GtkWidget   *entry,
15495                            GtkTreeView *tree_view)
15496 {
15497   gint ret;
15498   gint count = 0;
15499   const gchar *text;
15500   GtkTreeIter iter;
15501   GtkTreeModel *model;
15502   GtkTreeSelection *selection;
15503
15504   g_return_if_fail (GTK_IS_ENTRY (entry));
15505   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
15506
15507   text = gtk_entry_get_text (GTK_ENTRY (entry));
15508
15509   model = gtk_tree_view_get_model (tree_view);
15510   selection = gtk_tree_view_get_selection (tree_view);
15511
15512   /* search */
15513   gtk_tree_selection_unselect_all (selection);
15514   if (tree_view->priv->typeselect_flush_timeout
15515       && !tree_view->priv->search_custom_entry_set)
15516     {
15517       g_source_remove (tree_view->priv->typeselect_flush_timeout);
15518       tree_view->priv->typeselect_flush_timeout =
15519         gdk_threads_add_timeout (GTK_TREE_VIEW_SEARCH_DIALOG_TIMEOUT,
15520                        (GSourceFunc) gtk_tree_view_search_entry_flush_timeout,
15521                        tree_view);
15522     }
15523
15524   if (*text == '\0')
15525     return;
15526
15527   if (!gtk_tree_model_get_iter_first (model, &iter))
15528     return;
15529
15530   ret = gtk_tree_view_search_iter (model, selection,
15531                                    &iter, text,
15532                                    &count, 1);
15533
15534   if (ret)
15535     tree_view->priv->selected_iter = 1;
15536 }
15537
15538 void
15539 _gtk_tree_view_remove_editable (GtkTreeView       *tree_view,
15540                                 GtkTreeViewColumn *column,
15541                                 GtkCellEditable   *cell_editable)
15542 {
15543   if (tree_view->priv->edited_column == NULL)
15544     return;
15545
15546   g_return_if_fail (column == tree_view->priv->edited_column);
15547
15548   tree_view->priv->edited_column = NULL;
15549
15550   if (gtk_widget_has_focus (GTK_WIDGET (cell_editable)))
15551     gtk_widget_grab_focus (GTK_WIDGET (tree_view));
15552
15553   gtk_container_remove (GTK_CONTAINER (tree_view),
15554                         GTK_WIDGET (cell_editable));
15555
15556   /* FIXME should only redraw a single node */
15557   gtk_widget_queue_draw (GTK_WIDGET (tree_view));
15558 }
15559
15560 static gboolean
15561 gtk_tree_view_start_editing (GtkTreeView *tree_view,
15562                              GtkTreePath *cursor_path,
15563                              gboolean     edit_only)
15564 {
15565   GtkTreeIter iter;
15566   GdkRectangle cell_area;
15567   GtkTreeViewColumn *focus_column;
15568   guint flags = 0; /* can be 0, as the flags are primarily for rendering */
15569   gint retval = FALSE;
15570   GtkRBTree *cursor_tree;
15571   GtkRBNode *cursor_node;
15572
15573   g_assert (tree_view->priv->focus_column);
15574   focus_column = tree_view->priv->focus_column;
15575
15576   if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
15577     return FALSE;
15578
15579   if (_gtk_tree_view_find_node (tree_view, cursor_path, &cursor_tree, &cursor_node) ||
15580       cursor_node == NULL)
15581     return FALSE;
15582
15583   gtk_tree_model_get_iter (tree_view->priv->model, &iter, cursor_path);
15584
15585   validate_row (tree_view, cursor_tree, cursor_node, &iter, cursor_path);
15586
15587   gtk_tree_view_column_cell_set_cell_data (focus_column,
15588                                            tree_view->priv->model,
15589                                            &iter,
15590                                            GTK_RBNODE_FLAG_SET (cursor_node, GTK_RBNODE_IS_PARENT),
15591                                            cursor_node->children ? TRUE : FALSE);
15592   gtk_tree_view_get_cell_area (tree_view,
15593                                cursor_path,
15594                                focus_column,
15595                                &cell_area);
15596
15597   if (gtk_cell_area_activate (gtk_cell_layout_get_area (GTK_CELL_LAYOUT (focus_column)),
15598                               _gtk_tree_view_column_get_context (focus_column),
15599                               GTK_WIDGET (tree_view),
15600                               &cell_area,
15601                               flags, edit_only))
15602     retval = TRUE;
15603
15604   return retval;
15605 }
15606
15607 void
15608 _gtk_tree_view_add_editable (GtkTreeView       *tree_view,
15609                              GtkTreeViewColumn *column,
15610                              GtkTreePath       *path,
15611                              GtkCellEditable   *cell_editable,
15612                              GdkRectangle      *cell_area)
15613 {
15614   gint pre_val = gtk_adjustment_get_value (tree_view->priv->vadjustment);
15615   GtkRequisition requisition;
15616
15617   tree_view->priv->edited_column = column;
15618
15619   gtk_tree_view_real_set_cursor (tree_view, path, FALSE, TRUE);
15620   cell_area->y += pre_val - (int)gtk_adjustment_get_value (tree_view->priv->vadjustment);
15621
15622   gtk_widget_get_preferred_size (GTK_WIDGET (cell_editable),
15623                                  &requisition, NULL);
15624
15625   tree_view->priv->draw_keyfocus = TRUE;
15626
15627   if (requisition.height < cell_area->height)
15628     {
15629       gint diff = cell_area->height - requisition.height;
15630       gtk_tree_view_put (tree_view,
15631                          GTK_WIDGET (cell_editable),
15632                          cell_area->x, cell_area->y + diff/2,
15633                          cell_area->width, requisition.height);
15634     }
15635   else
15636     {
15637       gtk_tree_view_put (tree_view,
15638                          GTK_WIDGET (cell_editable),
15639                          cell_area->x, cell_area->y,
15640                          cell_area->width, cell_area->height);
15641     }
15642 }
15643
15644 static void
15645 gtk_tree_view_stop_editing (GtkTreeView *tree_view,
15646                             gboolean     cancel_editing)
15647 {
15648   GtkTreeViewColumn *column;
15649
15650   if (tree_view->priv->edited_column == NULL)
15651     return;
15652
15653   /*
15654    * This is very evil. We need to do this, because
15655    * gtk_cell_editable_editing_done may trigger gtk_tree_view_row_changed
15656    * later on. If gtk_tree_view_row_changed notices
15657    * tree_view->priv->edited_column != NULL, it'll call
15658    * gtk_tree_view_stop_editing again. Bad things will happen then.
15659    *
15660    * Please read that again if you intend to modify anything here.
15661    */
15662
15663   column = tree_view->priv->edited_column;
15664   gtk_cell_area_stop_editing (gtk_cell_layout_get_area (GTK_CELL_LAYOUT (column)), cancel_editing);
15665   tree_view->priv->edited_column = NULL;
15666 }
15667
15668
15669 /**
15670  * gtk_tree_view_set_hover_selection:
15671  * @tree_view: a #GtkTreeView
15672  * @hover: %TRUE to enable hover selection mode
15673  *
15674  * Enables or disables the hover selection mode of @tree_view.
15675  * Hover selection makes the selected row follow the pointer.
15676  * Currently, this works only for the selection modes
15677  * %GTK_SELECTION_SINGLE and %GTK_SELECTION_BROWSE.
15678  *
15679  * Since: 2.6
15680  **/
15681 void
15682 gtk_tree_view_set_hover_selection (GtkTreeView *tree_view,
15683                                    gboolean     hover)
15684 {
15685   hover = hover != FALSE;
15686
15687   if (hover != tree_view->priv->hover_selection)
15688     {
15689       tree_view->priv->hover_selection = hover;
15690
15691       g_object_notify (G_OBJECT (tree_view), "hover-selection");
15692     }
15693 }
15694
15695 /**
15696  * gtk_tree_view_get_hover_selection:
15697  * @tree_view: a #GtkTreeView
15698  *
15699  * Returns whether hover selection mode is turned on for @tree_view.
15700  *
15701  * Return value: %TRUE if @tree_view is in hover selection mode
15702  *
15703  * Since: 2.6
15704  **/
15705 gboolean
15706 gtk_tree_view_get_hover_selection (GtkTreeView *tree_view)
15707 {
15708   return tree_view->priv->hover_selection;
15709 }
15710
15711 /**
15712  * gtk_tree_view_set_hover_expand:
15713  * @tree_view: a #GtkTreeView
15714  * @expand: %TRUE to enable hover selection mode
15715  *
15716  * Enables of disables the hover expansion mode of @tree_view.
15717  * Hover expansion makes rows expand or collapse if the pointer
15718  * moves over them.
15719  *
15720  * Since: 2.6
15721  **/
15722 void
15723 gtk_tree_view_set_hover_expand (GtkTreeView *tree_view,
15724                                 gboolean     expand)
15725 {
15726   expand = expand != FALSE;
15727
15728   if (expand != tree_view->priv->hover_expand)
15729     {
15730       tree_view->priv->hover_expand = expand;
15731
15732       g_object_notify (G_OBJECT (tree_view), "hover-expand");
15733     }
15734 }
15735
15736 /**
15737  * gtk_tree_view_get_hover_expand:
15738  * @tree_view: a #GtkTreeView
15739  *
15740  * Returns whether hover expansion mode is turned on for @tree_view.
15741  *
15742  * Return value: %TRUE if @tree_view is in hover expansion mode
15743  *
15744  * Since: 2.6
15745  **/
15746 gboolean
15747 gtk_tree_view_get_hover_expand (GtkTreeView *tree_view)
15748 {
15749   return tree_view->priv->hover_expand;
15750 }
15751
15752 /**
15753  * gtk_tree_view_set_rubber_banding:
15754  * @tree_view: a #GtkTreeView
15755  * @enable: %TRUE to enable rubber banding
15756  *
15757  * Enables or disables rubber banding in @tree_view.  If the selection mode
15758  * is #GTK_SELECTION_MULTIPLE, rubber banding will allow the user to select
15759  * multiple rows by dragging the mouse.
15760  *
15761  * Since: 2.10
15762  **/
15763 void
15764 gtk_tree_view_set_rubber_banding (GtkTreeView *tree_view,
15765                                   gboolean     enable)
15766 {
15767   enable = enable != FALSE;
15768
15769   if (enable != tree_view->priv->rubber_banding_enable)
15770     {
15771       tree_view->priv->rubber_banding_enable = enable;
15772
15773       g_object_notify (G_OBJECT (tree_view), "rubber-banding");
15774     }
15775 }
15776
15777 /**
15778  * gtk_tree_view_get_rubber_banding:
15779  * @tree_view: a #GtkTreeView
15780  *
15781  * Returns whether rubber banding is turned on for @tree_view.  If the
15782  * selection mode is #GTK_SELECTION_MULTIPLE, rubber banding will allow the
15783  * user to select multiple rows by dragging the mouse.
15784  *
15785  * Return value: %TRUE if rubber banding in @tree_view is enabled.
15786  *
15787  * Since: 2.10
15788  **/
15789 gboolean
15790 gtk_tree_view_get_rubber_banding (GtkTreeView *tree_view)
15791 {
15792   return tree_view->priv->rubber_banding_enable;
15793 }
15794
15795 /**
15796  * gtk_tree_view_is_rubber_banding_active:
15797  * @tree_view: a #GtkTreeView
15798  *
15799  * Returns whether a rubber banding operation is currently being done
15800  * in @tree_view.
15801  *
15802  * Return value: %TRUE if a rubber banding operation is currently being
15803  * done in @tree_view.
15804  *
15805  * Since: 2.12
15806  **/
15807 gboolean
15808 gtk_tree_view_is_rubber_banding_active (GtkTreeView *tree_view)
15809 {
15810   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
15811
15812   if (tree_view->priv->rubber_banding_enable
15813       && tree_view->priv->rubber_band_status == RUBBER_BAND_ACTIVE)
15814     return TRUE;
15815
15816   return FALSE;
15817 }
15818
15819 /**
15820  * gtk_tree_view_get_row_separator_func: (skip)
15821  * @tree_view: a #GtkTreeView
15822  *
15823  * Returns the current row separator function.
15824  *
15825  * Return value: the current row separator function.
15826  *
15827  * Since: 2.6
15828  **/
15829 GtkTreeViewRowSeparatorFunc
15830 gtk_tree_view_get_row_separator_func (GtkTreeView *tree_view)
15831 {
15832   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
15833
15834   return tree_view->priv->row_separator_func;
15835 }
15836
15837 /**
15838  * gtk_tree_view_set_row_separator_func:
15839  * @tree_view: a #GtkTreeView
15840  * @func: (allow-none): a #GtkTreeViewRowSeparatorFunc
15841  * @data: (allow-none): user data to pass to @func, or %NULL
15842  * @destroy: (allow-none): destroy notifier for @data, or %NULL
15843  *
15844  * Sets the row separator function, which is used to determine
15845  * whether a row should be drawn as a separator. If the row separator
15846  * function is %NULL, no separators are drawn. This is the default value.
15847  *
15848  * Since: 2.6
15849  **/
15850 void
15851 gtk_tree_view_set_row_separator_func (GtkTreeView                 *tree_view,
15852                                       GtkTreeViewRowSeparatorFunc  func,
15853                                       gpointer                     data,
15854                                       GDestroyNotify               destroy)
15855 {
15856   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
15857
15858   if (tree_view->priv->row_separator_destroy)
15859     tree_view->priv->row_separator_destroy (tree_view->priv->row_separator_data);
15860
15861   tree_view->priv->row_separator_func = func;
15862   tree_view->priv->row_separator_data = data;
15863   tree_view->priv->row_separator_destroy = destroy;
15864
15865   /* Have the tree recalculate heights */
15866   _gtk_rbtree_mark_invalid (tree_view->priv->tree);
15867   gtk_widget_queue_resize (GTK_WIDGET (tree_view));
15868 }
15869
15870
15871 static void
15872 gtk_tree_view_grab_notify (GtkWidget *widget,
15873                            gboolean   was_grabbed)
15874 {
15875   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
15876
15877   tree_view->priv->in_grab = !was_grabbed;
15878
15879   if (!was_grabbed)
15880     {
15881       tree_view->priv->pressed_button = -1;
15882
15883       if (tree_view->priv->rubber_band_status)
15884         gtk_tree_view_stop_rubber_band (tree_view);
15885     }
15886 }
15887
15888 static void
15889 gtk_tree_view_state_flags_changed (GtkWidget     *widget,
15890                                    GtkStateFlags  previous_state)
15891 {
15892   if (gtk_widget_get_realized (widget))
15893     gtk_tree_view_ensure_background (GTK_TREE_VIEW (widget));
15894
15895   gtk_widget_queue_draw (widget);
15896 }
15897
15898 /**
15899  * gtk_tree_view_get_grid_lines:
15900  * @tree_view: a #GtkTreeView
15901  *
15902  * Returns which grid lines are enabled in @tree_view.
15903  *
15904  * Return value: a #GtkTreeViewGridLines value indicating which grid lines
15905  * are enabled.
15906  *
15907  * Since: 2.10
15908  */
15909 GtkTreeViewGridLines
15910 gtk_tree_view_get_grid_lines (GtkTreeView *tree_view)
15911 {
15912   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), 0);
15913
15914   return tree_view->priv->grid_lines;
15915 }
15916
15917 /**
15918  * gtk_tree_view_set_grid_lines:
15919  * @tree_view: a #GtkTreeView
15920  * @grid_lines: a #GtkTreeViewGridLines value indicating which grid lines to
15921  * enable.
15922  *
15923  * Sets which grid lines to draw in @tree_view.
15924  *
15925  * Since: 2.10
15926  */
15927 void
15928 gtk_tree_view_set_grid_lines (GtkTreeView           *tree_view,
15929                               GtkTreeViewGridLines   grid_lines)
15930 {
15931   GtkTreeViewPrivate *priv;
15932   GtkWidget *widget;
15933   GtkTreeViewGridLines old_grid_lines;
15934
15935   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
15936
15937   priv = tree_view->priv;
15938   widget = GTK_WIDGET (tree_view);
15939
15940   old_grid_lines = priv->grid_lines;
15941   priv->grid_lines = grid_lines;
15942
15943   if (gtk_widget_get_realized (widget))
15944     {
15945       if (grid_lines == GTK_TREE_VIEW_GRID_LINES_NONE &&
15946           priv->grid_line_width)
15947         {
15948           priv->grid_line_width = 0;
15949         }
15950
15951       if (grid_lines != GTK_TREE_VIEW_GRID_LINES_NONE &&
15952           !priv->grid_line_width)
15953         {
15954           gint8 *dash_list;
15955
15956           gtk_widget_style_get (widget,
15957                                 "grid-line-width", &priv->grid_line_width,
15958                                 "grid-line-pattern", (gchar *)&dash_list,
15959                                 NULL);
15960
15961           if (dash_list)
15962             {
15963               priv->grid_line_dashes[0] = dash_list[0];
15964               if (dash_list[0])
15965                 priv->grid_line_dashes[1] = dash_list[1];
15966
15967               g_free (dash_list);
15968             }
15969           else
15970             {
15971               priv->grid_line_dashes[0] = 1;
15972               priv->grid_line_dashes[1] = 1;
15973             }
15974         }
15975     }
15976
15977   if (old_grid_lines != grid_lines)
15978     {
15979       gtk_widget_queue_draw (GTK_WIDGET (tree_view));
15980
15981       g_object_notify (G_OBJECT (tree_view), "enable-grid-lines");
15982     }
15983 }
15984
15985 /**
15986  * gtk_tree_view_get_enable_tree_lines:
15987  * @tree_view: a #GtkTreeView.
15988  *
15989  * Returns whether or not tree lines are drawn in @tree_view.
15990  *
15991  * Return value: %TRUE if tree lines are drawn in @tree_view, %FALSE
15992  * otherwise.
15993  *
15994  * Since: 2.10
15995  */
15996 gboolean
15997 gtk_tree_view_get_enable_tree_lines (GtkTreeView *tree_view)
15998 {
15999   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
16000
16001   return tree_view->priv->tree_lines_enabled;
16002 }
16003
16004 /**
16005  * gtk_tree_view_set_enable_tree_lines:
16006  * @tree_view: a #GtkTreeView
16007  * @enabled: %TRUE to enable tree line drawing, %FALSE otherwise.
16008  *
16009  * Sets whether to draw lines interconnecting the expanders in @tree_view.
16010  * This does not have any visible effects for lists.
16011  *
16012  * Since: 2.10
16013  */
16014 void
16015 gtk_tree_view_set_enable_tree_lines (GtkTreeView *tree_view,
16016                                      gboolean     enabled)
16017 {
16018   GtkTreeViewPrivate *priv;
16019   GtkWidget *widget;
16020   gboolean was_enabled;
16021
16022   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
16023
16024   enabled = enabled != FALSE;
16025
16026   priv = tree_view->priv;
16027   widget = GTK_WIDGET (tree_view);
16028
16029   was_enabled = priv->tree_lines_enabled;
16030
16031   priv->tree_lines_enabled = enabled;
16032
16033   if (gtk_widget_get_realized (widget))
16034     {
16035       if (!enabled && priv->tree_line_width)
16036         {
16037           priv->tree_line_width = 0;
16038         }
16039
16040       if (enabled && !priv->tree_line_width)
16041         {
16042           gint8 *dash_list;
16043           gtk_widget_style_get (widget,
16044                                 "tree-line-width", &priv->tree_line_width,
16045                                 "tree-line-pattern", (gchar *)&dash_list,
16046                                 NULL);
16047
16048           if (dash_list)
16049             {
16050               priv->tree_line_dashes[0] = dash_list[0];
16051               if (dash_list[0])
16052                 priv->tree_line_dashes[1] = dash_list[1];
16053
16054               g_free (dash_list);
16055             }
16056           else
16057             {
16058               priv->tree_line_dashes[0] = 1;
16059               priv->tree_line_dashes[1] = 1;
16060             }
16061         }
16062     }
16063
16064   if (was_enabled != enabled)
16065     {
16066       gtk_widget_queue_draw (GTK_WIDGET (tree_view));
16067
16068       g_object_notify (G_OBJECT (tree_view), "enable-tree-lines");
16069     }
16070 }
16071
16072
16073 /**
16074  * gtk_tree_view_set_show_expanders:
16075  * @tree_view: a #GtkTreeView
16076  * @enabled: %TRUE to enable expander drawing, %FALSE otherwise.
16077  *
16078  * Sets whether to draw and enable expanders and indent child rows in
16079  * @tree_view.  When disabled there will be no expanders visible in trees
16080  * and there will be no way to expand and collapse rows by default.  Also
16081  * note that hiding the expanders will disable the default indentation.  You
16082  * can set a custom indentation in this case using
16083  * gtk_tree_view_set_level_indentation().
16084  * This does not have any visible effects for lists.
16085  *
16086  * Since: 2.12
16087  */
16088 void
16089 gtk_tree_view_set_show_expanders (GtkTreeView *tree_view,
16090                                   gboolean     enabled)
16091 {
16092   gboolean was_enabled;
16093
16094   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
16095
16096   enabled = enabled != FALSE;
16097   was_enabled = tree_view->priv->show_expanders;
16098
16099   tree_view->priv->show_expanders = enabled == TRUE;
16100
16101   if (enabled != was_enabled)
16102     gtk_widget_queue_draw (GTK_WIDGET (tree_view));
16103 }
16104
16105 /**
16106  * gtk_tree_view_get_show_expanders:
16107  * @tree_view: a #GtkTreeView.
16108  *
16109  * Returns whether or not expanders are drawn in @tree_view.
16110  *
16111  * Return value: %TRUE if expanders are drawn in @tree_view, %FALSE
16112  * otherwise.
16113  *
16114  * Since: 2.12
16115  */
16116 gboolean
16117 gtk_tree_view_get_show_expanders (GtkTreeView *tree_view)
16118 {
16119   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
16120
16121   return tree_view->priv->show_expanders;
16122 }
16123
16124 /**
16125  * gtk_tree_view_set_level_indentation:
16126  * @tree_view: a #GtkTreeView
16127  * @indentation: the amount, in pixels, of extra indentation in @tree_view.
16128  *
16129  * Sets the amount of extra indentation for child levels to use in @tree_view
16130  * in addition to the default indentation.  The value should be specified in
16131  * pixels, a value of 0 disables this feature and in this case only the default
16132  * indentation will be used.
16133  * This does not have any visible effects for lists.
16134  *
16135  * Since: 2.12
16136  */
16137 void
16138 gtk_tree_view_set_level_indentation (GtkTreeView *tree_view,
16139                                      gint         indentation)
16140 {
16141   tree_view->priv->level_indentation = indentation;
16142
16143   gtk_widget_queue_draw (GTK_WIDGET (tree_view));
16144 }
16145
16146 /**
16147  * gtk_tree_view_get_level_indentation:
16148  * @tree_view: a #GtkTreeView.
16149  *
16150  * Returns the amount, in pixels, of extra indentation for child levels
16151  * in @tree_view.
16152  *
16153  * Return value: the amount of extra indentation for child levels in
16154  * @tree_view.  A return value of 0 means that this feature is disabled.
16155  *
16156  * Since: 2.12
16157  */
16158 gint
16159 gtk_tree_view_get_level_indentation (GtkTreeView *tree_view)
16160 {
16161   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), 0);
16162
16163   return tree_view->priv->level_indentation;
16164 }
16165
16166 /**
16167  * gtk_tree_view_set_tooltip_row:
16168  * @tree_view: a #GtkTreeView
16169  * @tooltip: a #GtkTooltip
16170  * @path: a #GtkTreePath
16171  *
16172  * Sets the tip area of @tooltip to be the area covered by the row at @path.
16173  * See also gtk_tree_view_set_tooltip_column() for a simpler alternative.
16174  * See also gtk_tooltip_set_tip_area().
16175  *
16176  * Since: 2.12
16177  */
16178 void
16179 gtk_tree_view_set_tooltip_row (GtkTreeView *tree_view,
16180                                GtkTooltip  *tooltip,
16181                                GtkTreePath *path)
16182 {
16183   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
16184   g_return_if_fail (GTK_IS_TOOLTIP (tooltip));
16185
16186   gtk_tree_view_set_tooltip_cell (tree_view, tooltip, path, NULL, NULL);
16187 }
16188
16189 /**
16190  * gtk_tree_view_set_tooltip_cell:
16191  * @tree_view: a #GtkTreeView
16192  * @tooltip: a #GtkTooltip
16193  * @path: (allow-none): a #GtkTreePath or %NULL
16194  * @column: (allow-none): a #GtkTreeViewColumn or %NULL
16195  * @cell: (allow-none): a #GtkCellRenderer or %NULL
16196  *
16197  * Sets the tip area of @tooltip to the area @path, @column and @cell have
16198  * in common.  For example if @path is %NULL and @column is set, the tip
16199  * area will be set to the full area covered by @column.  See also
16200  * gtk_tooltip_set_tip_area().
16201  *
16202  * Note that if @path is not specified and @cell is set and part of a column
16203  * containing the expander, the tooltip might not show and hide at the correct
16204  * position.  In such cases @path must be set to the current node under the
16205  * mouse cursor for this function to operate correctly.
16206  *
16207  * See also gtk_tree_view_set_tooltip_column() for a simpler alternative.
16208  *
16209  * Since: 2.12
16210  */
16211 void
16212 gtk_tree_view_set_tooltip_cell (GtkTreeView       *tree_view,
16213                                 GtkTooltip        *tooltip,
16214                                 GtkTreePath       *path,
16215                                 GtkTreeViewColumn *column,
16216                                 GtkCellRenderer   *cell)
16217 {
16218   GtkAllocation allocation;
16219   GdkRectangle rect;
16220
16221   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
16222   g_return_if_fail (GTK_IS_TOOLTIP (tooltip));
16223   g_return_if_fail (column == NULL || GTK_IS_TREE_VIEW_COLUMN (column));
16224   g_return_if_fail (cell == NULL || GTK_IS_CELL_RENDERER (cell));
16225
16226   /* Determine x values. */
16227   if (column && cell)
16228     {
16229       GdkRectangle tmp;
16230       gint start, width;
16231
16232       /* We always pass in path here, whether it is NULL or not.
16233        * For cells in expander columns path must be specified so that
16234        * we can correctly account for the indentation.  This also means
16235        * that the tooltip is constrained vertically by the "Determine y
16236        * values" code below; this is not a real problem since cells actually
16237        * don't stretch vertically in constrast to columns.
16238        */
16239       gtk_tree_view_get_cell_area (tree_view, path, column, &tmp);
16240       gtk_tree_view_column_cell_get_position (column, cell, &start, &width);
16241
16242       gtk_tree_view_convert_bin_window_to_widget_coords (tree_view,
16243                                                          tmp.x + start, 0,
16244                                                          &rect.x, NULL);
16245       rect.width = width;
16246     }
16247   else if (column)
16248     {
16249       GdkRectangle tmp;
16250
16251       gtk_tree_view_get_background_area (tree_view, NULL, column, &tmp);
16252       gtk_tree_view_convert_bin_window_to_widget_coords (tree_view,
16253                                                          tmp.x, 0,
16254                                                          &rect.x, NULL);
16255       rect.width = tmp.width;
16256     }
16257   else
16258     {
16259       gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
16260       rect.x = 0;
16261       rect.width = allocation.width;
16262     }
16263
16264   /* Determine y values. */
16265   if (path)
16266     {
16267       GdkRectangle tmp;
16268
16269       gtk_tree_view_get_background_area (tree_view, path, NULL, &tmp);
16270       gtk_tree_view_convert_bin_window_to_widget_coords (tree_view,
16271                                                          0, tmp.y,
16272                                                          NULL, &rect.y);
16273       rect.height = tmp.height;
16274     }
16275   else
16276     {
16277       rect.y = 0;
16278       rect.height = gtk_adjustment_get_page_size (tree_view->priv->vadjustment);
16279     }
16280
16281   gtk_tooltip_set_tip_area (tooltip, &rect);
16282 }
16283
16284 /**
16285  * gtk_tree_view_get_tooltip_context:
16286  * @tree_view: a #GtkTreeView
16287  * @x: (inout): the x coordinate (relative to widget coordinates)
16288  * @y: (inout): the y coordinate (relative to widget coordinates)
16289  * @keyboard_tip: whether this is a keyboard tooltip or not
16290  * @model: (out) (allow-none) (transfer none): a pointer to receive a
16291  *         #GtkTreeModel or %NULL
16292  * @path: (out) (allow-none): a pointer to receive a #GtkTreePath or %NULL
16293  * @iter: (out) (allow-none): a pointer to receive a #GtkTreeIter or %NULL
16294  *
16295  * This function is supposed to be used in a #GtkWidget::query-tooltip
16296  * signal handler for #GtkTreeView.  The @x, @y and @keyboard_tip values
16297  * which are received in the signal handler, should be passed to this
16298  * function without modification.
16299  *
16300  * The return value indicates whether there is a tree view row at the given
16301  * coordinates (%TRUE) or not (%FALSE) for mouse tooltips.  For keyboard
16302  * tooltips the row returned will be the cursor row.  When %TRUE, then any of
16303  * @model, @path and @iter which have been provided will be set to point to
16304  * that row and the corresponding model.  @x and @y will always be converted
16305  * to be relative to @tree_view's bin_window if @keyboard_tooltip is %FALSE.
16306  *
16307  * Return value: whether or not the given tooltip context points to a row.
16308  *
16309  * Since: 2.12
16310  */
16311 gboolean
16312 gtk_tree_view_get_tooltip_context (GtkTreeView   *tree_view,
16313                                    gint          *x,
16314                                    gint          *y,
16315                                    gboolean       keyboard_tip,
16316                                    GtkTreeModel **model,
16317                                    GtkTreePath  **path,
16318                                    GtkTreeIter   *iter)
16319 {
16320   GtkTreePath *tmppath = NULL;
16321
16322   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
16323   g_return_val_if_fail (x != NULL, FALSE);
16324   g_return_val_if_fail (y != NULL, FALSE);
16325
16326   if (keyboard_tip)
16327     {
16328       gtk_tree_view_get_cursor (tree_view, &tmppath, NULL);
16329
16330       if (!tmppath)
16331         return FALSE;
16332     }
16333   else
16334     {
16335       gtk_tree_view_convert_widget_to_bin_window_coords (tree_view, *x, *y,
16336                                                          x, y);
16337
16338       if (!gtk_tree_view_get_path_at_pos (tree_view, *x, *y,
16339                                           &tmppath, NULL, NULL, NULL))
16340         return FALSE;
16341     }
16342
16343   if (model)
16344     *model = gtk_tree_view_get_model (tree_view);
16345
16346   if (iter)
16347     gtk_tree_model_get_iter (gtk_tree_view_get_model (tree_view),
16348                              iter, tmppath);
16349
16350   if (path)
16351     *path = tmppath;
16352   else
16353     gtk_tree_path_free (tmppath);
16354
16355   return TRUE;
16356 }
16357
16358 static gboolean
16359 gtk_tree_view_set_tooltip_query_cb (GtkWidget  *widget,
16360                                     gint        x,
16361                                     gint        y,
16362                                     gboolean    keyboard_tip,
16363                                     GtkTooltip *tooltip,
16364                                     gpointer    data)
16365 {
16366   GValue value = G_VALUE_INIT;
16367   GValue transformed = G_VALUE_INIT;
16368   GtkTreeIter iter;
16369   GtkTreePath *path;
16370   GtkTreeModel *model;
16371   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
16372
16373   if (!gtk_tree_view_get_tooltip_context (GTK_TREE_VIEW (widget),
16374                                           &x, &y,
16375                                           keyboard_tip,
16376                                           &model, &path, &iter))
16377     return FALSE;
16378
16379   gtk_tree_model_get_value (model, &iter,
16380                             tree_view->priv->tooltip_column, &value);
16381
16382   g_value_init (&transformed, G_TYPE_STRING);
16383
16384   if (!g_value_transform (&value, &transformed))
16385     {
16386       g_value_unset (&value);
16387       gtk_tree_path_free (path);
16388
16389       return FALSE;
16390     }
16391
16392   g_value_unset (&value);
16393
16394   if (!g_value_get_string (&transformed))
16395     {
16396       g_value_unset (&transformed);
16397       gtk_tree_path_free (path);
16398
16399       return FALSE;
16400     }
16401
16402   gtk_tooltip_set_markup (tooltip, g_value_get_string (&transformed));
16403   gtk_tree_view_set_tooltip_row (tree_view, tooltip, path);
16404
16405   gtk_tree_path_free (path);
16406   g_value_unset (&transformed);
16407
16408   return TRUE;
16409 }
16410
16411 /**
16412  * gtk_tree_view_set_tooltip_column:
16413  * @tree_view: a #GtkTreeView
16414  * @column: an integer, which is a valid column number for @tree_view's model
16415  *
16416  * If you only plan to have simple (text-only) tooltips on full rows, you
16417  * can use this function to have #GtkTreeView handle these automatically
16418  * for you. @column should be set to the column in @tree_view's model
16419  * containing the tooltip texts, or -1 to disable this feature.
16420  *
16421  * When enabled, #GtkWidget::has-tooltip will be set to %TRUE and
16422  * @tree_view will connect a #GtkWidget::query-tooltip signal handler.
16423  *
16424  * Note that the signal handler sets the text with gtk_tooltip_set_markup(),
16425  * so &amp;, &lt;, etc have to be escaped in the text.
16426  *
16427  * Since: 2.12
16428  */
16429 void
16430 gtk_tree_view_set_tooltip_column (GtkTreeView *tree_view,
16431                                   gint         column)
16432 {
16433   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
16434
16435   if (column == tree_view->priv->tooltip_column)
16436     return;
16437
16438   if (column == -1)
16439     {
16440       g_signal_handlers_disconnect_by_func (tree_view,
16441                                             gtk_tree_view_set_tooltip_query_cb,
16442                                             NULL);
16443       gtk_widget_set_has_tooltip (GTK_WIDGET (tree_view), FALSE);
16444     }
16445   else
16446     {
16447       if (tree_view->priv->tooltip_column == -1)
16448         {
16449           g_signal_connect (tree_view, "query-tooltip",
16450                             G_CALLBACK (gtk_tree_view_set_tooltip_query_cb), NULL);
16451           gtk_widget_set_has_tooltip (GTK_WIDGET (tree_view), TRUE);
16452         }
16453     }
16454
16455   tree_view->priv->tooltip_column = column;
16456   g_object_notify (G_OBJECT (tree_view), "tooltip-column");
16457 }
16458
16459 /**
16460  * gtk_tree_view_get_tooltip_column:
16461  * @tree_view: a #GtkTreeView
16462  *
16463  * Returns the column of @tree_view's model which is being used for
16464  * displaying tooltips on @tree_view's rows.
16465  *
16466  * Return value: the index of the tooltip column that is currently being
16467  * used, or -1 if this is disabled.
16468  *
16469  * Since: 2.12
16470  */
16471 gint
16472 gtk_tree_view_get_tooltip_column (GtkTreeView *tree_view)
16473 {
16474   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), 0);
16475
16476   return tree_view->priv->tooltip_column;
16477 }