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 "gtktreemodelsort.h"
  43 #include "gtktooltip.h"
  44 #include "gtkscrollable.h"
  45 #include "gtkcelllayout.h"
  46 #include "gtkprivate.h"
  47 #include "gtkwidgetprivate.h"
  48 #include "gtkentryprivate.h"
  49 #include "gtkstylecontextprivate.h"
  50 #include "gtktypebuiltins.h"
  51 #include "a11y/gtktreeviewaccessible.h"
  52
  53
  54 /**
  55  * SECTION:gtktreeview
  56  * @Short_description: A widget for displaying both trees and lists
  57  * @Title: GtkTreeView
  58  * @See_also: #GtkTreeViewColumn, #GtkTreeSelection, #GtkTreeDnd, #GtkTreeMode,
  59  *   #GtkTreeSortable, #GtkTreeModelSort, #GtkListStore, #GtkTreeStore,
  60  *   #GtkCellRenderer, #GtkCellEditable, #GtkCellRendererPixbuf,
  61  *   #GtkCellRendererText, #GtkCellRendererToggle
  62  *
  63  * Widget that displays any object that implements the #GtkTreeModel interface.
  64  *
  65  * Please refer to the <link linkend="TreeWidget">tree widget conceptual
  66  * overview</link> for an overview of all the objects and data types related
  67  * to the tree widget and how they work together.
  68  *
  69  * Several different coordinate systems are exposed in the GtkTreeView API.
  70  * These are:
  71  *
  72  * <inlinegraphic fileref="tree-view-coordinates.png" format="PNG"></inlinegraphic>
  73  * <variablelist><title>Coordinate systems in GtkTreeView API</title>
  74  * <varlistentry><term>Widget coordinates</term>
  75  * <listitem>
  76  * <para>
  77  * Coordinates relative to the widget (usually <literal>widget->window</literal>).
  78  * </para>
  79  * </listitem>
  80  * </varlistentry>
  81  * <varlistentry><term>Bin window coordinates</term>
  82  * <listitem>
  83  * <para>
  84  * Coordinates relative to the window that GtkTreeView renders to.
  85  * </para>
  86  * </listitem>
  87  * </varlistentry>
  88  * <varlistentry><term>Tree coordinates</term>
  89  * <listitem>
  90  * <para>
  91  * Coordinates relative to the entire scrollable area of GtkTreeView. These
  92  * coordinates start at (0, 0) for row 0 of the tree.
  93  * </para>
  94  * </listitem>
  95  * </varlistentry>
  96  * </variablelist>
  97  *
  98  * Several functions are available for converting between the different
  99  * coordinate systems.  The most common translations are between widget and bin
 100  * window coordinates and between bin window and tree coordinates. For the
 101  * former you can use gtk_tree_view_convert_widget_to_bin_window_coords()
 102  * (and vice versa), for the latter gtk_tree_view_convert_bin_window_to_tree_coords()
 103  * (and vice versa).
 104  *
 105  * <refsect2 id="GtkTreeView-BUILDER-UI">
 106  * <title>GtkTreeView as GtkBuildable</title>
 107  * The GtkTreeView implementation of the GtkBuildable interface accepts
 108  * #GtkTreeViewColumn objects as &lt;child&gt; elements and exposes the
 109  * internal #GtkTreeSelection in UI definitions.
 110  * <example>
 111  * <title>A UI definition fragment with GtkTreeView</title>
 112  * <programlisting><![CDATA[
 113  * <object class="GtkTreeView" id="treeview">
 114  *   <property name="model">liststore1</property>
 115  *   <child>
 116  *     <object class="GtkTreeViewColumn" id="test-column">
 117  *       <property name="title">Test</property>
 118  *       <child>
 119  *         <object class="GtkCellRendererText" id="test-renderer"/>
 120  *         <attributes>
 121  *           <attribute name="text">1</attribute>
 122  *         </attributes>
 123  *       </child>
 124  *     </object>
 125  *   </child>
 126  *   <child internal-child="selection">
 127  *     <object class="GtkTreeSelection" id="selection">
 128  *       <signal name="changed" handler="on_treeview_selection_changed"/>
 129  *     </object>
 130  *   </child>
 131  * </object>
 132  * ]]></programlisting>
 133  * </example>
 134  * </refsect2>
 135  */
 136
 137 enum
 138 {
 139   DRAG_COLUMN_WINDOW_STATE_UNSET = 0,
 140   DRAG_COLUMN_WINDOW_STATE_ORIGINAL = 1,
 141   DRAG_COLUMN_WINDOW_STATE_ARROW = 2,
 142   DRAG_COLUMN_WINDOW_STATE_ARROW_LEFT = 3,
 143   DRAG_COLUMN_WINDOW_STATE_ARROW_RIGHT = 4
 144 };
 145
 146 enum
 147 {
 148   RUBBER_BAND_OFF = 0,
 149   RUBBER_BAND_MAYBE_START = 1,
 150   RUBBER_BAND_ACTIVE = 2
 151 };
 152
 153  /* This lovely little value is used to determine how far away from the title bar
 154   * you can move the mouse and still have a column drag work.
 155   */
 156 #define TREE_VIEW_COLUMN_DRAG_DEAD_MULTIPLIER(tree_view) (10*gtk_tree_view_get_effective_header_height(tree_view))
 157
 158 #ifdef __GNUC__
 159
 160 #define TREE_VIEW_INTERNAL_ASSERT(expr, ret)     G_STMT_START{          \
 161      if (!(expr))                                                       \
 162        {                                                                \
 163          g_log (G_LOG_DOMAIN,                                           \
 164                 G_LOG_LEVEL_CRITICAL,                                   \
 165                 "%s (%s): assertion `%s' failed.\n"                     \
 166                 "There is a disparity between the internal view of the GtkTreeView,\n"    \
 167                 "and the GtkTreeModel.  This generally means that the model has changed\n"\
 168                 "without letting the view know.  Any display from now on is likely to\n"  \
 169                 "be incorrect.\n",                                                        \
 170                 G_STRLOC,                                               \
 171                 G_STRFUNC,                                              \
 172                 #expr);                                                 \
 173          return ret;                                                    \
 174        };                               }G_STMT_END
 175
 176 #define TREE_VIEW_INTERNAL_ASSERT_VOID(expr)     G_STMT_START{          \
 177      if (!(expr))                                                       \
 178        {                                                                \
 179          g_log (G_LOG_DOMAIN,                                           \
 180                 G_LOG_LEVEL_CRITICAL,                                   \
 181                 "%s (%s): assertion `%s' failed.\n"                     \
 182                 "There is a disparity between the internal view of the GtkTreeView,\n"    \
 183                 "and the GtkTreeModel.  This generally means that the model has changed\n"\
 184                 "without letting the view know.  Any display from now on is likely to\n"  \
 185                 "be incorrect.\n",                                                        \
 186                 G_STRLOC,                                               \
 187                 G_STRFUNC,                                              \
 188                 #expr);                                                 \
 189          return;                                                        \
 190        };                               }G_STMT_END
 191
 192 #else
 193
 194 #define TREE_VIEW_INTERNAL_ASSERT(expr, ret)     G_STMT_START{          \
 195      if (!(expr))                                                       \
 196        {                                                                \
 197          g_log (G_LOG_DOMAIN,                                           \
 198                 G_LOG_LEVEL_CRITICAL,                                   \
 199                 "file %s: line %d: assertion `%s' failed.\n"       \
 200                 "There is a disparity between the internal view of the GtkTreeView,\n"    \
 201                 "and the GtkTreeModel.  This generally means that the model has changed\n"\
 202                 "without letting the view know.  Any display from now on is likely to\n"  \
 203                 "be incorrect.\n",                                                        \
 204                 __FILE__,                                               \
 205                 __LINE__,                                               \
 206                 #expr);                                                 \
 207          return ret;                                                    \
 208        };                               }G_STMT_END
 209
 210 #define TREE_VIEW_INTERNAL_ASSERT_VOID(expr)     G_STMT_START{          \
 211      if (!(expr))                                                       \
 212        {                                                                \
 213          g_log (G_LOG_DOMAIN,                                           \
 214                 G_LOG_LEVEL_CRITICAL,                                   \
 215                 "file %s: line %d: assertion '%s' failed.\n"            \
 216                 "There is a disparity between the internal view of the GtkTreeView,\n"    \
 217                 "and the GtkTreeModel.  This generally means that the model has changed\n"\
 218                 "without letting the view know.  Any display from now on is likely to\n"  \
 219                 "be incorrect.\n",                                                        \
 220                 __FILE__,                                               \
 221                 __LINE__,                                               \
 222                 #expr);                                                 \
 223          return;                                                        \
 224        };                               }G_STMT_END
 225 #endif
 226
 227 #define GTK_TREE_VIEW_PRIORITY_VALIDATE (GDK_PRIORITY_REDRAW + 5)
 228 #define GTK_TREE_VIEW_PRIORITY_SCROLL_SYNC (GTK_TREE_VIEW_PRIORITY_VALIDATE + 2)
 229 #define GTK_TREE_VIEW_TIME_MS_PER_IDLE 30
 230 #define SCROLL_EDGE_SIZE 15
 231 #define EXPANDER_EXTRA_PADDING 4
 232 #define GTK_TREE_VIEW_SEARCH_DIALOG_TIMEOUT 5000
 233 #define AUTO_EXPAND_TIMEOUT 500
 234
 235 /* Translate from bin_window coordinates to rbtree (tree coordinates) and
 236  * vice versa.
 237  */
 238 #define TREE_WINDOW_Y_TO_RBTREE_Y(tree_view,y) ((y) + tree_view->priv->dy)
 239 #define RBTREE_Y_TO_TREE_WINDOW_Y(tree_view,y) ((y) - tree_view->priv->dy)
 240
 241 typedef struct _GtkTreeViewColumnReorder GtkTreeViewColumnReorder;
 242 struct _GtkTreeViewColumnReorder
 243 {
 244   gint left_align;
 245   gint right_align;
 246   GtkTreeViewColumn *left_column;
 247   GtkTreeViewColumn *right_column;
 248 };
 249
 250 typedef struct _GtkTreeViewChild GtkTreeViewChild;
 251 struct _GtkTreeViewChild
 252 {
 253   GtkWidget *widget;
 254   gint x;
 255   gint y;
 256   gint width;
 257   gint height;
 258 };
 259
 260
 261 typedef struct _TreeViewDragInfo TreeViewDragInfo;
 262 struct _TreeViewDragInfo
 263 {
 264   GdkModifierType start_button_mask;
 265   GtkTargetList *_unused_source_target_list;
 266   GdkDragAction source_actions;
 267
 268   GtkTargetList *_unused_dest_target_list;
 269
 270   guint source_set : 1;
 271   guint dest_set : 1;
 272 };
 273
 274
 275 struct _GtkTreeViewPrivate
 276 {
 277   GtkTreeModel *model;
 278
 279   /* tree information */
 280   GtkRBTree *tree;
 281
 282   /* Container info */
 283   GList *children;
 284   gint width;
 285   gint height;
 286
 287   /* Adjustments */
 288   GtkAdjustment *hadjustment;
 289   GtkAdjustment *vadjustment;
 290   gint           min_display_width;
 291   gint           min_display_height;
 292
 293   /* Sub windows */
 294   GdkWindow *bin_window;
 295   GdkWindow *header_window;
 296
 297   /* Scroll position state keeping */
 298   GtkTreeRowReference *top_row;
 299   gint top_row_dy;
 300   /* dy == y pos of top_row + top_row_dy */
 301   /* we cache it for simplicity of the code */
 302   gint dy;
 303
 304   guint presize_handler_timer;
 305   guint validate_rows_timer;
 306   guint scroll_sync_timer;
 307
 308   /* Indentation and expander layout */
 309   gint expander_size;
 310   GtkTreeViewColumn *expander_column;
 311
 312   gint level_indentation;
 313
 314   /* Key navigation (focus), selection */
 315   gint cursor_offset;
 316
 317   GtkTreeRowReference *anchor;
 318   GtkTreeRowReference *cursor;
 319
 320   GtkTreeViewColumn *focus_column;
 321
 322   /* Current pressed node, previously pressed, prelight */
 323   GtkRBNode *button_pressed_node;
 324   GtkRBTree *button_pressed_tree;
 325
 326   gint pressed_button;
 327   gint press_start_x;
 328   gint press_start_y;
 329
 330   gint event_last_x;
 331   gint event_last_y;
 332
 333   guint last_button_time;
 334   gint last_button_x;
 335   gint last_button_y;
 336
 337   GtkRBNode *prelight_node;
 338   GtkRBTree *prelight_tree;
 339
 340   /* Cell Editing */
 341   GtkTreeViewColumn *edited_column;
 342
 343   /* The node that's currently being collapsed or expanded */
 344   GtkRBNode *expanded_collapsed_node;
 345   GtkRBTree *expanded_collapsed_tree;
 346   guint expand_collapse_timeout;
 347
 348   /* Auto expand/collapse timeout in hover mode */
 349   guint auto_expand_timeout;
 350
 351   /* Selection information */
 352   GtkTreeSelection *selection;
 353
 354   /* Header information */
 355   gint n_columns;
 356   GList *columns;
 357   gint header_height;
 358
 359   GtkTreeViewColumnDropFunc column_drop_func;
 360   gpointer column_drop_func_data;
 361   GDestroyNotify column_drop_func_data_destroy;
 362   GList *column_drag_info;
 363   GtkTreeViewColumnReorder *cur_reorder;
 364
 365   gint prev_width_before_expander;
 366
 367   /* Interactive Header reordering */
 368   GdkWindow *drag_window;
 369   GdkWindow *drag_highlight_window;
 370   GtkTreeViewColumn *drag_column;
 371   gint drag_column_x;
 372
 373   /* Interactive Header Resizing */
 374   gint drag_pos;
 375   gint x_drag;
 376
 377   /* Non-interactive Header Resizing, expand flag support */
 378   gint prev_width;
 379
 380   gint last_extra_space;
 381   gint last_extra_space_per_column;
 382   gint last_number_of_expand_columns;
 383
 384   /* ATK Hack */
 385   GtkTreeDestroyCountFunc destroy_count_func;
 386   gpointer destroy_count_data;
 387   GDestroyNotify destroy_count_destroy;
 388
 389   /* Scroll timeout (e.g. during dnd, rubber banding) */
 390   guint scroll_timeout;
 391
 392   /* Row drag-and-drop */
 393   GtkTreeRowReference *drag_dest_row;
 394   GtkTreeViewDropPosition drag_dest_pos;
 395   guint open_dest_timeout;
 396
 397   /* Rubber banding */
 398   gint rubber_band_status;
 399   gint rubber_band_x;
 400   gint rubber_band_y;
 401   gint rubber_band_extend;
 402   gint rubber_band_modify;
 403
 404   GtkRBNode *rubber_band_start_node;
 405   GtkRBTree *rubber_band_start_tree;
 406
 407   GtkRBNode *rubber_band_end_node;
 408   GtkRBTree *rubber_band_end_tree;
 409
 410   /* fixed height */
 411   gint fixed_height;
 412
 413   /* Scroll-to functionality when unrealized */
 414   GtkTreeRowReference *scroll_to_path;
 415   GtkTreeViewColumn *scroll_to_column;
 416   gfloat scroll_to_row_align;
 417   gfloat scroll_to_col_align;
 418
 419   /* Interactive search */
 420   gint selected_iter;
 421   gint search_column;
 422   GtkTreeViewSearchPositionFunc search_position_func;
 423   GtkTreeViewSearchEqualFunc search_equal_func;
 424   gpointer search_user_data;
 425   GDestroyNotify search_destroy;
 426   gpointer search_position_user_data;
 427   GDestroyNotify search_position_destroy;
 428   GtkWidget *search_window;
 429   GtkWidget *search_entry;
 430   gulong search_entry_changed_id;
 431   guint typeselect_flush_timeout;
 432
 433   /* Grid and tree lines */
 434   GtkTreeViewGridLines grid_lines;
 435   double grid_line_dashes[2];
 436   int grid_line_width;
 437
 438   gboolean tree_lines_enabled;
 439   double tree_line_dashes[2];
 440   int tree_line_width;
 441
 442   /* Row separators */
 443   GtkTreeViewRowSeparatorFunc row_separator_func;
 444   gpointer row_separator_data;
 445   GDestroyNotify row_separator_destroy;
 446
 447   /* Tooltip support */
 448   gint tooltip_column;
 449
 450   /* Here comes the bitfield */
 451   guint scroll_to_use_align : 1;
 452
 453   guint fixed_height_mode : 1;
 454   guint fixed_height_check : 1;
 455
 456   guint reorderable : 1;
 457   guint header_has_focus : 1;
 458   guint drag_column_window_state : 3;
 459   /* hint to display rows in alternating colors */
 460   guint has_rules : 1;
 461   guint mark_rows_col_dirty : 1;
 462
 463   /* for DnD */
 464   guint empty_view_drop : 1;
 465
 466   guint modify_selection_pressed : 1;
 467   guint extend_selection_pressed : 1;
 468
 469   guint init_hadjust_value : 1;
 470
 471   guint in_top_row_to_dy : 1;
 472
 473   /* interactive search */
 474   guint enable_search : 1;
 475   guint disable_popdown : 1;
 476   guint search_custom_entry_set : 1;
 477
 478   guint hover_selection : 1;
 479   guint hover_expand : 1;
 480   guint imcontext_changed : 1;
 481
 482   guint rubber_banding_enable : 1;
 483
 484   guint in_grab : 1;
 485
 486   guint post_validation_flag : 1;
 487
 488   /* Whether our key press handler is to avoid sending an unhandled binding to the search entry */
 489   guint search_entry_avoid_unhandled_binding : 1;
 490
 491   /* GtkScrollablePolicy needs to be checked when
 492    * driving the scrollable adjustment values */
 493   guint hscroll_policy : 1;
 494   guint vscroll_policy : 1;
 495
 496   /* GtkTreeView flags */
 497   guint is_list : 1;
 498   guint show_expanders : 1;
 499   guint in_column_resize : 1;
 500   guint arrow_prelit : 1;
 501   guint headers_visible : 1;
 502   guint draw_keyfocus : 1;
 503   guint model_setup : 1;
 504   guint in_column_drag : 1;
 505 };
 506
 507
 508 /* Signals */
 509 enum
 510 {
 511   ROW_ACTIVATED,
 512   TEST_EXPAND_ROW,
 513   TEST_COLLAPSE_ROW,
 514   ROW_EXPANDED,
 515   ROW_COLLAPSED,
 516   COLUMNS_CHANGED,
 517   CURSOR_CHANGED,
 518   MOVE_CURSOR,
 519   SELECT_ALL,
 520   UNSELECT_ALL,
 521   SELECT_CURSOR_ROW,
 522   TOGGLE_CURSOR_ROW,
 523   EXPAND_COLLAPSE_CURSOR_ROW,
 524   SELECT_CURSOR_PARENT,
 525   START_INTERACTIVE_SEARCH,
 526   LAST_SIGNAL
 527 };
 528
 529 /* Properties */
 530 enum {
 531   PROP_0,
 532   PROP_MODEL,
 533   PROP_HADJUSTMENT,
 534   PROP_VADJUSTMENT,
 535   PROP_HSCROLL_POLICY,
 536   PROP_VSCROLL_POLICY,
 537   PROP_HEADERS_VISIBLE,
 538   PROP_HEADERS_CLICKABLE,
 539   PROP_EXPANDER_COLUMN,
 540   PROP_REORDERABLE,
 541   PROP_RULES_HINT,
 542   PROP_ENABLE_SEARCH,
 543   PROP_SEARCH_COLUMN,
 544   PROP_FIXED_HEIGHT_MODE,
 545   PROP_HOVER_SELECTION,
 546   PROP_HOVER_EXPAND,
 547   PROP_SHOW_EXPANDERS,
 548   PROP_LEVEL_INDENTATION,
 549   PROP_RUBBER_BANDING,
 550   PROP_ENABLE_GRID_LINES,
 551   PROP_ENABLE_TREE_LINES,
 552   PROP_TOOLTIP_COLUMN
 553 };
 554
 555 /* object signals */
 556 static void     gtk_tree_view_finalize             (GObject          *object);
 557 static void     gtk_tree_view_set_property         (GObject         *object,
 558                                                     guint            prop_id,
 559                                                     const GValue    *value,
 560                                                     GParamSpec      *pspec);
 561 static void     gtk_tree_view_get_property         (GObject         *object,
 562                                                     guint            prop_id,
 563                                                     GValue          *value,
 564                                                     GParamSpec      *pspec);
 565
 566 /* gtkwidget signals */
 567 static void     gtk_tree_view_destroy              (GtkWidget        *widget);
 568 static void     gtk_tree_view_realize              (GtkWidget        *widget);
 569 static void     gtk_tree_view_unrealize            (GtkWidget        *widget);
 570 static void     gtk_tree_view_map                  (GtkWidget        *widget);
 571 static void     gtk_tree_view_get_preferred_width  (GtkWidget        *widget,
 572                                                     gint             *minimum,
 573                                                     gint             *natural);
 574 static void     gtk_tree_view_get_preferred_height (GtkWidget        *widget,
 575                                                     gint             *minimum,
 576                                                     gint             *natural);
 577 static void     gtk_tree_view_size_request         (GtkWidget        *widget,
 578                                                     GtkRequisition   *requisition,
 579                                                     gboolean          may_validate);
 580 static void     gtk_tree_view_size_allocate        (GtkWidget        *widget,
 581                                                     GtkAllocation    *allocation);
 582 static gboolean gtk_tree_view_draw                 (GtkWidget        *widget,
 583                                                     cairo_t          *cr);
 584 static gboolean gtk_tree_view_key_press            (GtkWidget        *widget,
 585                                                     GdkEventKey      *event);
 586 static gboolean gtk_tree_view_key_release          (GtkWidget        *widget,
 587                                                     GdkEventKey      *event);
 588 static gboolean gtk_tree_view_motion               (GtkWidget        *widget,
 589                                                     GdkEventMotion   *event);
 590 static gboolean gtk_tree_view_enter_notify         (GtkWidget        *widget,
 591                                                     GdkEventCrossing *event);
 592 static gboolean gtk_tree_view_leave_notify         (GtkWidget        *widget,
 593                                                     GdkEventCrossing *event);
 594 static gboolean gtk_tree_view_button_press         (GtkWidget        *widget,
 595                                                     GdkEventButton   *event);
 596 static gboolean gtk_tree_view_button_release       (GtkWidget        *widget,
 597                                                     GdkEventButton   *event);
 598 static gboolean gtk_tree_view_grab_broken          (GtkWidget          *widget,
 599                                                     GdkEventGrabBroken *event);
 600 #if 0
 601 static gboolean gtk_tree_view_configure            (GtkWidget         *widget,
 602                                                     GdkEventConfigure *event);
 603 #endif
 604
 605 static GtkWidgetPath * gtk_tree_view_get_path_for_child (GtkContainer *container,
 606                                                          GtkWidget    *child);
 607
 608 static void     gtk_tree_view_set_focus_child      (GtkContainer     *container,
 609                                                     GtkWidget        *child);
 610 static gint     gtk_tree_view_focus_out            (GtkWidget        *widget,
 611                                                     GdkEventFocus    *event);
 612 static gint     gtk_tree_view_focus                (GtkWidget        *widget,
 613                                                     GtkDirectionType  direction);
 614 static void     gtk_tree_view_grab_focus           (GtkWidget        *widget);
 615 static void     gtk_tree_view_style_updated        (GtkWidget        *widget);
 616 static void     gtk_tree_view_grab_notify          (GtkWidget        *widget,
 617                                                     gboolean          was_grabbed);
 618 static void     gtk_tree_view_state_flags_changed  (GtkWidget        *widget,
 619                                                     GtkStateFlags     previous_state);
 620
 621 /* container signals */
 622 static void     gtk_tree_view_remove               (GtkContainer     *container,
 623                                                     GtkWidget        *widget);
 624 static void     gtk_tree_view_forall               (GtkContainer     *container,
 625                                                     gboolean          include_internals,
 626                                                     GtkCallback       callback,
 627                                                     gpointer          callback_data);
 628
 629 /* Source side drag signals */
 630 static void gtk_tree_view_drag_begin       (GtkWidget        *widget,
 631                                             GdkDragContext   *context);
 632 static void gtk_tree_view_drag_end         (GtkWidget        *widget,
 633                                             GdkDragContext   *context);
 634 static void gtk_tree_view_drag_data_get    (GtkWidget        *widget,
 635                                             GdkDragContext   *context,
 636                                             GtkSelectionData *selection_data,
 637                                             guint             info,
 638                                             guint             time);
 639 static void gtk_tree_view_drag_data_delete (GtkWidget        *widget,
 640                                             GdkDragContext   *context);
 641
 642 /* Target side drag signals */
 643 static void     gtk_tree_view_drag_leave         (GtkWidget        *widget,
 644                                                   GdkDragContext   *context,
 645                                                   guint             time);
 646 static gboolean gtk_tree_view_drag_motion        (GtkWidget        *widget,
 647                                                   GdkDragContext   *context,
 648                                                   gint              x,
 649                                                   gint              y,
 650                                                   guint             time);
 651 static gboolean gtk_tree_view_drag_drop          (GtkWidget        *widget,
 652                                                   GdkDragContext   *context,
 653                                                   gint              x,
 654                                                   gint              y,
 655                                                   guint             time);
 656 static void     gtk_tree_view_drag_data_received (GtkWidget        *widget,
 657                                                   GdkDragContext   *context,
 658                                                   gint              x,
 659                                                   gint              y,
 660                                                   GtkSelectionData *selection_data,
 661                                                   guint             info,
 662                                                   guint             time);
 663
 664 /* tree_model signals */
 665 static gboolean gtk_tree_view_real_move_cursor            (GtkTreeView     *tree_view,
 666                                                            GtkMovementStep  step,
 667                                                            gint             count);
 668 static gboolean gtk_tree_view_real_select_all             (GtkTreeView     *tree_view);
 669 static gboolean gtk_tree_view_real_unselect_all           (GtkTreeView     *tree_view);
 670 static gboolean gtk_tree_view_real_select_cursor_row      (GtkTreeView     *tree_view,
 671                                                            gboolean         start_editing);
 672 static gboolean gtk_tree_view_real_toggle_cursor_row      (GtkTreeView     *tree_view);
 673 static gboolean gtk_tree_view_real_expand_collapse_cursor_row (GtkTreeView     *tree_view,
 674                                                                gboolean         logical,
 675                                                                gboolean         expand,
 676                                                                gboolean         open_all);
 677 static gboolean gtk_tree_view_real_select_cursor_parent   (GtkTreeView     *tree_view);
 678 static void gtk_tree_view_row_changed                     (GtkTreeModel    *model,
 679                                                            GtkTreePath     *path,
 680                                                            GtkTreeIter     *iter,
 681                                                            gpointer         data);
 682 static void gtk_tree_view_row_inserted                    (GtkTreeModel    *model,
 683                                                            GtkTreePath     *path,
 684                                                            GtkTreeIter     *iter,
 685                                                            gpointer         data);
 686 static void gtk_tree_view_row_has_child_toggled           (GtkTreeModel    *model,
 687                                                            GtkTreePath     *path,
 688                                                            GtkTreeIter     *iter,
 689                                                            gpointer         data);
 690 static void gtk_tree_view_row_deleted                     (GtkTreeModel    *model,
 691                                                            GtkTreePath     *path,
 692                                                            gpointer         data);
 693 static void gtk_tree_view_rows_reordered                  (GtkTreeModel    *model,
 694                                                            GtkTreePath     *parent,
 695                                                            GtkTreeIter     *iter,
 696                                                            gint            *new_order,
 697                                                            gpointer         data);
 698
 699 /* Incremental reflow */
 700 static gboolean validate_row             (GtkTreeView *tree_view,
 701                                           GtkRBTree   *tree,
 702                                           GtkRBNode   *node,
 703                                           GtkTreeIter *iter,
 704                                           GtkTreePath *path);
 705 static void     validate_visible_area    (GtkTreeView *tree_view);
 706 static gboolean validate_rows_handler    (GtkTreeView *tree_view);
 707 static gboolean do_validate_rows         (GtkTreeView *tree_view,
 708                                           gboolean     size_request);
 709 static gboolean validate_rows            (GtkTreeView *tree_view);
 710 static gboolean presize_handler_callback (gpointer     data);
 711 static void     install_presize_handler  (GtkTreeView *tree_view);
 712 static void     install_scroll_sync_handler (GtkTreeView *tree_view);
 713 static void     gtk_tree_view_set_top_row   (GtkTreeView *tree_view,
 714                                              GtkTreePath *path,
 715                                              gint         offset);
 716 static void     gtk_tree_view_dy_to_top_row (GtkTreeView *tree_view);
 717 static void     gtk_tree_view_top_row_to_dy (GtkTreeView *tree_view);
 718 static void     invalidate_empty_focus      (GtkTreeView *tree_view);
 719
 720 /* Internal functions */
 721 static gboolean gtk_tree_view_is_expander_column             (GtkTreeView        *tree_view,
 722                                                               GtkTreeViewColumn  *column);
 723 static inline gboolean gtk_tree_view_draw_expanders          (GtkTreeView        *tree_view);
 724 static void     gtk_tree_view_add_move_binding               (GtkBindingSet      *binding_set,
 725                                                               guint               keyval,
 726                                                               guint               modmask,
 727                                                               gboolean            add_shifted_binding,
 728                                                               GtkMovementStep     step,
 729                                                               gint                count);
 730 static gint     gtk_tree_view_unref_and_check_selection_tree (GtkTreeView        *tree_view,
 731                                                               GtkRBTree          *tree);
 732 static void     gtk_tree_view_queue_draw_path                (GtkTreeView        *tree_view,
 733                                                               GtkTreePath        *path,
 734                                                               const GdkRectangle *clip_rect);
 735 static void     gtk_tree_view_queue_draw_arrow               (GtkTreeView        *tree_view,
 736                                                               GtkRBTree          *tree,
 737                                                               GtkRBNode          *node);
 738 static void     gtk_tree_view_draw_arrow                     (GtkTreeView        *tree_view,
 739                                                               cairo_t            *cr,
 740                                                               GtkRBTree          *tree,
 741                                                               GtkRBNode          *node);
 742 static void     gtk_tree_view_get_arrow_xrange               (GtkTreeView        *tree_view,
 743                                                               GtkRBTree          *tree,
 744                                                               gint               *x1,
 745                                                               gint               *x2);
 746 static gint     gtk_tree_view_new_column_width               (GtkTreeView        *tree_view,
 747                                                               gint                i,
 748                                                               gint               *x);
 749 static void     gtk_tree_view_adjustment_changed             (GtkAdjustment      *adjustment,
 750                                                               GtkTreeView        *tree_view);
 751 static void     gtk_tree_view_build_tree                     (GtkTreeView        *tree_view,
 752                                                               GtkRBTree          *tree,
 753                                                               GtkTreeIter        *iter,
 754                                                               gint                depth,
 755                                                               gboolean            recurse);
 756 static void     gtk_tree_view_clamp_node_visible             (GtkTreeView        *tree_view,
 757                                                               GtkRBTree          *tree,
 758                                                               GtkRBNode          *node);
 759 static void     gtk_tree_view_clamp_column_visible           (GtkTreeView        *tree_view,
 760                                                               GtkTreeViewColumn  *column,
 761                                                               gboolean            focus_to_cell);
 762 static gboolean gtk_tree_view_maybe_begin_dragging_row       (GtkTreeView        *tree_view,
 763                                                               GdkEventMotion     *event);
 764 static void     gtk_tree_view_focus_to_cursor                (GtkTreeView        *tree_view);
 765 static void     gtk_tree_view_move_cursor_up_down            (GtkTreeView        *tree_view,
 766                                                               gint                count);
 767 static void     gtk_tree_view_move_cursor_page_up_down       (GtkTreeView        *tree_view,
 768                                                               gint                count);
 769 static void     gtk_tree_view_move_cursor_left_right         (GtkTreeView        *tree_view,
 770                                                               gint                count);
 771 static void     gtk_tree_view_move_cursor_start_end          (GtkTreeView        *tree_view,
 772                                                               gint                count);
 773 static gboolean gtk_tree_view_real_collapse_row              (GtkTreeView        *tree_view,
 774                                                               GtkTreePath        *path,
 775                                                               GtkRBTree          *tree,
 776                                                               GtkRBNode          *node,
 777                                                               gboolean            animate);
 778 static gboolean gtk_tree_view_real_expand_row                (GtkTreeView        *tree_view,
 779                                                               GtkTreePath        *path,
 780                                                               GtkRBTree          *tree,
 781                                                               GtkRBNode          *node,
 782                                                               gboolean            open_all,
 783                                                               gboolean            animate);
 784 static void     gtk_tree_view_real_set_cursor                (GtkTreeView        *tree_view,
 785                                                               GtkTreePath        *path,
 786                                                               gboolean            clear_and_select,
 787                                                               gboolean            clamp_node);
 788 static gboolean gtk_tree_view_has_can_focus_cell             (GtkTreeView        *tree_view);
 789 static void     column_sizing_notify                         (GObject            *object,
 790                                                               GParamSpec         *pspec,
 791                                                               gpointer            data);
 792 static void     gtk_tree_view_stop_rubber_band               (GtkTreeView        *tree_view);
 793 static void     update_prelight                              (GtkTreeView        *tree_view,
 794                                                               int                 x,
 795                                                               int                 y);
 796
 797 static inline gint gtk_tree_view_get_effective_header_height (GtkTreeView *tree_view);
 798
 799 static inline gint gtk_tree_view_get_cell_area_y_offset      (GtkTreeView *tree_view,
 800                                                               GtkRBTree   *tree,
 801                                                               GtkRBNode   *node,
 802                                                               gint         vertical_separator);
 803 static inline gint gtk_tree_view_get_cell_area_height        (GtkTreeView *tree_view,
 804                                                               GtkRBNode   *node,
 805                                                               gint         vertical_separator);
 806
 807 static inline gint gtk_tree_view_get_row_y_offset            (GtkTreeView *tree_view,
 808                                                               GtkRBTree   *tree,
 809                                                               GtkRBNode   *node);
 810 static inline gint gtk_tree_view_get_row_height              (GtkTreeView *tree_view,
 811                                                               GtkRBNode   *node);
 812
 813 /* interactive search */
 814 static void     gtk_tree_view_ensure_interactive_directory (GtkTreeView *tree_view);
 815 static void     gtk_tree_view_search_dialog_hide        (GtkWidget        *search_dialog,
 816                                                          GtkTreeView      *tree_view,
 817                                                          GdkDevice        *device);
 818 static void     gtk_tree_view_search_position_func      (GtkTreeView      *tree_view,
 819                                                          GtkWidget        *search_dialog,
 820                                                          gpointer          user_data);
 821 static void     gtk_tree_view_search_disable_popdown    (GtkEntry         *entry,
 822                                                          GtkMenu          *menu,
 823                                                          gpointer          data);
 824 static void     gtk_tree_view_search_preedit_changed    (GtkIMContext     *im_context,
 825                                                          GtkTreeView      *tree_view);
 826 static void     gtk_tree_view_search_activate           (GtkEntry         *entry,
 827                                                          GtkTreeView      *tree_view);
 828 static gboolean gtk_tree_view_real_search_enable_popdown(gpointer          data);
 829 static void     gtk_tree_view_search_enable_popdown     (GtkWidget        *widget,
 830                                                          gpointer          data);
 831 static gboolean gtk_tree_view_search_delete_event       (GtkWidget        *widget,
 832                                                          GdkEventAny      *event,
 833                                                          GtkTreeView      *tree_view);
 834 static gboolean gtk_tree_view_search_button_press_event (GtkWidget        *widget,
 835                                                          GdkEventButton   *event,
 836                                                          GtkTreeView      *tree_view);
 837 static gboolean gtk_tree_view_search_scroll_event       (GtkWidget        *entry,
 838                                                          GdkEventScroll   *event,
 839                                                          GtkTreeView      *tree_view);
 840 static gboolean gtk_tree_view_search_key_press_event    (GtkWidget        *entry,
 841                                                          GdkEventKey      *event,
 842                                                          GtkTreeView      *tree_view);
 843 static gboolean gtk_tree_view_search_move               (GtkWidget        *window,
 844                                                          GtkTreeView      *tree_view,
 845                                                          gboolean          up);
 846 static gboolean gtk_tree_view_search_equal_func         (GtkTreeModel     *model,
 847                                                          gint              column,
 848                                                          const gchar      *key,
 849                                                          GtkTreeIter      *iter,
 850                                                          gpointer          search_data);
 851 static gboolean gtk_tree_view_search_iter               (GtkTreeModel     *model,
 852                                                          GtkTreeSelection *selection,
 853                                                          GtkTreeIter      *iter,
 854                                                          const gchar      *text,
 855                                                          gint             *count,
 856                                                          gint              n);
 857 static void     gtk_tree_view_search_init               (GtkWidget        *entry,
 858                                                          GtkTreeView      *tree_view);
 859 static void     gtk_tree_view_put                       (GtkTreeView      *tree_view,
 860                                                          GtkWidget        *child_widget,
 861                                                          gint              x,
 862                                                          gint              y,
 863                                                          gint              width,
 864                                                          gint              height);
 865 static gboolean gtk_tree_view_start_editing             (GtkTreeView      *tree_view,
 866                                                          GtkTreePath      *cursor_path,
 867                                                          gboolean          edit_only);
 868 static void gtk_tree_view_stop_editing                  (GtkTreeView *tree_view,
 869                                                          gboolean     cancel_editing);
 870 static gboolean gtk_tree_view_real_start_interactive_search (GtkTreeView *tree_view,
 871                                                              GdkDevice   *device,
 872                                                              gboolean     keybinding);
 873 static gboolean gtk_tree_view_start_interactive_search      (GtkTreeView *tree_view);
 874 static GtkTreeViewColumn *gtk_tree_view_get_drop_column (GtkTreeView       *tree_view,
 875                                                          GtkTreeViewColumn *column,
 876                                                          gint               drop_position);
 877
 878 /* GtkBuildable */
 879 static void     gtk_tree_view_buildable_add_child          (GtkBuildable      *tree_view,
 880                                                             GtkBuilder        *builder,
 881                                                             GObject           *child,
 882                                                             const gchar       *type);
 883 static GObject *gtk_tree_view_buildable_get_internal_child (GtkBuildable      *buildable,
 884                                                             GtkBuilder        *builder,
 885                                                             const gchar       *childname);
 886 static void     gtk_tree_view_buildable_init               (GtkBuildableIface *iface);
 887
 888
 889 static gboolean scroll_row_timeout                   (gpointer     data);
 890 static void     add_scroll_timeout                   (GtkTreeView *tree_view);
 891 static void     remove_scroll_timeout                (GtkTreeView *tree_view);
 892
 893 static guint tree_view_signals [LAST_SIGNAL] = { 0 };
 894
 895 \f
 896
 897 /* GType Methods
 898  */
 899
 900 G_DEFINE_TYPE_WITH_CODE (GtkTreeView, gtk_tree_view, GTK_TYPE_CONTAINER,
 901                          G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE,
 902                                                 gtk_tree_view_buildable_init)
 903                          G_IMPLEMENT_INTERFACE (GTK_TYPE_SCROLLABLE, NULL))
 904
 905 static void
 906 gtk_tree_view_class_init (GtkTreeViewClass *class)
 907 {
 908   GObjectClass *o_class;
 909   GtkWidgetClass *widget_class;
 910   GtkContainerClass *container_class;
 911   GtkBindingSet *binding_set;
 912
 913   binding_set = gtk_binding_set_by_class (class);
 914
 915   o_class = (GObjectClass *) class;
 916   widget_class = (GtkWidgetClass *) class;
 917   container_class = (GtkContainerClass *) class;
 918
 919   /* GObject signals */
 920   o_class->set_property = gtk_tree_view_set_property;
 921   o_class->get_property = gtk_tree_view_get_property;
 922   o_class->finalize = gtk_tree_view_finalize;
 923
 924   /* GtkWidget signals */
 925   widget_class->destroy = gtk_tree_view_destroy;
 926   widget_class->map = gtk_tree_view_map;
 927   widget_class->realize = gtk_tree_view_realize;
 928   widget_class->unrealize = gtk_tree_view_unrealize;
 929   widget_class->get_preferred_width = gtk_tree_view_get_preferred_width;
 930   widget_class->get_preferred_height = gtk_tree_view_get_preferred_height;
 931   widget_class->size_allocate = gtk_tree_view_size_allocate;
 932   widget_class->button_press_event = gtk_tree_view_button_press;
 933   widget_class->button_release_event = gtk_tree_view_button_release;
 934   widget_class->grab_broken_event = gtk_tree_view_grab_broken;
 935   /*widget_class->configure_event = gtk_tree_view_configure;*/
 936   widget_class->motion_notify_event = gtk_tree_view_motion;
 937   widget_class->draw = gtk_tree_view_draw;
 938   widget_class->key_press_event = gtk_tree_view_key_press;
 939   widget_class->key_release_event = gtk_tree_view_key_release;
 940   widget_class->enter_notify_event = gtk_tree_view_enter_notify;
 941   widget_class->leave_notify_event = gtk_tree_view_leave_notify;
 942   widget_class->focus_out_event = gtk_tree_view_focus_out;
 943   widget_class->drag_begin = gtk_tree_view_drag_begin;
 944   widget_class->drag_end = gtk_tree_view_drag_end;
 945   widget_class->drag_data_get = gtk_tree_view_drag_data_get;
 946   widget_class->drag_data_delete = gtk_tree_view_drag_data_delete;
 947   widget_class->drag_leave = gtk_tree_view_drag_leave;
 948   widget_class->drag_motion = gtk_tree_view_drag_motion;
 949   widget_class->drag_drop = gtk_tree_view_drag_drop;
 950   widget_class->drag_data_received = gtk_tree_view_drag_data_received;
 951   widget_class->focus = gtk_tree_view_focus;
 952   widget_class->grab_focus = gtk_tree_view_grab_focus;
 953   widget_class->style_updated = gtk_tree_view_style_updated;
 954   widget_class->grab_notify = gtk_tree_view_grab_notify;
 955   widget_class->state_flags_changed = gtk_tree_view_state_flags_changed;
 956
 957   /* GtkContainer signals */
 958   container_class->remove = gtk_tree_view_remove;
 959   container_class->forall = gtk_tree_view_forall;
 960   container_class->set_focus_child = gtk_tree_view_set_focus_child;
 961   container_class->get_path_for_child = gtk_tree_view_get_path_for_child;
 962
 963   class->move_cursor = gtk_tree_view_real_move_cursor;
 964   class->select_all = gtk_tree_view_real_select_all;
 965   class->unselect_all = gtk_tree_view_real_unselect_all;
 966   class->select_cursor_row = gtk_tree_view_real_select_cursor_row;
 967   class->toggle_cursor_row = gtk_tree_view_real_toggle_cursor_row;
 968   class->expand_collapse_cursor_row = gtk_tree_view_real_expand_collapse_cursor_row;
 969   class->select_cursor_parent = gtk_tree_view_real_select_cursor_parent;
 970   class->start_interactive_search = gtk_tree_view_start_interactive_search;
 971
 972   /* Properties */
 973
 974   g_object_class_install_property (o_class,
 975                                    PROP_MODEL,
 976                                    g_param_spec_object ("model",
 977                                                         P_("TreeView Model"),
 978                                                         P_("The model for the tree view"),
 979                                                         GTK_TYPE_TREE_MODEL,
 980                                                         GTK_PARAM_READWRITE));
 981
 982   g_object_class_override_property (o_class, PROP_HADJUSTMENT,    "hadjustment");
 983   g_object_class_override_property (o_class, PROP_VADJUSTMENT,    "vadjustment");
 984   g_object_class_override_property (o_class, PROP_HSCROLL_POLICY, "hscroll-policy");
 985   g_object_class_override_property (o_class, PROP_VSCROLL_POLICY, "vscroll-policy");
 986
 987   g_object_class_install_property (o_class,
 988                                    PROP_HEADERS_VISIBLE,
 989                                    g_param_spec_boolean ("headers-visible",
 990                                                          P_("Headers Visible"),
 991                                                          P_("Show the column header buttons"),
 992                                                          TRUE,
 993                                                          GTK_PARAM_READWRITE));
 994
 995   g_object_class_install_property (o_class,
 996                                    PROP_HEADERS_CLICKABLE,
 997                                    g_param_spec_boolean ("headers-clickable",
 998                                                          P_("Headers Clickable"),
 999                                                          P_("Column headers respond to click events"),
1000                                                          TRUE,
1001                                                          GTK_PARAM_READWRITE));
1002
1003   g_object_class_install_property (o_class,
1004                                    PROP_EXPANDER_COLUMN,
1005                                    g_param_spec_object ("expander-column",
1006                                                         P_("Expander Column"),
1007                                                         P_("Set the column for the expander column"),
1008                                                         GTK_TYPE_TREE_VIEW_COLUMN,
1009                                                         GTK_PARAM_READWRITE));
1010
1011   g_object_class_install_property (o_class,
1012                                    PROP_REORDERABLE,
1013                                    g_param_spec_boolean ("reorderable",
1014                                                          P_("Reorderable"),
1015                                                          P_("View is reorderable"),
1016                                                          FALSE,
1017                                                          GTK_PARAM_READWRITE));
1018
1019   g_object_class_install_property (o_class,
1020                                    PROP_RULES_HINT,
1021                                    g_param_spec_boolean ("rules-hint",
1022                                                          P_("Rules Hint"),
1023                                                          P_("Set a hint to the theme engine to draw rows in alternating colors"),
1024                                                          FALSE,
1025                                                          GTK_PARAM_READWRITE));
1026
1027     g_object_class_install_property (o_class,
1028                                      PROP_ENABLE_SEARCH,
1029                                      g_param_spec_boolean ("enable-search",
1030                                                            P_("Enable Search"),
1031                                                            P_("View allows user to search through columns interactively"),
1032                                                            TRUE,
1033                                                            GTK_PARAM_READWRITE));
1034
1035     g_object_class_install_property (o_class,
1036                                      PROP_SEARCH_COLUMN,
1037                                      g_param_spec_int ("search-column",
1038                                                        P_("Search Column"),
1039                                                        P_("Model column to search through during interactive search"),
1040                                                        -1,
1041                                                        G_MAXINT,
1042                                                        -1,
1043                                                        GTK_PARAM_READWRITE));
1044
1045     /**
1046      * GtkTreeView:fixed-height-mode:
1047      *
1048      * Setting the ::fixed-height-mode property to %TRUE speeds up
1049      * #GtkTreeView by assuming that all rows have the same height.
1050      * Only enable this option if all rows are the same height.
1051      * Please see gtk_tree_view_set_fixed_height_mode() for more
1052      * information on this option.
1053      *
1054      * Since: 2.4
1055      **/
1056     g_object_class_install_property (o_class,
1057                                      PROP_FIXED_HEIGHT_MODE,
1058                                      g_param_spec_boolean ("fixed-height-mode",
1059                                                            P_("Fixed Height Mode"),
1060                                                            P_("Speeds up GtkTreeView by assuming that all rows have the same height"),
1061                                                            FALSE,
1062                                                            GTK_PARAM_READWRITE));
1063
1064     /**
1065      * GtkTreeView:hover-selection:
1066      *
1067      * Enables or disables the hover selection mode of @tree_view.
1068      * Hover selection makes the selected row follow the pointer.
1069      * Currently, this works only for the selection modes
1070      * %GTK_SELECTION_SINGLE and %GTK_SELECTION_BROWSE.
1071      *
1072      * This mode is primarily intended for treeviews in popups, e.g.
1073      * in #GtkComboBox or #GtkEntryCompletion.
1074      *
1075      * Since: 2.6
1076      */
1077     g_object_class_install_property (o_class,
1078                                      PROP_HOVER_SELECTION,
1079                                      g_param_spec_boolean ("hover-selection",
1080                                                            P_("Hover Selection"),
1081                                                            P_("Whether the selection should follow the pointer"),
1082                                                            FALSE,
1083                                                            GTK_PARAM_READWRITE));
1084
1085     /**
1086      * GtkTreeView:hover-expand:
1087      *
1088      * Enables or disables the hover expansion mode of @tree_view.
1089      * Hover expansion makes rows expand or collapse if the pointer moves
1090      * over them.
1091      *
1092      * This mode is primarily intended for treeviews in popups, e.g.
1093      * in #GtkComboBox or #GtkEntryCompletion.
1094      *
1095      * Since: 2.6
1096      */
1097     g_object_class_install_property (o_class,
1098                                      PROP_HOVER_EXPAND,
1099                                      g_param_spec_boolean ("hover-expand",
1100                                                            P_("Hover Expand"),
1101                                                            P_("Whether rows should be expanded/collapsed when the pointer moves over them"),
1102                                                            FALSE,
1103                                                            GTK_PARAM_READWRITE));
1104
1105     /**
1106      * GtkTreeView:show-expanders:
1107      *
1108      * %TRUE if the view has expanders.
1109      *
1110      * Since: 2.12
1111      */
1112     g_object_class_install_property (o_class,
1113                                      PROP_SHOW_EXPANDERS,
1114                                      g_param_spec_boolean ("show-expanders",
1115                                                            P_("Show Expanders"),
1116                                                            P_("View has expanders"),
1117                                                            TRUE,
1118                                                            GTK_PARAM_READWRITE));
1119
1120     /**
1121      * GtkTreeView:level-indentation:
1122      *
1123      * Extra indentation for each level.
1124      *
1125      * Since: 2.12
1126      */
1127     g_object_class_install_property (o_class,
1128                                      PROP_LEVEL_INDENTATION,
1129                                      g_param_spec_int ("level-indentation",
1130                                                        P_("Level Indentation"),
1131                                                        P_("Extra indentation for each level"),
1132                                                        0,
1133                                                        G_MAXINT,
1134                                                        0,
1135                                                        GTK_PARAM_READWRITE));
1136
1137     g_object_class_install_property (o_class,
1138                                      PROP_RUBBER_BANDING,
1139                                      g_param_spec_boolean ("rubber-banding",
1140                                                            P_("Rubber Banding"),
1141                                                            P_("Whether to enable selection of multiple items by dragging the mouse pointer"),
1142                                                            FALSE,
1143                                                            GTK_PARAM_READWRITE));
1144
1145     g_object_class_install_property (o_class,
1146                                      PROP_ENABLE_GRID_LINES,
1147                                      g_param_spec_enum ("enable-grid-lines",
1148                                                         P_("Enable Grid Lines"),
1149                                                         P_("Whether grid lines should be drawn in the tree view"),
1150                                                         GTK_TYPE_TREE_VIEW_GRID_LINES,
1151                                                         GTK_TREE_VIEW_GRID_LINES_NONE,
1152                                                         GTK_PARAM_READWRITE));
1153
1154     g_object_class_install_property (o_class,
1155                                      PROP_ENABLE_TREE_LINES,
1156                                      g_param_spec_boolean ("enable-tree-lines",
1157                                                            P_("Enable Tree Lines"),
1158                                                            P_("Whether tree lines should be drawn in the tree view"),
1159                                                            FALSE,
1160                                                            GTK_PARAM_READWRITE));
1161
1162     g_object_class_install_property (o_class,
1163                                      PROP_TOOLTIP_COLUMN,
1164                                      g_param_spec_int ("tooltip-column",
1165                                                        P_("Tooltip Column"),
1166                                                        P_("The column in the model containing the tooltip texts for the rows"),
1167                                                        -1,
1168                                                        G_MAXINT,
1169                                                        -1,
1170                                                        GTK_PARAM_READWRITE));
1171
1172   /* Style properties */
1173 #define _TREE_VIEW_EXPANDER_SIZE 14
1174 #define _TREE_VIEW_VERTICAL_SEPARATOR 2
1175 #define _TREE_VIEW_HORIZONTAL_SEPARATOR 2
1176
1177   gtk_widget_class_install_style_property (widget_class,
1178                                            g_param_spec_int ("expander-size",
1179                                                              P_("Expander Size"),
1180                                                              P_("Size of the expander arrow"),
1181                                                              0,
1182                                                              G_MAXINT,
1183                                                              _TREE_VIEW_EXPANDER_SIZE,
1184                                                              GTK_PARAM_READABLE));
1185
1186   gtk_widget_class_install_style_property (widget_class,
1187                                            g_param_spec_int ("vertical-separator",
1188                                                              P_("Vertical Separator Width"),
1189                                                              P_("Vertical space between cells.  Must be an even number"),
1190                                                              0,
1191                                                              G_MAXINT,
1192                                                              _TREE_VIEW_VERTICAL_SEPARATOR,
1193                                                              GTK_PARAM_READABLE));
1194
1195   gtk_widget_class_install_style_property (widget_class,
1196                                            g_param_spec_int ("horizontal-separator",
1197                                                              P_("Horizontal Separator Width"),
1198                                                              P_("Horizontal space between cells.  Must be an even number"),
1199                                                              0,
1200                                                              G_MAXINT,
1201                                                              _TREE_VIEW_HORIZONTAL_SEPARATOR,
1202                                                              GTK_PARAM_READABLE));
1203
1204   gtk_widget_class_install_style_property (widget_class,
1205                                            g_param_spec_boolean ("allow-rules",
1206                                                                  P_("Allow Rules"),
1207                                                                  P_("Allow drawing of alternating color rows"),
1208                                                                  TRUE,
1209                                                                  GTK_PARAM_READABLE));
1210
1211   gtk_widget_class_install_style_property (widget_class,
1212                                            g_param_spec_boolean ("indent-expanders",
1213                                                                  P_("Indent Expanders"),
1214                                                                  P_("Make the expanders indented"),
1215                                                                  TRUE,
1216                                                                  GTK_PARAM_READABLE));
1217
1218   gtk_widget_class_install_style_property (widget_class,
1219                                            g_param_spec_boxed ("even-row-color",
1220                                                                P_("Even Row Color"),
1221                                                                P_("Color to use for even rows"),
1222                                                                GDK_TYPE_COLOR,
1223                                                                GTK_PARAM_READABLE));
1224
1225   gtk_widget_class_install_style_property (widget_class,
1226                                            g_param_spec_boxed ("odd-row-color",
1227                                                                P_("Odd Row Color"),
1228                                                                P_("Color to use for odd rows"),
1229                                                                GDK_TYPE_COLOR,
1230                                                                GTK_PARAM_READABLE));
1231
1232   gtk_widget_class_install_style_property (widget_class,
1233                                            g_param_spec_int ("grid-line-width",
1234                                                              P_("Grid line width"),
1235                                                              P_("Width, in pixels, of the tree view grid lines"),
1236                                                              0, G_MAXINT, 1,
1237                                                              GTK_PARAM_READABLE));
1238
1239   gtk_widget_class_install_style_property (widget_class,
1240                                            g_param_spec_int ("tree-line-width",
1241                                                              P_("Tree line width"),
1242                                                              P_("Width, in pixels, of the tree view lines"),
1243                                                              0, G_MAXINT, 1,
1244                                                              GTK_PARAM_READABLE));
1245
1246   gtk_widget_class_install_style_property (widget_class,
1247                                            g_param_spec_string ("grid-line-pattern",
1248                                                                 P_("Grid line pattern"),
1249                                                                 P_("Dash pattern used to draw the tree view grid lines"),
1250                                                                 "\1\1",
1251                                                                 GTK_PARAM_READABLE));
1252
1253   gtk_widget_class_install_style_property (widget_class,
1254                                            g_param_spec_string ("tree-line-pattern",
1255                                                                 P_("Tree line pattern"),
1256                                                                 P_("Dash pattern used to draw the tree view lines"),
1257                                                                 "\1\1",
1258                                                                 GTK_PARAM_READABLE));
1259
1260   /* Signals */
1261   /**
1262    * GtkTreeView::row-activated:
1263    * @tree_view: the object on which the signal is emitted
1264    * @path: the #GtkTreePath for the activated row
1265    * @column: the #GtkTreeViewColumn in which the activation occurred
1266    *
1267    * The "row-activated" signal is emitted when the method
1268    * gtk_tree_view_row_activated() is called or the user double clicks
1269    * a treeview row. It is also emitted when a non-editable row is
1270    * selected and one of the keys: Space, Shift+Space, Return or
1271    * Enter is pressed.
1272    *
1273    * For selection handling refer to the <link linkend="TreeWidget">tree
1274    * widget conceptual overview</link> as well as #GtkTreeSelection.
1275    */
1276   tree_view_signals[ROW_ACTIVATED] =
1277     g_signal_new (I_("row-activated"),
1278                   G_TYPE_FROM_CLASS (o_class),
1279                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1280                   G_STRUCT_OFFSET (GtkTreeViewClass, row_activated),
1281                   NULL, NULL,
1282                   _gtk_marshal_VOID__BOXED_OBJECT,
1283                   G_TYPE_NONE, 2,
1284                   GTK_TYPE_TREE_PATH,
1285                   GTK_TYPE_TREE_VIEW_COLUMN);
1286
1287   /**
1288    * GtkTreeView::test-expand-row:
1289    * @tree_view: the object on which the signal is emitted
1290    * @iter: the tree iter of the row to expand
1291    * @path: a tree path that points to the row
1292    *
1293    * The given row is about to be expanded (show its children nodes). Use this
1294    * signal if you need to control the expandability of individual rows.
1295    *
1296    * Returns: %FALSE to allow expansion, %TRUE to reject
1297    */
1298   tree_view_signals[TEST_EXPAND_ROW] =
1299     g_signal_new (I_("test-expand-row"),
1300                   G_TYPE_FROM_CLASS (o_class),
1301                   G_SIGNAL_RUN_LAST,
1302                   G_STRUCT_OFFSET (GtkTreeViewClass, test_expand_row),
1303                   _gtk_boolean_handled_accumulator, NULL,
1304                   _gtk_marshal_BOOLEAN__BOXED_BOXED,
1305                   G_TYPE_BOOLEAN, 2,
1306                   GTK_TYPE_TREE_ITER,
1307                   GTK_TYPE_TREE_PATH);
1308
1309   /**
1310    * GtkTreeView::test-collapse-row:
1311    * @tree_view: the object on which the signal is emitted
1312    * @iter: the tree iter of the row to collapse
1313    * @path: a tree path that points to the row
1314    *
1315    * The given row is about to be collapsed (hide its children nodes). Use this
1316    * signal if you need to control the collapsibility of individual rows.
1317    *
1318    * Returns: %FALSE to allow collapsing, %TRUE to reject
1319    */
1320   tree_view_signals[TEST_COLLAPSE_ROW] =
1321     g_signal_new (I_("test-collapse-row"),
1322                   G_TYPE_FROM_CLASS (o_class),
1323                   G_SIGNAL_RUN_LAST,
1324                   G_STRUCT_OFFSET (GtkTreeViewClass, test_collapse_row),
1325                   _gtk_boolean_handled_accumulator, NULL,
1326                   _gtk_marshal_BOOLEAN__BOXED_BOXED,
1327                   G_TYPE_BOOLEAN, 2,
1328                   GTK_TYPE_TREE_ITER,
1329                   GTK_TYPE_TREE_PATH);
1330
1331   /**
1332    * GtkTreeView::row-expanded:
1333    * @tree_view: the object on which the signal is emitted
1334    * @iter: the tree iter of the expanded row
1335    * @path: a tree path that points to the row
1336    *
1337    * The given row has been expanded (child nodes are shown).
1338    */
1339   tree_view_signals[ROW_EXPANDED] =
1340     g_signal_new (I_("row-expanded"),
1341                   G_TYPE_FROM_CLASS (o_class),
1342                   G_SIGNAL_RUN_LAST,
1343                   G_STRUCT_OFFSET (GtkTreeViewClass, row_expanded),
1344                   NULL, NULL,
1345                   _gtk_marshal_VOID__BOXED_BOXED,
1346                   G_TYPE_NONE, 2,
1347                   GTK_TYPE_TREE_ITER,
1348                   GTK_TYPE_TREE_PATH);
1349
1350   /**
1351    * GtkTreeView::row-collapsed:
1352    * @tree_view: the object on which the signal is emitted
1353    * @iter: the tree iter of the collapsed row
1354    * @path: a tree path that points to the row
1355    *
1356    * The given row has been collapsed (child nodes are hidden).
1357    */
1358   tree_view_signals[ROW_COLLAPSED] =
1359     g_signal_new (I_("row-collapsed"),
1360                   G_TYPE_FROM_CLASS (o_class),
1361                   G_SIGNAL_RUN_LAST,
1362                   G_STRUCT_OFFSET (GtkTreeViewClass, row_collapsed),
1363                   NULL, NULL,
1364                   _gtk_marshal_VOID__BOXED_BOXED,
1365                   G_TYPE_NONE, 2,
1366                   GTK_TYPE_TREE_ITER,
1367                   GTK_TYPE_TREE_PATH);
1368
1369   /**
1370    * GtkTreeView::columns-changed:
1371    * @tree_view: the object on which the signal is emitted
1372    *
1373    * The number of columns of the treeview has changed.
1374    */
1375   tree_view_signals[COLUMNS_CHANGED] =
1376     g_signal_new (I_("columns-changed"),
1377                   G_TYPE_FROM_CLASS (o_class),
1378                   G_SIGNAL_RUN_LAST,
1379                   G_STRUCT_OFFSET (GtkTreeViewClass, columns_changed),
1380                   NULL, NULL,
1381                   _gtk_marshal_VOID__VOID,
1382                   G_TYPE_NONE, 0);
1383
1384   /**
1385    * GtkTreeView::cursor-changed:
1386    * @tree_view: the object on which the signal is emitted
1387    *
1388    * The position of the cursor (focused cell) has changed.
1389    */
1390   tree_view_signals[CURSOR_CHANGED] =
1391     g_signal_new (I_("cursor-changed"),
1392                   G_TYPE_FROM_CLASS (o_class),
1393                   G_SIGNAL_RUN_LAST,
1394                   G_STRUCT_OFFSET (GtkTreeViewClass, cursor_changed),
1395                   NULL, NULL,
1396                   _gtk_marshal_VOID__VOID,
1397                   G_TYPE_NONE, 0);
1398
1399   tree_view_signals[MOVE_CURSOR] =
1400     g_signal_new (I_("move-cursor"),
1401                   G_TYPE_FROM_CLASS (o_class),
1402                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1403                   G_STRUCT_OFFSET (GtkTreeViewClass, move_cursor),
1404                   NULL, NULL,
1405                   _gtk_marshal_BOOLEAN__ENUM_INT,
1406                   G_TYPE_BOOLEAN, 2,
1407                   GTK_TYPE_MOVEMENT_STEP,
1408                   G_TYPE_INT);
1409
1410   tree_view_signals[SELECT_ALL] =
1411     g_signal_new (I_("select-all"),
1412                   G_TYPE_FROM_CLASS (o_class),
1413                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1414                   G_STRUCT_OFFSET (GtkTreeViewClass, select_all),
1415                   NULL, NULL,
1416                   _gtk_marshal_BOOLEAN__VOID,
1417                   G_TYPE_BOOLEAN, 0);
1418
1419   tree_view_signals[UNSELECT_ALL] =
1420     g_signal_new (I_("unselect-all"),
1421                   G_TYPE_FROM_CLASS (o_class),
1422                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1423                   G_STRUCT_OFFSET (GtkTreeViewClass, unselect_all),
1424                   NULL, NULL,
1425                   _gtk_marshal_BOOLEAN__VOID,
1426                   G_TYPE_BOOLEAN, 0);
1427
1428   tree_view_signals[SELECT_CURSOR_ROW] =
1429     g_signal_new (I_("select-cursor-row"),
1430                   G_TYPE_FROM_CLASS (o_class),
1431                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1432                   G_STRUCT_OFFSET (GtkTreeViewClass, select_cursor_row),
1433                   NULL, NULL,
1434                   _gtk_marshal_BOOLEAN__BOOLEAN,
1435                   G_TYPE_BOOLEAN, 1,
1436                   G_TYPE_BOOLEAN);
1437
1438   tree_view_signals[TOGGLE_CURSOR_ROW] =
1439     g_signal_new (I_("toggle-cursor-row"),
1440                   G_TYPE_FROM_CLASS (o_class),
1441                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1442                   G_STRUCT_OFFSET (GtkTreeViewClass, toggle_cursor_row),
1443                   NULL, NULL,
1444                   _gtk_marshal_BOOLEAN__VOID,
1445                   G_TYPE_BOOLEAN, 0);
1446
1447   tree_view_signals[EXPAND_COLLAPSE_CURSOR_ROW] =
1448     g_signal_new (I_("expand-collapse-cursor-row"),
1449                   G_TYPE_FROM_CLASS (o_class),
1450                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1451                   G_STRUCT_OFFSET (GtkTreeViewClass, expand_collapse_cursor_row),
1452                   NULL, NULL,
1453                   _gtk_marshal_BOOLEAN__BOOLEAN_BOOLEAN_BOOLEAN,
1454                   G_TYPE_BOOLEAN, 3,
1455                   G_TYPE_BOOLEAN,
1456                   G_TYPE_BOOLEAN,
1457                   G_TYPE_BOOLEAN);
1458
1459   tree_view_signals[SELECT_CURSOR_PARENT] =
1460     g_signal_new (I_("select-cursor-parent"),
1461                   G_TYPE_FROM_CLASS (o_class),
1462                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1463                   G_STRUCT_OFFSET (GtkTreeViewClass, select_cursor_parent),
1464                   NULL, NULL,
1465                   _gtk_marshal_BOOLEAN__VOID,
1466                   G_TYPE_BOOLEAN, 0);
1467
1468   tree_view_signals[START_INTERACTIVE_SEARCH] =
1469     g_signal_new (I_("start-interactive-search"),
1470                   G_TYPE_FROM_CLASS (o_class),
1471                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1472                   G_STRUCT_OFFSET (GtkTreeViewClass, start_interactive_search),
1473                   NULL, NULL,
1474                   _gtk_marshal_BOOLEAN__VOID,
1475                   G_TYPE_BOOLEAN, 0);
1476
1477   /* Key bindings */
1478   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_Up, 0, TRUE,
1479                                   GTK_MOVEMENT_DISPLAY_LINES, -1);
1480   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_KP_Up, 0, TRUE,
1481                                   GTK_MOVEMENT_DISPLAY_LINES, -1);
1482
1483   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_Down, 0, TRUE,
1484                                   GTK_MOVEMENT_DISPLAY_LINES, 1);
1485   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_KP_Down, 0, TRUE,
1486                                   GTK_MOVEMENT_DISPLAY_LINES, 1);
1487
1488   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_p, GDK_CONTROL_MASK, FALSE,
1489                                   GTK_MOVEMENT_DISPLAY_LINES, -1);
1490
1491   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_n, GDK_CONTROL_MASK, FALSE,
1492                                   GTK_MOVEMENT_DISPLAY_LINES, 1);
1493
1494   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_Home, 0, TRUE,
1495                                   GTK_MOVEMENT_BUFFER_ENDS, -1);
1496   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_KP_Home, 0, TRUE,
1497                                   GTK_MOVEMENT_BUFFER_ENDS, -1);
1498
1499   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_End, 0, TRUE,
1500                                   GTK_MOVEMENT_BUFFER_ENDS, 1);
1501   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_KP_End, 0, TRUE,
1502                                   GTK_MOVEMENT_BUFFER_ENDS, 1);
1503
1504   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_Page_Up, 0, TRUE,
1505                                   GTK_MOVEMENT_PAGES, -1);
1506   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_KP_Page_Up, 0, TRUE,
1507                                   GTK_MOVEMENT_PAGES, -1);
1508
1509   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_Page_Down, 0, TRUE,
1510                                   GTK_MOVEMENT_PAGES, 1);
1511   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_KP_Page_Down, 0, TRUE,
1512                                   GTK_MOVEMENT_PAGES, 1);
1513
1514
1515   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Right, 0, "move-cursor", 2,
1516                                 G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
1517                                 G_TYPE_INT, 1);
1518
1519   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Left, 0, "move-cursor", 2,
1520                                 G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
1521                                 G_TYPE_INT, -1);
1522
1523   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_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_KP_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_Right, GDK_CONTROL_MASK,
1532                                 "move-cursor", 2,
1533                                 G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
1534                                 G_TYPE_INT, 1);
1535
1536   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Left, GDK_CONTROL_MASK,
1537                                 "move-cursor", 2,
1538                                 G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
1539                                 G_TYPE_INT, -1);
1540
1541   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Right, GDK_CONTROL_MASK,
1542                                 "move-cursor", 2,
1543                                 G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
1544                                 G_TYPE_INT, 1);
1545
1546   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Left, GDK_CONTROL_MASK,
1547                                 "move-cursor", 2,
1548                                 G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
1549                                 G_TYPE_INT, -1);
1550
1551   gtk_binding_entry_add_signal (binding_set, GDK_KEY_space, GDK_CONTROL_MASK, "toggle-cursor-row", 0);
1552   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Space, GDK_CONTROL_MASK, "toggle-cursor-row", 0);
1553
1554   gtk_binding_entry_add_signal (binding_set, GDK_KEY_a, GDK_CONTROL_MASK, "select-all", 0);
1555   gtk_binding_entry_add_signal (binding_set, GDK_KEY_slash, GDK_CONTROL_MASK, "select-all", 0);
1556
1557   gtk_binding_entry_add_signal (binding_set, GDK_KEY_A, GDK_CONTROL_MASK | GDK_SHIFT_MASK, "unselect-all", 0);
1558   gtk_binding_entry_add_signal (binding_set, GDK_KEY_backslash, GDK_CONTROL_MASK, "unselect-all", 0);
1559
1560   gtk_binding_entry_add_signal (binding_set, GDK_KEY_space, GDK_SHIFT_MASK, "select-cursor-row", 1,
1561                                 G_TYPE_BOOLEAN, TRUE);
1562   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Space, GDK_SHIFT_MASK, "select-cursor-row", 1,
1563                                 G_TYPE_BOOLEAN, TRUE);
1564
1565   gtk_binding_entry_add_signal (binding_set, GDK_KEY_space, 0, "select-cursor-row", 1,
1566                                 G_TYPE_BOOLEAN, TRUE);
1567   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Space, 0, "select-cursor-row", 1,
1568                                 G_TYPE_BOOLEAN, TRUE);
1569   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Return, 0, "select-cursor-row", 1,
1570                                 G_TYPE_BOOLEAN, TRUE);
1571   gtk_binding_entry_add_signal (binding_set, GDK_KEY_ISO_Enter, 0, "select-cursor-row", 1,
1572                                 G_TYPE_BOOLEAN, TRUE);
1573   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Enter, 0, "select-cursor-row", 1,
1574                                 G_TYPE_BOOLEAN, TRUE);
1575
1576   /* expand and collapse rows */
1577   gtk_binding_entry_add_signal (binding_set, GDK_KEY_plus, 0, "expand-collapse-cursor-row", 3,
1578                                 G_TYPE_BOOLEAN, TRUE,
1579                                 G_TYPE_BOOLEAN, TRUE,
1580                                 G_TYPE_BOOLEAN, FALSE);
1581
1582   gtk_binding_entry_add_signal (binding_set, GDK_KEY_asterisk, 0,
1583                                 "expand-collapse-cursor-row", 3,
1584                                 G_TYPE_BOOLEAN, TRUE,
1585                                 G_TYPE_BOOLEAN, TRUE,
1586                                 G_TYPE_BOOLEAN, TRUE);
1587   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Multiply, 0,
1588                                 "expand-collapse-cursor-row", 3,
1589                                 G_TYPE_BOOLEAN, TRUE,
1590                                 G_TYPE_BOOLEAN, TRUE,
1591                                 G_TYPE_BOOLEAN, TRUE);
1592
1593   gtk_binding_entry_add_signal (binding_set, GDK_KEY_slash, 0,
1594                                 "expand-collapse-cursor-row", 3,
1595                                 G_TYPE_BOOLEAN, TRUE,
1596                                 G_TYPE_BOOLEAN, FALSE,
1597                                 G_TYPE_BOOLEAN, FALSE);
1598   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Divide, 0,
1599                                 "expand-collapse-cursor-row", 3,
1600                                 G_TYPE_BOOLEAN, TRUE,
1601                                 G_TYPE_BOOLEAN, FALSE,
1602                                 G_TYPE_BOOLEAN, FALSE);
1603
1604   /* Not doable on US keyboards */
1605   gtk_binding_entry_add_signal (binding_set, GDK_KEY_plus, GDK_SHIFT_MASK, "expand-collapse-cursor-row", 3,
1606                                 G_TYPE_BOOLEAN, TRUE,
1607                                 G_TYPE_BOOLEAN, TRUE,
1608                                 G_TYPE_BOOLEAN, TRUE);
1609   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Add, 0, "expand-collapse-cursor-row", 3,
1610                                 G_TYPE_BOOLEAN, TRUE,
1611                                 G_TYPE_BOOLEAN, TRUE,
1612                                 G_TYPE_BOOLEAN, FALSE);
1613   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Add, 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, GDK_SHIFT_MASK, "expand-collapse-cursor-row", 3,
1618                                 G_TYPE_BOOLEAN, TRUE,
1619                                 G_TYPE_BOOLEAN, TRUE,
1620                                 G_TYPE_BOOLEAN, TRUE);
1621   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Right, GDK_SHIFT_MASK,
1622                                 "expand-collapse-cursor-row", 3,
1623                                 G_TYPE_BOOLEAN, FALSE,
1624                                 G_TYPE_BOOLEAN, TRUE,
1625                                 G_TYPE_BOOLEAN, TRUE);
1626   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Right, GDK_SHIFT_MASK,
1627                                 "expand-collapse-cursor-row", 3,
1628                                 G_TYPE_BOOLEAN, FALSE,
1629                                 G_TYPE_BOOLEAN, TRUE,
1630                                 G_TYPE_BOOLEAN, TRUE);
1631   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Right,
1632                                 GDK_CONTROL_MASK | GDK_SHIFT_MASK,
1633                                 "expand-collapse-cursor-row", 3,
1634                                 G_TYPE_BOOLEAN, FALSE,
1635                                 G_TYPE_BOOLEAN, TRUE,
1636                                 G_TYPE_BOOLEAN, TRUE);
1637   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Right,
1638                                 GDK_CONTROL_MASK | GDK_SHIFT_MASK,
1639                                 "expand-collapse-cursor-row", 3,
1640                                 G_TYPE_BOOLEAN, FALSE,
1641                                 G_TYPE_BOOLEAN, TRUE,
1642                                 G_TYPE_BOOLEAN, TRUE);
1643
1644   gtk_binding_entry_add_signal (binding_set, GDK_KEY_minus, 0, "expand-collapse-cursor-row", 3,
1645                                 G_TYPE_BOOLEAN, TRUE,
1646                                 G_TYPE_BOOLEAN, FALSE,
1647                                 G_TYPE_BOOLEAN, FALSE);
1648   gtk_binding_entry_add_signal (binding_set, GDK_KEY_minus, GDK_SHIFT_MASK, "expand-collapse-cursor-row", 3,
1649                                 G_TYPE_BOOLEAN, TRUE,
1650                                 G_TYPE_BOOLEAN, FALSE,
1651                                 G_TYPE_BOOLEAN, TRUE);
1652   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Subtract, 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_KP_Subtract, 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_Left, GDK_SHIFT_MASK,
1661                                 "expand-collapse-cursor-row", 3,
1662                                 G_TYPE_BOOLEAN, FALSE,
1663                                 G_TYPE_BOOLEAN, FALSE,
1664                                 G_TYPE_BOOLEAN, TRUE);
1665   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Left, GDK_SHIFT_MASK,
1666                                 "expand-collapse-cursor-row", 3,
1667                                 G_TYPE_BOOLEAN, FALSE,
1668                                 G_TYPE_BOOLEAN, FALSE,
1669                                 G_TYPE_BOOLEAN, TRUE);
1670   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Left,
1671                                 GDK_CONTROL_MASK | GDK_SHIFT_MASK,
1672                                 "expand-collapse-cursor-row", 3,
1673                                 G_TYPE_BOOLEAN, FALSE,
1674                                 G_TYPE_BOOLEAN, FALSE,
1675                                 G_TYPE_BOOLEAN, TRUE);
1676   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Left,
1677                                 GDK_CONTROL_MASK | GDK_SHIFT_MASK,
1678                                 "expand-collapse-cursor-row", 3,
1679                                 G_TYPE_BOOLEAN, FALSE,
1680                                 G_TYPE_BOOLEAN, FALSE,
1681                                 G_TYPE_BOOLEAN, TRUE);
1682
1683   gtk_binding_entry_add_signal (binding_set, GDK_KEY_BackSpace, 0, "select-cursor-parent", 0);
1684   gtk_binding_entry_add_signal (binding_set, GDK_KEY_BackSpace, GDK_CONTROL_MASK, "select-cursor-parent", 0);
1685
1686   gtk_binding_entry_add_signal (binding_set, GDK_KEY_f, GDK_CONTROL_MASK, "start-interactive-search", 0);
1687
1688   gtk_binding_entry_add_signal (binding_set, GDK_KEY_F, GDK_CONTROL_MASK, "start-interactive-search", 0);
1689
1690   g_type_class_add_private (o_class, sizeof (GtkTreeViewPrivate));
1691
1692   gtk_widget_class_set_accessible_type (widget_class, GTK_TYPE_TREE_VIEW_ACCESSIBLE);
1693 }
1694
1695 static void
1696 gtk_tree_view_init (GtkTreeView *tree_view)
1697 {
1698   tree_view->priv = G_TYPE_INSTANCE_GET_PRIVATE (tree_view, GTK_TYPE_TREE_VIEW, GtkTreeViewPrivate);
1699
1700   gtk_widget_set_can_focus (GTK_WIDGET (tree_view), TRUE);
1701   gtk_widget_set_redraw_on_allocate (GTK_WIDGET (tree_view), FALSE);
1702
1703   tree_view->priv->show_expanders = TRUE;
1704   tree_view->priv->draw_keyfocus = TRUE;
1705   tree_view->priv->headers_visible = TRUE;
1706
1707   /* We need some padding */
1708   tree_view->priv->dy = 0;
1709   tree_view->priv->cursor_offset = 0;
1710   tree_view->priv->n_columns = 0;
1711   tree_view->priv->header_height = 1;
1712   tree_view->priv->x_drag = 0;
1713   tree_view->priv->drag_pos = -1;
1714   tree_view->priv->header_has_focus = FALSE;
1715   tree_view->priv->pressed_button = -1;
1716   tree_view->priv->press_start_x = -1;
1717   tree_view->priv->press_start_y = -1;
1718   tree_view->priv->reorderable = FALSE;
1719   tree_view->priv->presize_handler_timer = 0;
1720   tree_view->priv->scroll_sync_timer = 0;
1721   tree_view->priv->fixed_height = -1;
1722   tree_view->priv->fixed_height_mode = FALSE;
1723   tree_view->priv->fixed_height_check = 0;
1724   tree_view->priv->selection = _gtk_tree_selection_new_with_tree_view (tree_view);
1725   tree_view->priv->enable_search = TRUE;
1726   tree_view->priv->search_column = -1;
1727   tree_view->priv->search_position_func = gtk_tree_view_search_position_func;
1728   tree_view->priv->search_equal_func = gtk_tree_view_search_equal_func;
1729   tree_view->priv->search_custom_entry_set = FALSE;
1730   tree_view->priv->typeselect_flush_timeout = 0;
1731   tree_view->priv->init_hadjust_value = TRUE;
1732   tree_view->priv->width = 0;
1733
1734   tree_view->priv->hover_selection = FALSE;
1735   tree_view->priv->hover_expand = FALSE;
1736
1737   tree_view->priv->level_indentation = 0;
1738
1739   tree_view->priv->rubber_banding_enable = FALSE;
1740
1741   tree_view->priv->grid_lines = GTK_TREE_VIEW_GRID_LINES_NONE;
1742   tree_view->priv->tree_lines_enabled = FALSE;
1743
1744   tree_view->priv->tooltip_column = -1;
1745
1746   tree_view->priv->post_validation_flag = FALSE;
1747
1748   tree_view->priv->last_button_x = -1;
1749   tree_view->priv->last_button_y = -1;
1750
1751   tree_view->priv->event_last_x = -10000;
1752   tree_view->priv->event_last_y = -10000;
1753
1754   gtk_tree_view_set_vadjustment (tree_view, NULL);
1755   gtk_tree_view_set_hadjustment (tree_view, NULL);
1756 }
1757
1758 \f
1759
1760 /* GObject Methods
1761  */
1762
1763 static void
1764 gtk_tree_view_set_property (GObject         *object,
1765                             guint            prop_id,
1766                             const GValue    *value,
1767                             GParamSpec      *pspec)
1768 {
1769   GtkTreeView *tree_view;
1770
1771   tree_view = GTK_TREE_VIEW (object);
1772
1773   switch (prop_id)
1774     {
1775     case PROP_MODEL:
1776       gtk_tree_view_set_model (tree_view, g_value_get_object (value));
1777       break;
1778     case PROP_HADJUSTMENT:
1779       gtk_tree_view_set_hadjustment (tree_view, g_value_get_object (value));
1780       break;
1781     case PROP_VADJUSTMENT:
1782       gtk_tree_view_set_vadjustment (tree_view, g_value_get_object (value));
1783       break;
1784     case PROP_HSCROLL_POLICY:
1785       tree_view->priv->hscroll_policy = g_value_get_enum (value);
1786       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
1787       break;
1788     case PROP_VSCROLL_POLICY:
1789       tree_view->priv->vscroll_policy = g_value_get_enum (value);
1790       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
1791       break;
1792     case PROP_HEADERS_VISIBLE:
1793       gtk_tree_view_set_headers_visible (tree_view, g_value_get_boolean (value));
1794       break;
1795     case PROP_HEADERS_CLICKABLE:
1796       gtk_tree_view_set_headers_clickable (tree_view, g_value_get_boolean (value));
1797       break;
1798     case PROP_EXPANDER_COLUMN:
1799       gtk_tree_view_set_expander_column (tree_view, g_value_get_object (value));
1800       break;
1801     case PROP_REORDERABLE:
1802       gtk_tree_view_set_reorderable (tree_view, g_value_get_boolean (value));
1803       break;
1804     case PROP_RULES_HINT:
1805       gtk_tree_view_set_rules_hint (tree_view, g_value_get_boolean (value));
1806       break;
1807     case PROP_ENABLE_SEARCH:
1808       gtk_tree_view_set_enable_search (tree_view, g_value_get_boolean (value));
1809       break;
1810     case PROP_SEARCH_COLUMN:
1811       gtk_tree_view_set_search_column (tree_view, g_value_get_int (value));
1812       break;
1813     case PROP_FIXED_HEIGHT_MODE:
1814       gtk_tree_view_set_fixed_height_mode (tree_view, g_value_get_boolean (value));
1815       break;
1816     case PROP_HOVER_SELECTION:
1817       tree_view->priv->hover_selection = g_value_get_boolean (value);
1818       break;
1819     case PROP_HOVER_EXPAND:
1820       tree_view->priv->hover_expand = g_value_get_boolean (value);
1821       break;
1822     case PROP_SHOW_EXPANDERS:
1823       gtk_tree_view_set_show_expanders (tree_view, g_value_get_boolean (value));
1824       break;
1825     case PROP_LEVEL_INDENTATION:
1826       tree_view->priv->level_indentation = g_value_get_int (value);
1827       break;
1828     case PROP_RUBBER_BANDING:
1829       tree_view->priv->rubber_banding_enable = g_value_get_boolean (value);
1830       break;
1831     case PROP_ENABLE_GRID_LINES:
1832       gtk_tree_view_set_grid_lines (tree_view, g_value_get_enum (value));
1833       break;
1834     case PROP_ENABLE_TREE_LINES:
1835       gtk_tree_view_set_enable_tree_lines (tree_view, g_value_get_boolean (value));
1836       break;
1837     case PROP_TOOLTIP_COLUMN:
1838       gtk_tree_view_set_tooltip_column (tree_view, g_value_get_int (value));
1839       break;
1840     default:
1841       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1842       break;
1843     }
1844 }
1845
1846 static void
1847 gtk_tree_view_get_property (GObject    *object,
1848                             guint       prop_id,
1849                             GValue     *value,
1850                             GParamSpec *pspec)
1851 {
1852   GtkTreeView *tree_view;
1853
1854   tree_view = GTK_TREE_VIEW (object);
1855
1856   switch (prop_id)
1857     {
1858     case PROP_MODEL:
1859       g_value_set_object (value, tree_view->priv->model);
1860       break;
1861     case PROP_HADJUSTMENT:
1862       g_value_set_object (value, tree_view->priv->hadjustment);
1863       break;
1864     case PROP_VADJUSTMENT:
1865       g_value_set_object (value, tree_view->priv->vadjustment);
1866       break;
1867     case PROP_HSCROLL_POLICY:
1868       g_value_set_enum (value, tree_view->priv->hscroll_policy);
1869       break;
1870     case PROP_VSCROLL_POLICY:
1871       g_value_set_enum (value, tree_view->priv->vscroll_policy);
1872       break;
1873     case PROP_HEADERS_VISIBLE:
1874       g_value_set_boolean (value, gtk_tree_view_get_headers_visible (tree_view));
1875       break;
1876     case PROP_HEADERS_CLICKABLE:
1877       g_value_set_boolean (value, gtk_tree_view_get_headers_clickable (tree_view));
1878       break;
1879     case PROP_EXPANDER_COLUMN:
1880       g_value_set_object (value, tree_view->priv->expander_column);
1881       break;
1882     case PROP_REORDERABLE:
1883       g_value_set_boolean (value, tree_view->priv->reorderable);
1884       break;
1885     case PROP_RULES_HINT:
1886       g_value_set_boolean (value, tree_view->priv->has_rules);
1887       break;
1888     case PROP_ENABLE_SEARCH:
1889       g_value_set_boolean (value, tree_view->priv->enable_search);
1890       break;
1891     case PROP_SEARCH_COLUMN:
1892       g_value_set_int (value, tree_view->priv->search_column);
1893       break;
1894     case PROP_FIXED_HEIGHT_MODE:
1895       g_value_set_boolean (value, tree_view->priv->fixed_height_mode);
1896       break;
1897     case PROP_HOVER_SELECTION:
1898       g_value_set_boolean (value, tree_view->priv->hover_selection);
1899       break;
1900     case PROP_HOVER_EXPAND:
1901       g_value_set_boolean (value, tree_view->priv->hover_expand);
1902       break;
1903     case PROP_SHOW_EXPANDERS:
1904       g_value_set_boolean (value, tree_view->priv->show_expanders);
1905       break;
1906     case PROP_LEVEL_INDENTATION:
1907       g_value_set_int (value, tree_view->priv->level_indentation);
1908       break;
1909     case PROP_RUBBER_BANDING:
1910       g_value_set_boolean (value, tree_view->priv->rubber_banding_enable);
1911       break;
1912     case PROP_ENABLE_GRID_LINES:
1913       g_value_set_enum (value, tree_view->priv->grid_lines);
1914       break;
1915     case PROP_ENABLE_TREE_LINES:
1916       g_value_set_boolean (value, tree_view->priv->tree_lines_enabled);
1917       break;
1918     case PROP_TOOLTIP_COLUMN:
1919       g_value_set_int (value, tree_view->priv->tooltip_column);
1920       break;
1921     default:
1922       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1923       break;
1924     }
1925 }
1926
1927 static void
1928 gtk_tree_view_finalize (GObject *object)
1929 {
1930   G_OBJECT_CLASS (gtk_tree_view_parent_class)->finalize (object);
1931 }
1932
1933
1934 static GtkBuildableIface *parent_buildable_iface;
1935
1936 static void
1937 gtk_tree_view_buildable_init (GtkBuildableIface *iface)
1938 {
1939   parent_buildable_iface = g_type_interface_peek_parent (iface);
1940   iface->add_child = gtk_tree_view_buildable_add_child;
1941   iface->get_internal_child = gtk_tree_view_buildable_get_internal_child;
1942 }
1943
1944 static void
1945 gtk_tree_view_buildable_add_child (GtkBuildable *tree_view,
1946                                    GtkBuilder  *builder,
1947                                    GObject     *child,
1948                                    const gchar *type)
1949 {
1950   gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), GTK_TREE_VIEW_COLUMN (child));
1951 }
1952
1953 static GObject *
1954 gtk_tree_view_buildable_get_internal_child (GtkBuildable      *buildable,
1955                                             GtkBuilder        *builder,
1956                                             const gchar       *childname)
1957 {
1958     if (strcmp (childname, "selection") == 0)
1959       return G_OBJECT (GTK_TREE_VIEW (buildable)->priv->selection);
1960
1961     return parent_buildable_iface->get_internal_child (buildable,
1962                                                        builder,
1963                                                        childname);
1964 }
1965
1966 /* GtkWidget Methods
1967  */
1968
1969 static void
1970 gtk_tree_view_free_rbtree (GtkTreeView *tree_view)
1971 {
1972   _gtk_rbtree_free (tree_view->priv->tree);
1973
1974   tree_view->priv->tree = NULL;
1975   tree_view->priv->button_pressed_node = NULL;
1976   tree_view->priv->button_pressed_tree = NULL;
1977   tree_view->priv->prelight_tree = NULL;
1978   tree_view->priv->prelight_node = NULL;
1979   tree_view->priv->expanded_collapsed_node = NULL;
1980   tree_view->priv->expanded_collapsed_tree = NULL;
1981 }
1982
1983 static void
1984 gtk_tree_view_destroy (GtkWidget *widget)
1985 {
1986   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
1987   GList *list;
1988
1989   gtk_tree_view_stop_editing (tree_view, TRUE);
1990
1991   if (tree_view->priv->columns != NULL)
1992     {
1993       list = tree_view->priv->columns;
1994       while (list)
1995         {
1996           GtkTreeViewColumn *column;
1997           column = GTK_TREE_VIEW_COLUMN (list->data);
1998           list = list->next;
1999           gtk_tree_view_remove_column (tree_view, column);
2000         }
2001       tree_view->priv->columns = NULL;
2002     }
2003
2004   if (tree_view->priv->tree != NULL)
2005     {
2006       gtk_tree_view_unref_and_check_selection_tree (tree_view, tree_view->priv->tree);
2007
2008       gtk_tree_view_free_rbtree (tree_view);
2009     }
2010
2011   if (tree_view->priv->selection != NULL)
2012     {
2013       _gtk_tree_selection_set_tree_view (tree_view->priv->selection, NULL);
2014       g_object_unref (tree_view->priv->selection);
2015       tree_view->priv->selection = NULL;
2016     }
2017
2018   if (tree_view->priv->scroll_to_path != NULL)
2019     {
2020       gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
2021       tree_view->priv->scroll_to_path = NULL;
2022     }
2023
2024   if (tree_view->priv->drag_dest_row != NULL)
2025     {
2026       gtk_tree_row_reference_free (tree_view->priv->drag_dest_row);
2027       tree_view->priv->drag_dest_row = NULL;
2028     }
2029
2030   if (tree_view->priv->top_row != NULL)
2031     {
2032       gtk_tree_row_reference_free (tree_view->priv->top_row);
2033       tree_view->priv->top_row = NULL;
2034     }
2035
2036   if (tree_view->priv->column_drop_func_data &&
2037       tree_view->priv->column_drop_func_data_destroy)
2038     {
2039       tree_view->priv->column_drop_func_data_destroy (tree_view->priv->column_drop_func_data);
2040       tree_view->priv->column_drop_func_data = NULL;
2041     }
2042
2043   if (tree_view->priv->destroy_count_destroy &&
2044       tree_view->priv->destroy_count_data)
2045     {
2046       tree_view->priv->destroy_count_destroy (tree_view->priv->destroy_count_data);
2047       tree_view->priv->destroy_count_data = NULL;
2048     }
2049
2050   gtk_tree_row_reference_free (tree_view->priv->cursor);
2051   tree_view->priv->cursor = NULL;
2052
2053   gtk_tree_row_reference_free (tree_view->priv->anchor);
2054   tree_view->priv->anchor = NULL;
2055
2056   /* destroy interactive search dialog */
2057   if (tree_view->priv->search_window)
2058     {
2059       gtk_widget_destroy (tree_view->priv->search_window);
2060       tree_view->priv->search_window = NULL;
2061       tree_view->priv->search_entry = NULL;
2062       if (tree_view->priv->typeselect_flush_timeout)
2063         {
2064           g_source_remove (tree_view->priv->typeselect_flush_timeout);
2065           tree_view->priv->typeselect_flush_timeout = 0;
2066         }
2067     }
2068
2069   if (tree_view->priv->search_destroy && tree_view->priv->search_user_data)
2070     {
2071       tree_view->priv->search_destroy (tree_view->priv->search_user_data);
2072       tree_view->priv->search_user_data = NULL;
2073     }
2074
2075   if (tree_view->priv->search_position_destroy && tree_view->priv->search_position_user_data)
2076     {
2077       tree_view->priv->search_position_destroy (tree_view->priv->search_position_user_data);
2078       tree_view->priv->search_position_user_data = NULL;
2079     }
2080
2081   if (tree_view->priv->row_separator_destroy && tree_view->priv->row_separator_data)
2082     {
2083       tree_view->priv->row_separator_destroy (tree_view->priv->row_separator_data);
2084       tree_view->priv->row_separator_data = NULL;
2085     }
2086
2087   gtk_tree_view_set_model (tree_view, NULL);
2088
2089   if (tree_view->priv->hadjustment)
2090     {
2091       g_object_unref (tree_view->priv->hadjustment);
2092       tree_view->priv->hadjustment = NULL;
2093     }
2094   if (tree_view->priv->vadjustment)
2095     {
2096       g_object_unref (tree_view->priv->vadjustment);
2097       tree_view->priv->vadjustment = NULL;
2098     }
2099
2100   GTK_WIDGET_CLASS (gtk_tree_view_parent_class)->destroy (widget);
2101 }
2102
2103 /* GtkWidget::map helper */
2104 static void
2105 gtk_tree_view_map_buttons (GtkTreeView *tree_view)
2106 {
2107   GList *list;
2108
2109   g_return_if_fail (gtk_widget_get_mapped (GTK_WIDGET (tree_view)));
2110
2111   if (tree_view->priv->headers_visible)
2112     {
2113       GtkTreeViewColumn *column;
2114       GtkWidget         *button;
2115       GdkWindow         *window;
2116
2117       for (list = tree_view->priv->columns; list; list = list->next)
2118         {
2119           column = list->data;
2120           button = gtk_tree_view_column_get_button (column);
2121
2122           if (gtk_tree_view_column_get_visible (column) && button)
2123             gtk_widget_show_now (button);
2124
2125           if (gtk_widget_get_visible (button) &&
2126               !gtk_widget_get_mapped (button))
2127             gtk_widget_map (button);
2128         }
2129       for (list = tree_view->priv->columns; list; list = list->next)
2130         {
2131           column = list->data;
2132           if (gtk_tree_view_column_get_visible (column) == FALSE)
2133             continue;
2134
2135           window = _gtk_tree_view_column_get_window (column);
2136           if (gtk_tree_view_column_get_resizable (column))
2137             {
2138               gdk_window_raise (window);
2139               gdk_window_show (window);
2140             }
2141           else
2142             gdk_window_hide (window);
2143         }
2144       gdk_window_show (tree_view->priv->header_window);
2145     }
2146 }
2147
2148 static void
2149 gtk_tree_view_map (GtkWidget *widget)
2150 {
2151   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
2152   GList *tmp_list;
2153
2154   gtk_widget_set_mapped (widget, TRUE);
2155
2156   tmp_list = tree_view->priv->children;
2157   while (tmp_list)
2158     {
2159       GtkTreeViewChild *child = tmp_list->data;
2160       tmp_list = tmp_list->next;
2161
2162       if (gtk_widget_get_visible (child->widget))
2163         {
2164           if (!gtk_widget_get_mapped (child->widget))
2165             gtk_widget_map (child->widget);
2166         }
2167     }
2168   gdk_window_show (tree_view->priv->bin_window);
2169
2170   gtk_tree_view_map_buttons (tree_view);
2171
2172   gdk_window_show (gtk_widget_get_window (widget));
2173 }
2174
2175 static void
2176 gtk_tree_view_realize (GtkWidget *widget)
2177 {
2178   GtkAllocation allocation;
2179   GtkStyleContext *context;
2180   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
2181   GdkWindow *window;
2182   GdkWindowAttr attributes;
2183   GList *tmp_list;
2184   gint attributes_mask;
2185
2186   gtk_widget_set_realized (widget, TRUE);
2187
2188   gtk_widget_get_allocation (widget, &allocation);
2189
2190   /* Make the main, clipping window */
2191   attributes.window_type = GDK_WINDOW_CHILD;
2192   attributes.x = allocation.x;
2193   attributes.y = allocation.y;
2194   attributes.width = allocation.width;
2195   attributes.height = allocation.height;
2196   attributes.wclass = GDK_INPUT_OUTPUT;
2197   attributes.visual = gtk_widget_get_visual (widget);
2198   attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK;
2199
2200   attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
2201
2202   window = gdk_window_new (gtk_widget_get_parent_window (widget),
2203                            &attributes, attributes_mask);
2204   gtk_widget_set_window (widget, window);
2205   gdk_window_set_user_data (window, widget);
2206
2207   gtk_widget_get_allocation (widget, &allocation);
2208
2209   /* Make the window for the tree */
2210   attributes.x = 0;
2211   attributes.y = gtk_tree_view_get_effective_header_height (tree_view);
2212   attributes.width = MAX (tree_view->priv->width, allocation.width);
2213   attributes.height = allocation.height;
2214   attributes.event_mask = (GDK_EXPOSURE_MASK |
2215                            GDK_SCROLL_MASK |
2216                            GDK_POINTER_MOTION_MASK |
2217                            GDK_ENTER_NOTIFY_MASK |
2218                            GDK_LEAVE_NOTIFY_MASK |
2219                            GDK_BUTTON_PRESS_MASK |
2220                            GDK_BUTTON_RELEASE_MASK |
2221                            gtk_widget_get_events (widget));
2222
2223   tree_view->priv->bin_window = gdk_window_new (window,
2224                                                 &attributes, attributes_mask);
2225   gdk_window_set_user_data (tree_view->priv->bin_window, widget);
2226
2227   gtk_widget_get_allocation (widget, &allocation);
2228
2229   /* Make the column header window */
2230   attributes.x = 0;
2231   attributes.y = 0;
2232   attributes.width = MAX (tree_view->priv->width, allocation.width);
2233   attributes.height = tree_view->priv->header_height;
2234   attributes.event_mask = (GDK_EXPOSURE_MASK |
2235                            GDK_SCROLL_MASK |
2236                            GDK_ENTER_NOTIFY_MASK |
2237                            GDK_LEAVE_NOTIFY_MASK |
2238                            GDK_BUTTON_PRESS_MASK |
2239                            GDK_BUTTON_RELEASE_MASK |
2240                            GDK_KEY_PRESS_MASK |
2241                            GDK_KEY_RELEASE_MASK |
2242                            gtk_widget_get_events (widget));
2243
2244   tree_view->priv->header_window = gdk_window_new (window,
2245                                                    &attributes, attributes_mask);
2246   gdk_window_set_user_data (tree_view->priv->header_window, widget);
2247
2248   context = gtk_widget_get_style_context (widget);
2249
2250   gtk_style_context_save (context);
2251   gtk_style_context_add_class (context, GTK_STYLE_CLASS_VIEW);
2252   gtk_style_context_set_background (context, tree_view->priv->bin_window);
2253   gtk_style_context_restore (context);
2254
2255   gtk_style_context_set_background (context, tree_view->priv->header_window);
2256
2257   tmp_list = tree_view->priv->children;
2258   while (tmp_list)
2259     {
2260       GtkTreeViewChild *child = tmp_list->data;
2261       tmp_list = tmp_list->next;
2262
2263       gtk_widget_set_parent_window (child->widget, tree_view->priv->bin_window);
2264     }
2265
2266   for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list = tmp_list->next)
2267     _gtk_tree_view_column_realize_button (GTK_TREE_VIEW_COLUMN (tmp_list->data));
2268
2269   /* Need to call those here, since they create GCs */
2270   gtk_tree_view_set_grid_lines (tree_view, tree_view->priv->grid_lines);
2271   gtk_tree_view_set_enable_tree_lines (tree_view, tree_view->priv->tree_lines_enabled);
2272
2273   install_presize_handler (tree_view);
2274 }
2275
2276 static void
2277 gtk_tree_view_unrealize (GtkWidget *widget)
2278 {
2279   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
2280   GtkTreeViewPrivate *priv = tree_view->priv;
2281   GtkStyleContext *context;
2282   GList *list;
2283
2284   if (priv->scroll_timeout != 0)
2285     {
2286       g_source_remove (priv->scroll_timeout);
2287       priv->scroll_timeout = 0;
2288     }
2289
2290   if (priv->auto_expand_timeout != 0)
2291     {
2292       g_source_remove (priv->auto_expand_timeout);
2293       priv->auto_expand_timeout = 0;
2294     }
2295
2296   if (priv->open_dest_timeout != 0)
2297     {
2298       g_source_remove (priv->open_dest_timeout);
2299       priv->open_dest_timeout = 0;
2300     }
2301
2302   context = gtk_widget_get_style_context (widget);
2303   gtk_style_context_cancel_animations (context, NULL);
2304
2305   if (priv->presize_handler_timer != 0)
2306     {
2307       g_source_remove (priv->presize_handler_timer);
2308       priv->presize_handler_timer = 0;
2309     }
2310
2311   if (priv->validate_rows_timer != 0)
2312     {
2313       g_source_remove (priv->validate_rows_timer);
2314       priv->validate_rows_timer = 0;
2315     }
2316
2317   if (priv->scroll_sync_timer != 0)
2318     {
2319       g_source_remove (priv->scroll_sync_timer);
2320       priv->scroll_sync_timer = 0;
2321     }
2322
2323   if (priv->typeselect_flush_timeout)
2324     {
2325       g_source_remove (priv->typeselect_flush_timeout);
2326       priv->typeselect_flush_timeout = 0;
2327     }
2328
2329   for (list = priv->columns; list; list = list->next)
2330     _gtk_tree_view_column_unrealize_button (GTK_TREE_VIEW_COLUMN (list->data));
2331
2332   gdk_window_set_user_data (priv->bin_window, NULL);
2333   gdk_window_destroy (priv->bin_window);
2334   priv->bin_window = NULL;
2335
2336   gdk_window_set_user_data (priv->header_window, NULL);
2337   gdk_window_destroy (priv->header_window);
2338   priv->header_window = NULL;
2339
2340   if (priv->drag_window)
2341     {
2342       gdk_window_set_user_data (priv->drag_window, NULL);
2343       gdk_window_destroy (priv->drag_window);
2344       priv->drag_window = NULL;
2345     }
2346
2347   if (priv->drag_highlight_window)
2348     {
2349       gdk_window_set_user_data (priv->drag_highlight_window, NULL);
2350       gdk_window_destroy (priv->drag_highlight_window);
2351       priv->drag_highlight_window = NULL;
2352     }
2353
2354   GTK_WIDGET_CLASS (gtk_tree_view_parent_class)->unrealize (widget);
2355 }
2356
2357 /* GtkWidget::size_request helper */
2358 static void
2359 gtk_tree_view_size_request_columns (GtkTreeView *tree_view)
2360 {
2361   GList *list;
2362
2363   tree_view->priv->header_height = 0;
2364
2365   for (list = tree_view->priv->columns; list; list = list->next)
2366     {
2367       GtkRequisition     requisition;
2368       GtkTreeViewColumn *column = list->data;
2369       GtkWidget         *button = gtk_tree_view_column_get_button (column);
2370
2371       if (button == NULL)
2372         continue;
2373
2374       gtk_widget_get_preferred_size (button, &requisition, NULL);
2375       tree_view->priv->header_height = MAX (tree_view->priv->header_height, requisition.height);
2376     }
2377 }
2378
2379
2380 /* Called only by ::size_request */
2381 static void
2382 gtk_tree_view_update_size (GtkTreeView *tree_view)
2383 {
2384   GList *list;
2385   GtkTreeViewColumn *column;
2386   gint i;
2387
2388   if (tree_view->priv->model == NULL)
2389     {
2390       tree_view->priv->width = 0;
2391       tree_view->priv->prev_width = 0;
2392       tree_view->priv->height = 0;
2393       return;
2394     }
2395
2396   tree_view->priv->prev_width = tree_view->priv->width;
2397   tree_view->priv->width = 0;
2398
2399   /* keep this in sync with size_allocate below */
2400   for (list = tree_view->priv->columns, i = 0; list; list = list->next, i++)
2401     {
2402       column = list->data;
2403       if (!gtk_tree_view_column_get_visible (column))
2404         continue;
2405
2406       tree_view->priv->width += _gtk_tree_view_column_request_width (column);
2407     }
2408
2409   if (tree_view->priv->tree == NULL)
2410     tree_view->priv->height = 0;
2411   else
2412     tree_view->priv->height = tree_view->priv->tree->root->offset;
2413 }
2414
2415 static void
2416 gtk_tree_view_size_request (GtkWidget      *widget,
2417                             GtkRequisition *requisition,
2418                             gboolean        may_validate)
2419 {
2420   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
2421
2422   if (may_validate)
2423     {
2424       /* we validate some rows initially just to make sure we have some size.
2425        * In practice, with a lot of static lists, this should get a good width.
2426        */
2427       do_validate_rows (tree_view, FALSE);
2428     }
2429
2430   gtk_tree_view_size_request_columns (tree_view);
2431   gtk_tree_view_update_size (GTK_TREE_VIEW (widget));
2432
2433   requisition->width = tree_view->priv->width;
2434   requisition->height = tree_view->priv->height + gtk_tree_view_get_effective_header_height (tree_view);
2435 }
2436
2437 static void
2438 gtk_tree_view_get_preferred_width (GtkWidget *widget,
2439                                    gint      *minimum,
2440                                    gint      *natural)
2441 {
2442   GtkRequisition requisition;
2443
2444   gtk_tree_view_size_request (widget, &requisition, TRUE);
2445
2446   *minimum = *natural = requisition.width;
2447 }
2448
2449 static void
2450 gtk_tree_view_get_preferred_height (GtkWidget *widget,
2451                                     gint      *minimum,
2452                                     gint      *natural)
2453 {
2454   GtkRequisition requisition;
2455
2456   gtk_tree_view_size_request (widget, &requisition, TRUE);
2457
2458   *minimum = *natural = requisition.height;
2459 }
2460
2461 static int
2462 gtk_tree_view_calculate_width_before_expander (GtkTreeView *tree_view)
2463 {
2464   int width = 0;
2465   GList *list;
2466   gboolean rtl;
2467
2468   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
2469   for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
2470        list->data != tree_view->priv->expander_column;
2471        list = (rtl ? list->prev : list->next))
2472     {
2473       GtkTreeViewColumn *column = list->data;
2474
2475       width += gtk_tree_view_column_get_width (column);
2476     }
2477
2478   return width;
2479 }
2480
2481 /* GtkWidget::size_allocate helper */
2482 static void
2483 gtk_tree_view_size_allocate_columns (GtkWidget *widget,
2484                                      gboolean  *width_changed)
2485 {
2486   GtkTreeView *tree_view;
2487   GList *list, *first_column, *last_column;
2488   GtkTreeViewColumn *column;
2489   GtkAllocation widget_allocation;
2490   gint width = 0;
2491   gint extra, extra_per_column, extra_for_last;
2492   gint full_requested_width = 0;
2493   gint number_of_expand_columns = 0;
2494   gboolean rtl;
2495   gboolean update_expand;
2496
2497   tree_view = GTK_TREE_VIEW (widget);
2498
2499   for (last_column = g_list_last (tree_view->priv->columns);
2500        last_column &&
2501        !(gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (last_column->data)));
2502        last_column = last_column->prev)
2503     ;
2504   if (last_column == NULL)
2505     return;
2506
2507   for (first_column = g_list_first (tree_view->priv->columns);
2508        first_column &&
2509        !(gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (first_column->data)));
2510        first_column = first_column->next)
2511     ;
2512
2513   rtl = (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL);
2514
2515   /* find out how many extra space and expandable columns we have */
2516   for (list = tree_view->priv->columns; list != last_column->next; list = list->next)
2517     {
2518       column = (GtkTreeViewColumn *)list->data;
2519
2520       if (!gtk_tree_view_column_get_visible (column))
2521         continue;
2522
2523       full_requested_width += _gtk_tree_view_column_request_width (column);
2524
2525       if (gtk_tree_view_column_get_expand (column))
2526         number_of_expand_columns++;
2527     }
2528
2529   /* Only update the expand value if the width of the widget has changed,
2530    * or the number of expand columns has changed, or if there are no expand
2531    * columns, or if we didn't have an size-allocation yet after the
2532    * last validated node.
2533    */
2534   update_expand = (width_changed && *width_changed == TRUE)
2535       || number_of_expand_columns != tree_view->priv->last_number_of_expand_columns
2536       || number_of_expand_columns == 0
2537       || tree_view->priv->post_validation_flag == TRUE;
2538
2539   tree_view->priv->post_validation_flag = FALSE;
2540
2541   gtk_widget_get_allocation (widget, &widget_allocation);
2542   if (!update_expand)
2543     {
2544       extra = tree_view->priv->last_extra_space;
2545       extra_for_last = MAX (widget_allocation.width - full_requested_width - extra, 0);
2546     }
2547   else
2548     {
2549       extra = MAX (widget_allocation.width - full_requested_width, 0);
2550       extra_for_last = 0;
2551
2552       tree_view->priv->last_extra_space = extra;
2553     }
2554
2555   if (number_of_expand_columns > 0)
2556     extra_per_column = extra/number_of_expand_columns;
2557   else
2558     extra_per_column = 0;
2559
2560   if (update_expand)
2561     {
2562       tree_view->priv->last_extra_space_per_column = extra_per_column;
2563       tree_view->priv->last_number_of_expand_columns = number_of_expand_columns;
2564     }
2565
2566   for (list = (rtl ? last_column : first_column);
2567        list != (rtl ? first_column->prev : last_column->next);
2568        list = (rtl ? list->prev : list->next))
2569     {
2570       gint column_width;
2571
2572       column = list->data;
2573
2574       if (!gtk_tree_view_column_get_visible (column))
2575         continue;
2576
2577       /* We need to handle the dragged button specially.
2578        */
2579       if (column == tree_view->priv->drag_column)
2580         {
2581           GtkAllocation drag_allocation;
2582           GtkWidget    *button;
2583
2584           button = gtk_tree_view_column_get_button (tree_view->priv->drag_column);
2585
2586           drag_allocation.x = 0;
2587           drag_allocation.y = 0;
2588           drag_allocation.width = gdk_window_get_width (tree_view->priv->drag_window);
2589           drag_allocation.height = gdk_window_get_height (tree_view->priv->drag_window);
2590           gtk_widget_size_allocate (button, &drag_allocation);
2591           width += drag_allocation.width;
2592           continue;
2593         }
2594
2595       column_width = _gtk_tree_view_column_request_width (column);
2596
2597       if (gtk_tree_view_column_get_expand (column))
2598         {
2599           if (number_of_expand_columns == 1)
2600             {
2601               /* We add the remander to the last column as
2602                * */
2603               column_width += extra;
2604             }
2605           else
2606             {
2607               column_width += extra_per_column;
2608               extra -= extra_per_column;
2609               number_of_expand_columns --;
2610             }
2611         }
2612       else if (number_of_expand_columns == 0 &&
2613                list == last_column)
2614         {
2615           column_width += extra;
2616         }
2617
2618       /* In addition to expand, the last column can get even more
2619        * extra space so all available space is filled up.
2620        */
2621       if (extra_for_last > 0 && list == last_column)
2622         column_width += extra_for_last;
2623
2624       _gtk_tree_view_column_allocate (column, width, column_width);
2625
2626       width += column_width;
2627     }
2628
2629   /* We change the width here.  The user might have been resizing columns,
2630    * which changes the total width of the tree view.  This is of
2631    * importance for getting the horizontal scroll bar right.
2632    */
2633   if (tree_view->priv->width != width)
2634     {
2635       tree_view->priv->width = width;
2636       if (width_changed)
2637         *width_changed = TRUE;
2638     }
2639 }
2640
2641
2642 static void
2643 gtk_tree_view_size_allocate (GtkWidget     *widget,
2644                              GtkAllocation *allocation)
2645 {
2646   GtkAllocation widget_allocation;
2647   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
2648   GList *tmp_list;
2649   gboolean width_changed = FALSE;
2650   gint old_width;
2651
2652   gtk_widget_get_allocation (widget, &widget_allocation);
2653   old_width = widget_allocation.width;
2654   if (allocation->width != widget_allocation.width)
2655     width_changed = TRUE;
2656
2657   gtk_widget_set_allocation (widget, allocation);
2658
2659   tmp_list = tree_view->priv->children;
2660
2661   while (tmp_list)
2662     {
2663       GtkAllocation allocation;
2664
2665       GtkTreeViewChild *child = tmp_list->data;
2666       tmp_list = tmp_list->next;
2667
2668       /* totally ignore our child's requisition */
2669       allocation.x = child->x;
2670       allocation.y = child->y;
2671       allocation.width = child->width;
2672       allocation.height = child->height;
2673       gtk_widget_size_allocate (child->widget, &allocation);
2674     }
2675
2676   /* We size-allocate the columns first because the width of the
2677    * tree view (used in updating the adjustments below) might change.
2678    */
2679   gtk_tree_view_size_allocate_columns (widget, &width_changed);
2680
2681   g_object_freeze_notify (G_OBJECT (tree_view->priv->hadjustment));
2682   gtk_adjustment_set_page_size (tree_view->priv->hadjustment,
2683                                 allocation->width);
2684   gtk_adjustment_set_page_increment (tree_view->priv->hadjustment,
2685                                      allocation->width * 0.9);
2686   gtk_adjustment_set_step_increment (tree_view->priv->hadjustment,
2687                                      allocation->width * 0.1);
2688   gtk_adjustment_set_lower (tree_view->priv->hadjustment, 0);
2689   gtk_adjustment_set_upper (tree_view->priv->hadjustment,
2690                             MAX (gtk_adjustment_get_page_size (tree_view->priv->hadjustment),
2691                                  tree_view->priv->width));
2692   g_object_thaw_notify (G_OBJECT (tree_view->priv->hadjustment));
2693
2694   if (gtk_widget_get_direction(widget) == GTK_TEXT_DIR_RTL)
2695     {
2696       if (allocation->width < tree_view->priv->width)
2697         {
2698           if (tree_view->priv->init_hadjust_value)
2699             {
2700               gtk_adjustment_set_value (tree_view->priv->hadjustment,
2701                                         MAX (tree_view->priv->width -
2702                                              allocation->width, 0));
2703               tree_view->priv->init_hadjust_value = FALSE;
2704             }
2705           else if (allocation->width != old_width)
2706             {
2707               gtk_adjustment_set_value (tree_view->priv->hadjustment,
2708                                         CLAMP (gtk_adjustment_get_value (tree_view->priv->hadjustment) - allocation->width + old_width,
2709                                                0,
2710                                                tree_view->priv->width - allocation->width));
2711             }
2712           else
2713             gtk_adjustment_set_value (tree_view->priv->hadjustment,
2714                                       CLAMP (tree_view->priv->width - (tree_view->priv->prev_width - gtk_adjustment_get_value (tree_view->priv->hadjustment)),
2715                                              0,
2716                                              tree_view->priv->width - allocation->width));
2717         }
2718       else
2719         {
2720           gtk_adjustment_set_value (tree_view->priv->hadjustment, 0);
2721           tree_view->priv->init_hadjust_value = TRUE;
2722         }
2723     }
2724   else
2725     if (gtk_adjustment_get_value (tree_view->priv->hadjustment) + allocation->width > tree_view->priv->width)
2726       gtk_adjustment_set_value (tree_view->priv->hadjustment,
2727                                 MAX (tree_view->priv->width -
2728                                      allocation->width, 0));
2729
2730   g_object_freeze_notify (G_OBJECT (tree_view->priv->vadjustment));
2731   gtk_adjustment_set_page_size (tree_view->priv->vadjustment,
2732                                 allocation->height -
2733                                 gtk_tree_view_get_effective_header_height (tree_view));
2734   gtk_adjustment_set_step_increment (tree_view->priv->vadjustment,
2735                                      gtk_adjustment_get_page_size (tree_view->priv->vadjustment) * 0.1);
2736   gtk_adjustment_set_page_increment (tree_view->priv->vadjustment,
2737                                      gtk_adjustment_get_page_size (tree_view->priv->vadjustment) * 0.9);
2738   gtk_adjustment_set_lower (tree_view->priv->vadjustment, 0);
2739   gtk_adjustment_set_upper (tree_view->priv->vadjustment,
2740                             MAX (gtk_adjustment_get_page_size (tree_view->priv->vadjustment),
2741                                  tree_view->priv->height));
2742   g_object_thaw_notify (G_OBJECT (tree_view->priv->vadjustment));
2743
2744   /* now the adjustments and window sizes are in sync, we can sync toprow/dy again */
2745   if (tree_view->priv->height <= gtk_adjustment_get_page_size (tree_view->priv->vadjustment))
2746     gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment), 0);
2747   else if (gtk_adjustment_get_value (tree_view->priv->vadjustment) + gtk_adjustment_get_page_size (tree_view->priv->vadjustment) > tree_view->priv->height)
2748     gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment),
2749                               tree_view->priv->height - gtk_adjustment_get_page_size (tree_view->priv->vadjustment));
2750   else if (gtk_tree_row_reference_valid (tree_view->priv->top_row))
2751     gtk_tree_view_top_row_to_dy (tree_view);
2752   else
2753     gtk_tree_view_dy_to_top_row (tree_view);
2754
2755   if (gtk_widget_get_realized (widget))
2756     {
2757       gdk_window_move_resize (gtk_widget_get_window (widget),
2758                               allocation->x, allocation->y,
2759                               allocation->width, allocation->height);
2760       gdk_window_move_resize (tree_view->priv->header_window,
2761                               - (gint) gtk_adjustment_get_value (tree_view->priv->hadjustment),
2762                               0,
2763                               MAX (tree_view->priv->width, allocation->width),
2764                               tree_view->priv->header_height);
2765       gdk_window_move_resize (tree_view->priv->bin_window,
2766                               - (gint) gtk_adjustment_get_value (tree_view->priv->hadjustment),
2767                               gtk_tree_view_get_effective_header_height (tree_view),
2768                               MAX (tree_view->priv->width, allocation->width),
2769                               allocation->height - gtk_tree_view_get_effective_header_height (tree_view));
2770
2771       if (tree_view->priv->tree == NULL)
2772         invalidate_empty_focus (tree_view);
2773
2774       if (width_changed && tree_view->priv->expander_column)
2775         {
2776           /* Might seem awkward, but is the best heuristic I could come up
2777            * with.  Only if the width of the columns before the expander
2778            * changes, we will update the prelight status.  It is this
2779            * width that makes the expander move vertically.  Always updating
2780            * prelight status causes trouble with hover selections.
2781            */
2782           gint width_before_expander;
2783
2784           width_before_expander = gtk_tree_view_calculate_width_before_expander (tree_view);
2785
2786           if (tree_view->priv->prev_width_before_expander
2787               != width_before_expander)
2788               update_prelight (tree_view,
2789                                tree_view->priv->event_last_x,
2790                                tree_view->priv->event_last_y);
2791
2792           tree_view->priv->prev_width_before_expander = width_before_expander;
2793         }
2794     }
2795 }
2796
2797 /* Grabs the focus and unsets the GTK_TREE_VIEW_DRAW_KEYFOCUS flag */
2798 static void
2799 grab_focus_and_unset_draw_keyfocus (GtkTreeView *tree_view)
2800 {
2801   GtkWidget *widget = GTK_WIDGET (tree_view);
2802
2803   if (gtk_widget_get_can_focus (widget) && !gtk_widget_has_focus (widget))
2804     gtk_widget_grab_focus (widget);
2805   tree_view->priv->draw_keyfocus = 0;
2806 }
2807
2808 static inline gboolean
2809 row_is_separator (GtkTreeView *tree_view,
2810                   GtkTreeIter *iter,
2811                   GtkTreePath *path)
2812 {
2813   gboolean is_separator = FALSE;
2814
2815   if (tree_view->priv->row_separator_func)
2816     {
2817       GtkTreeIter tmpiter;
2818
2819       if (iter)
2820         tmpiter = *iter;
2821       else
2822         {
2823           if (!gtk_tree_model_get_iter (tree_view->priv->model, &tmpiter, path))
2824             return FALSE;
2825         }
2826
2827       is_separator = tree_view->priv->row_separator_func (tree_view->priv->model,
2828                                                           &tmpiter,
2829                                                           tree_view->priv->row_separator_data);
2830     }
2831
2832   return is_separator;
2833 }
2834
2835 static gboolean
2836 gtk_tree_view_button_press (GtkWidget      *widget,
2837                             GdkEventButton *event)
2838 {
2839   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
2840   GList *list;
2841   GtkTreeViewColumn *column = NULL;
2842   gint i;
2843   GdkRectangle background_area;
2844   GdkRectangle cell_area;
2845   gint vertical_separator;
2846   gint horizontal_separator;
2847   gboolean path_is_selectable;
2848   gboolean rtl;
2849
2850   rtl = (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL);
2851   gtk_tree_view_stop_editing (tree_view, FALSE);
2852   gtk_widget_style_get (widget,
2853                         "vertical-separator", &vertical_separator,
2854                         "horizontal-separator", &horizontal_separator,
2855                         NULL);
2856
2857   /* Because grab_focus can cause reentrancy, we delay grab_focus until after
2858    * we're done handling the button press.
2859    */
2860
2861   if (event->window == tree_view->priv->bin_window)
2862     {
2863       GtkRBNode *node;
2864       GtkRBTree *tree;
2865       GtkTreePath *path;
2866       gint depth;
2867       gint new_y;
2868       gint y_offset;
2869       gint dval;
2870       gint pre_val, aft_val;
2871       GtkTreeViewColumn *column = NULL;
2872       gint column_handled_click = FALSE;
2873       gboolean row_double_click = FALSE;
2874       gboolean rtl;
2875       gboolean node_selected;
2876       GdkModifierType extend_mod_mask;
2877       GdkModifierType modify_mod_mask;
2878
2879       /* Empty tree? */
2880       if (tree_view->priv->tree == NULL)
2881         {
2882           grab_focus_and_unset_draw_keyfocus (tree_view);
2883           return TRUE;
2884         }
2885
2886       /* are we in an arrow? */
2887       if (tree_view->priv->prelight_node &&
2888           tree_view->priv->arrow_prelit &&
2889           gtk_tree_view_draw_expanders (tree_view))
2890         {
2891           if (event->button == 1)
2892             {
2893               gtk_grab_add (widget);
2894               tree_view->priv->button_pressed_node = tree_view->priv->prelight_node;
2895               tree_view->priv->button_pressed_tree = tree_view->priv->prelight_tree;
2896               gtk_tree_view_queue_draw_arrow (GTK_TREE_VIEW (widget),
2897                                               tree_view->priv->prelight_tree,
2898                                               tree_view->priv->prelight_node);
2899             }
2900
2901           grab_focus_and_unset_draw_keyfocus (tree_view);
2902           return TRUE;
2903         }
2904
2905       /* find the node that was clicked */
2906       new_y = TREE_WINDOW_Y_TO_RBTREE_Y(tree_view, event->y);
2907       if (new_y < 0)
2908         new_y = 0;
2909       y_offset = -_gtk_rbtree_find_offset (tree_view->priv->tree, new_y, &tree, &node);
2910
2911       if (node == NULL)
2912         {
2913           /* We clicked in dead space */
2914           grab_focus_and_unset_draw_keyfocus (tree_view);
2915           return TRUE;
2916         }
2917
2918       /* Get the path and the node */
2919       path = _gtk_tree_view_find_path (tree_view, tree, node);
2920       path_is_selectable = !row_is_separator (tree_view, NULL, path);
2921
2922       if (!path_is_selectable)
2923         {
2924           gtk_tree_path_free (path);
2925           grab_focus_and_unset_draw_keyfocus (tree_view);
2926           return TRUE;
2927         }
2928
2929       depth = gtk_tree_path_get_depth (path);
2930       background_area.y = y_offset + event->y;
2931       background_area.height = gtk_tree_view_get_row_height (tree_view, node);
2932       background_area.x = 0;
2933
2934
2935       /* Let the column have a chance at selecting it. */
2936       rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
2937       for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
2938            list; list = (rtl ? list->prev : list->next))
2939         {
2940           GtkTreeViewColumn *candidate = list->data;
2941
2942           if (!gtk_tree_view_column_get_visible (candidate))
2943             continue;
2944
2945           background_area.width = gtk_tree_view_column_get_width (candidate);
2946           if ((background_area.x > (gint) event->x) ||
2947               (background_area.x + background_area.width <= (gint) event->x))
2948             {
2949               background_area.x += background_area.width;
2950               continue;
2951             }
2952
2953           /* we found the focus column */
2954           column = candidate;
2955           cell_area = background_area;
2956           cell_area.width -= horizontal_separator;
2957           cell_area.height -= vertical_separator;
2958           cell_area.x += horizontal_separator/2;
2959           cell_area.y += vertical_separator/2;
2960           if (gtk_tree_view_is_expander_column (tree_view, column))
2961             {
2962               if (!rtl)
2963                 cell_area.x += (depth - 1) * tree_view->priv->level_indentation;
2964               cell_area.width -= (depth - 1) * tree_view->priv->level_indentation;
2965
2966               if (gtk_tree_view_draw_expanders (tree_view))
2967                 {
2968                   if (!rtl)
2969                     cell_area.x += depth * tree_view->priv->expander_size;
2970                   cell_area.width -= depth * tree_view->priv->expander_size;
2971                 }
2972             }
2973           break;
2974         }
2975
2976       if (column == NULL)
2977         {
2978           gtk_tree_path_free (path);
2979           grab_focus_and_unset_draw_keyfocus (tree_view);
2980           return FALSE;
2981         }
2982
2983       tree_view->priv->focus_column = column;
2984
2985       /* decide if we edit */
2986       if (event->type == GDK_BUTTON_PRESS && event->button == 1 &&
2987           !(event->state & gtk_accelerator_get_default_mod_mask ()))
2988         {
2989           GtkTreePath *anchor;
2990           GtkTreeIter iter;
2991
2992           gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
2993           gtk_tree_view_column_cell_set_cell_data (column,
2994                                                    tree_view->priv->model,
2995                                                    &iter,
2996                                                    GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT),
2997                                                    node->children?TRUE:FALSE);
2998
2999           if (tree_view->priv->anchor)
3000             anchor = gtk_tree_row_reference_get_path (tree_view->priv->anchor);
3001           else
3002             anchor = NULL;
3003
3004           if ((anchor && !gtk_tree_path_compare (anchor, path))
3005               || !_gtk_tree_view_column_has_editable_cell (column))
3006             {
3007               GtkCellEditable *cell_editable = NULL;
3008
3009               /* FIXME: get the right flags */
3010               guint flags = 0;
3011
3012               if (_gtk_tree_view_column_cell_event (column,
3013                                                     (GdkEvent *)event,
3014                                                     &cell_area, flags))
3015                 {
3016                   GtkCellArea *area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (column));
3017                   cell_editable = gtk_cell_area_get_edit_widget (area);
3018
3019                   if (cell_editable != NULL)
3020                     {
3021                       gtk_tree_path_free (path);
3022                       gtk_tree_path_free (anchor);
3023                       return TRUE;
3024                     }
3025                   column_handled_click = TRUE;
3026                 }
3027             }
3028           if (anchor)
3029             gtk_tree_path_free (anchor);
3030         }
3031
3032       extend_mod_mask =
3033         gtk_widget_get_modifier_mask (widget, GDK_MODIFIER_INTENT_EXTEND_SELECTION);
3034
3035       modify_mod_mask =
3036         gtk_widget_get_modifier_mask (widget, GDK_MODIFIER_INTENT_MODIFY_SELECTION);
3037
3038       /* select */
3039       node_selected = GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED);
3040       pre_val = gtk_adjustment_get_value (tree_view->priv->vadjustment);
3041
3042       /* we only handle selection modifications on the first button press
3043        */
3044       if (event->type == GDK_BUTTON_PRESS)
3045         {
3046           GtkCellRenderer *focus_cell;
3047
3048           if ((event->state & modify_mod_mask) == modify_mod_mask)
3049             tree_view->priv->modify_selection_pressed = TRUE;
3050           if ((event->state & extend_mod_mask) == extend_mod_mask)
3051             tree_view->priv->extend_selection_pressed = TRUE;
3052
3053           /* We update the focus cell here, this is also needed if the
3054            * column does not contain an editable cell.  In this case,
3055            * GtkCellArea did not receive the event for processing (and
3056            * could not update the focus cell).
3057            */
3058           focus_cell = _gtk_tree_view_column_get_cell_at_pos (column,
3059                                                               &cell_area,
3060                                                               &background_area,
3061                                                               event->x,
3062                                                               event->y);
3063
3064           if (focus_cell)
3065             gtk_tree_view_column_focus_cell (column, focus_cell);
3066
3067           if (event->state & modify_mod_mask)
3068             {
3069               gtk_tree_view_real_set_cursor (tree_view, path, FALSE, TRUE);
3070               gtk_tree_view_real_toggle_cursor_row (tree_view);
3071             }
3072           else if (event->state & extend_mod_mask)
3073             {
3074               gtk_tree_view_real_set_cursor (tree_view, path, FALSE, TRUE);
3075               gtk_tree_view_real_select_cursor_row (tree_view, FALSE);
3076             }
3077           else
3078             {
3079               gtk_tree_view_real_set_cursor (tree_view, path, TRUE, TRUE);
3080             }
3081
3082           tree_view->priv->modify_selection_pressed = FALSE;
3083           tree_view->priv->extend_selection_pressed = FALSE;
3084         }
3085
3086       /* the treeview may have been scrolled because of _set_cursor,
3087        * correct here
3088        */
3089
3090       aft_val = gtk_adjustment_get_value (tree_view->priv->vadjustment);
3091       dval = pre_val - aft_val;
3092
3093       cell_area.y += dval;
3094       background_area.y += dval;
3095
3096       /* Save press to possibly begin a drag
3097        */
3098       if (!column_handled_click &&
3099           !tree_view->priv->in_grab &&
3100           tree_view->priv->pressed_button < 0)
3101         {
3102           tree_view->priv->pressed_button = event->button;
3103           tree_view->priv->press_start_x = event->x;
3104           tree_view->priv->press_start_y = event->y;
3105
3106           if (tree_view->priv->rubber_banding_enable
3107               && !node_selected
3108               && gtk_tree_selection_get_mode (tree_view->priv->selection) == GTK_SELECTION_MULTIPLE)
3109             {
3110               tree_view->priv->press_start_y += tree_view->priv->dy;
3111               tree_view->priv->rubber_band_x = event->x;
3112               tree_view->priv->rubber_band_y = event->y + tree_view->priv->dy;
3113               tree_view->priv->rubber_band_status = RUBBER_BAND_MAYBE_START;
3114
3115               if ((event->state & modify_mod_mask) == modify_mod_mask)
3116                 tree_view->priv->rubber_band_modify = TRUE;
3117               if ((event->state & extend_mod_mask) == extend_mod_mask)
3118                 tree_view->priv->rubber_band_extend = TRUE;
3119             }
3120         }
3121
3122       /* Test if a double click happened on the same row. */
3123       if (event->button == 1 && event->type == GDK_BUTTON_PRESS)
3124         {
3125           int double_click_time, double_click_distance;
3126
3127           g_object_get (gtk_settings_get_default (),
3128                         "gtk-double-click-time", &double_click_time,
3129                         "gtk-double-click-distance", &double_click_distance,
3130                         NULL);
3131
3132           /* Same conditions as _gdk_event_button_generate */
3133           if (tree_view->priv->last_button_x != -1 &&
3134               (event->time < tree_view->priv->last_button_time + double_click_time) &&
3135               (ABS (event->x - tree_view->priv->last_button_x) <= double_click_distance) &&
3136               (ABS (event->y - tree_view->priv->last_button_y) <= double_click_distance))
3137             {
3138               /* We do no longer compare paths of this row and the
3139                * row clicked previously.  We use the double click
3140                * distance to decide whether this is a valid click,
3141                * allowing the mouse to slightly move over another row.
3142                */
3143               row_double_click = TRUE;
3144
3145               tree_view->priv->last_button_time = 0;
3146               tree_view->priv->last_button_x = -1;
3147               tree_view->priv->last_button_y = -1;
3148             }
3149           else
3150             {
3151               tree_view->priv->last_button_time = event->time;
3152               tree_view->priv->last_button_x = event->x;
3153               tree_view->priv->last_button_y = event->y;
3154             }
3155         }
3156
3157       if (row_double_click)
3158         {
3159           gtk_grab_remove (widget);
3160           gtk_tree_view_row_activated (tree_view, path, column);
3161
3162           if (tree_view->priv->pressed_button == event->button)
3163             tree_view->priv->pressed_button = -1;
3164         }
3165
3166       gtk_tree_path_free (path);
3167
3168       /* If we activated the row through a double click we don't want to grab
3169        * focus back, as moving focus to another widget is pretty common.
3170        */
3171       if (!row_double_click)
3172         grab_focus_and_unset_draw_keyfocus (tree_view);
3173
3174       return TRUE;
3175     }
3176
3177   /* We didn't click in the window.  Let's check to see if we clicked on a column resize window.
3178    */
3179   for (i = 0, list = tree_view->priv->columns; list; list = list->next, i++)
3180     {
3181       column = list->data;
3182       if (event->window == _gtk_tree_view_column_get_window (column) &&
3183           gtk_tree_view_column_get_resizable (column) &&
3184           _gtk_tree_view_column_get_window (column))
3185         {
3186           gpointer drag_data;
3187
3188           if (event->type == GDK_2BUTTON_PRESS &&
3189               gtk_tree_view_column_get_sizing (column) != GTK_TREE_VIEW_COLUMN_AUTOSIZE)
3190             {
3191               _gtk_tree_view_column_set_use_resized_width (column, FALSE);
3192               _gtk_tree_view_column_autosize (tree_view, column);
3193               return TRUE;
3194             }
3195
3196           if (gdk_device_grab (gdk_event_get_device ((GdkEvent*)event),
3197                                _gtk_tree_view_column_get_window (column),
3198                                GDK_OWNERSHIP_NONE,
3199                                FALSE,
3200                                GDK_POINTER_MOTION_HINT_MASK
3201                                 | GDK_BUTTON1_MOTION_MASK
3202                                 | GDK_BUTTON_RELEASE_MASK,
3203                                NULL,
3204                                event->time) != GDK_GRAB_SUCCESS)
3205             return FALSE;
3206
3207           gtk_grab_add (widget);
3208           tree_view->priv->in_column_resize = TRUE;
3209
3210           _gtk_tree_view_column_set_resized_width (column, gtk_tree_view_column_get_width (column) -
3211                                                    tree_view->priv->last_extra_space_per_column);
3212
3213           /* block attached dnd signal handler */
3214           drag_data = g_object_get_data (G_OBJECT (widget), "gtk-site-data");
3215           if (drag_data)
3216             g_signal_handlers_block_matched (widget,
3217                                              G_SIGNAL_MATCH_DATA,
3218                                              0, 0, NULL, NULL,
3219                                              drag_data);
3220
3221           tree_view->priv->drag_pos = i;
3222           tree_view->priv->x_drag = gtk_tree_view_column_get_x_offset (column) + (rtl ? 0 : gtk_tree_view_column_get_width (column));
3223
3224           if (!gtk_widget_has_focus (widget))
3225             gtk_widget_grab_focus (widget);
3226
3227           return TRUE;
3228         }
3229     }
3230   return FALSE;
3231 }
3232
3233 /* GtkWidget::button_release_event helper */
3234 static gboolean
3235 gtk_tree_view_button_release_drag_column (GtkWidget      *widget,
3236                                           GdkEventButton *event)
3237 {
3238   GtkTreeView *tree_view;
3239   GtkWidget *button;
3240   GList *l;
3241   gboolean rtl;
3242   GdkDevice *device, *other;
3243
3244   tree_view = GTK_TREE_VIEW (widget);
3245
3246   rtl = (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL);
3247   device = gdk_event_get_device ((GdkEvent*)event);
3248   other = gdk_device_get_associated_device (device);
3249   gdk_device_ungrab (device, event->time);
3250   gdk_device_ungrab (other, event->time);
3251
3252   /* Move the button back */
3253   button = gtk_tree_view_column_get_button (tree_view->priv->drag_column);
3254   g_object_ref (button);
3255   gtk_container_remove (GTK_CONTAINER (tree_view), button);
3256   gtk_widget_set_parent_window (button, tree_view->priv->header_window);
3257   gtk_widget_set_parent (button, GTK_WIDGET (tree_view));
3258   g_object_unref (button);
3259   gtk_widget_queue_resize (widget);
3260   if (gtk_tree_view_column_get_resizable (tree_view->priv->drag_column))
3261     {
3262       gdk_window_raise (_gtk_tree_view_column_get_window (tree_view->priv->drag_column));
3263       gdk_window_show (_gtk_tree_view_column_get_window (tree_view->priv->drag_column));
3264     }
3265   else
3266     gdk_window_hide (_gtk_tree_view_column_get_window (tree_view->priv->drag_column));
3267
3268   gtk_widget_grab_focus (button);
3269
3270   if (rtl)
3271     {
3272       if (tree_view->priv->cur_reorder &&
3273           tree_view->priv->cur_reorder->right_column != tree_view->priv->drag_column)
3274         gtk_tree_view_move_column_after (tree_view, tree_view->priv->drag_column,
3275                                          tree_view->priv->cur_reorder->right_column);
3276     }
3277   else
3278     {
3279       if (tree_view->priv->cur_reorder &&
3280           tree_view->priv->cur_reorder->left_column != tree_view->priv->drag_column)
3281         gtk_tree_view_move_column_after (tree_view, tree_view->priv->drag_column,
3282                                          tree_view->priv->cur_reorder->left_column);
3283     }
3284   tree_view->priv->drag_column = NULL;
3285   gdk_window_hide (tree_view->priv->drag_window);
3286
3287   for (l = tree_view->priv->column_drag_info; l != NULL; l = l->next)
3288     g_slice_free (GtkTreeViewColumnReorder, l->data);
3289   g_list_free (tree_view->priv->column_drag_info);
3290   tree_view->priv->column_drag_info = NULL;
3291   tree_view->priv->cur_reorder = NULL;
3292
3293   if (tree_view->priv->drag_highlight_window)
3294     gdk_window_hide (tree_view->priv->drag_highlight_window);
3295
3296   /* Reset our flags */
3297   tree_view->priv->drag_column_window_state = DRAG_COLUMN_WINDOW_STATE_UNSET;
3298   tree_view->priv->in_column_drag = FALSE;
3299
3300   return TRUE;
3301 }
3302
3303 /* GtkWidget::button_release_event helper */
3304 static gboolean
3305 gtk_tree_view_button_release_column_resize (GtkWidget      *widget,
3306                                             GdkEventButton *event)
3307 {
3308   GtkTreeView *tree_view;
3309   gpointer drag_data;
3310
3311   tree_view = GTK_TREE_VIEW (widget);
3312
3313   tree_view->priv->drag_pos = -1;
3314
3315   /* unblock attached dnd signal handler */
3316   drag_data = g_object_get_data (G_OBJECT (widget), "gtk-site-data");
3317   if (drag_data)
3318     g_signal_handlers_unblock_matched (widget,
3319                                        G_SIGNAL_MATCH_DATA,
3320                                        0, 0, NULL, NULL,
3321                                        drag_data);
3322
3323   tree_view->priv->in_column_resize = FALSE;
3324   gtk_grab_remove (widget);
3325   gdk_device_ungrab (gdk_event_get_device ((GdkEvent*)event), event->time);
3326   return TRUE;
3327 }
3328
3329 static gboolean
3330 gtk_tree_view_button_release (GtkWidget      *widget,
3331                               GdkEventButton *event)
3332 {
3333   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
3334
3335   if (tree_view->priv->in_column_drag)
3336     return gtk_tree_view_button_release_drag_column (widget, event);
3337
3338   if (tree_view->priv->rubber_band_status)
3339     gtk_tree_view_stop_rubber_band (tree_view);
3340
3341   if (tree_view->priv->pressed_button == event->button)
3342     tree_view->priv->pressed_button = -1;
3343
3344   if (tree_view->priv->in_column_resize)
3345     return gtk_tree_view_button_release_column_resize (widget, event);
3346
3347   if (tree_view->priv->button_pressed_node == NULL)
3348     return FALSE;
3349
3350   if (event->button == 1)
3351     {
3352       if (tree_view->priv->button_pressed_node == tree_view->priv->prelight_node &&
3353           tree_view->priv->arrow_prelit)
3354         {
3355           GtkTreePath *path = NULL;
3356
3357           path = _gtk_tree_view_find_path (tree_view,
3358                                            tree_view->priv->button_pressed_tree,
3359                                            tree_view->priv->button_pressed_node);
3360           /* Actually activate the node */
3361           if (tree_view->priv->button_pressed_node->children == NULL)
3362             gtk_tree_view_real_expand_row (tree_view, path,
3363                                            tree_view->priv->button_pressed_tree,
3364                                            tree_view->priv->button_pressed_node,
3365                                            FALSE, TRUE);
3366           else
3367             gtk_tree_view_real_collapse_row (GTK_TREE_VIEW (widget), path,
3368                                              tree_view->priv->button_pressed_tree,
3369                                              tree_view->priv->button_pressed_node, TRUE);
3370           gtk_tree_path_free (path);
3371         }
3372
3373       gtk_grab_remove (widget);
3374       tree_view->priv->button_pressed_tree = NULL;
3375       tree_view->priv->button_pressed_node = NULL;
3376     }
3377
3378   return TRUE;
3379 }
3380
3381 static gboolean
3382 gtk_tree_view_grab_broken (GtkWidget          *widget,
3383                            GdkEventGrabBroken *event)
3384 {
3385   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
3386
3387   if (tree_view->priv->in_column_drag)
3388     gtk_tree_view_button_release_drag_column (widget, (GdkEventButton *)event);
3389
3390   if (tree_view->priv->in_column_resize)
3391     gtk_tree_view_button_release_column_resize (widget, (GdkEventButton *)event);
3392
3393   return TRUE;
3394 }
3395
3396 #if 0
3397 static gboolean
3398 gtk_tree_view_configure (GtkWidget *widget,
3399                          GdkEventConfigure *event)
3400 {
3401   GtkTreeView *tree_view;
3402
3403   tree_view = GTK_TREE_VIEW (widget);
3404   tree_view->priv->search_position_func (tree_view, tree_view->priv->search_window);
3405
3406   return FALSE;
3407 }
3408 #endif
3409
3410 /* GtkWidget::motion_event function set.
3411  */
3412
3413 static gboolean
3414 coords_are_over_arrow (GtkTreeView *tree_view,
3415                        GtkRBTree   *tree,
3416                        GtkRBNode   *node,
3417                        /* these are in bin window coords */
3418                        gint         x,
3419                        gint         y)
3420 {
3421   GdkRectangle arrow;
3422   gint x2;
3423
3424   if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
3425     return FALSE;
3426
3427   if ((node->flags & GTK_RBNODE_IS_PARENT) == 0)
3428     return FALSE;
3429
3430   arrow.y = gtk_tree_view_get_row_y_offset (tree_view, tree, node);
3431   arrow.height = gtk_tree_view_get_row_height (tree_view, node);
3432
3433   gtk_tree_view_get_arrow_xrange (tree_view, tree, &arrow.x, &x2);
3434
3435   arrow.width = x2 - arrow.x;
3436
3437   return (x >= arrow.x &&
3438           x < (arrow.x + arrow.width) &&
3439           y >= arrow.y &&
3440           y < (arrow.y + arrow.height));
3441 }
3442
3443 static gboolean
3444 auto_expand_timeout (gpointer data)
3445 {
3446   GtkTreeView *tree_view = GTK_TREE_VIEW (data);
3447   GtkTreePath *path;
3448
3449   if (tree_view->priv->prelight_node)
3450     {
3451       path = _gtk_tree_view_find_path (tree_view,
3452                                        tree_view->priv->prelight_tree,
3453                                        tree_view->priv->prelight_node);
3454
3455       if (tree_view->priv->prelight_node->children)
3456         gtk_tree_view_collapse_row (tree_view, path);
3457       else
3458         gtk_tree_view_expand_row (tree_view, path, FALSE);
3459
3460       gtk_tree_path_free (path);
3461     }
3462
3463   tree_view->priv->auto_expand_timeout = 0;
3464
3465   return FALSE;
3466 }
3467
3468 static void
3469 remove_auto_expand_timeout (GtkTreeView *tree_view)
3470 {
3471   if (tree_view->priv->auto_expand_timeout != 0)
3472     {
3473       g_source_remove (tree_view->priv->auto_expand_timeout);
3474       tree_view->priv->auto_expand_timeout = 0;
3475     }
3476 }
3477
3478 static void
3479 do_prelight (GtkTreeView *tree_view,
3480              GtkRBTree   *tree,
3481              GtkRBNode   *node,
3482              /* these are in bin_window coords */
3483              gint         x,
3484              gint         y)
3485 {
3486   if (tree_view->priv->prelight_tree == tree &&
3487       tree_view->priv->prelight_node == node)
3488     {
3489       /*  We are still on the same node,
3490           but we might need to take care of the arrow  */
3491
3492       if (tree && node && gtk_tree_view_draw_expanders (tree_view))
3493         {
3494           gboolean over_arrow;
3495
3496           over_arrow = coords_are_over_arrow (tree_view, tree, node, x, y);
3497
3498           if (over_arrow != tree_view->priv->arrow_prelit)
3499             {
3500               if (over_arrow)
3501                 tree_view->priv->arrow_prelit = TRUE;
3502               else
3503                 tree_view->priv->arrow_prelit = FALSE;
3504
3505               gtk_tree_view_queue_draw_arrow (tree_view, tree, node);
3506             }
3507         }
3508
3509       return;
3510     }
3511
3512   if (tree_view->priv->prelight_tree && tree_view->priv->prelight_node)
3513     {
3514       /*  Unprelight the old node and arrow  */
3515
3516       GTK_RBNODE_UNSET_FLAG (tree_view->priv->prelight_node,
3517                              GTK_RBNODE_IS_PRELIT);
3518
3519       if (tree_view->priv->arrow_prelit
3520           && gtk_tree_view_draw_expanders (tree_view))
3521         {
3522           tree_view->priv->arrow_prelit = FALSE;
3523
3524           gtk_tree_view_queue_draw_arrow (tree_view,
3525                                           tree_view->priv->prelight_tree,
3526                                           tree_view->priv->prelight_node);
3527         }
3528
3529       _gtk_tree_view_queue_draw_node (tree_view,
3530                                       tree_view->priv->prelight_tree,
3531                                       tree_view->priv->prelight_node,
3532                                       NULL);
3533     }
3534
3535
3536   if (tree_view->priv->hover_expand)
3537     remove_auto_expand_timeout (tree_view);
3538
3539   /*  Set the new prelight values  */
3540   tree_view->priv->prelight_node = node;
3541   tree_view->priv->prelight_tree = tree;
3542
3543   if (!node || !tree)
3544     return;
3545
3546   /*  Prelight the new node and arrow  */
3547
3548   if (gtk_tree_view_draw_expanders (tree_view)
3549       && coords_are_over_arrow (tree_view, tree, node, x, y))
3550     {
3551       tree_view->priv->arrow_prelit = TRUE;
3552
3553       gtk_tree_view_queue_draw_arrow (tree_view, tree, node);
3554     }
3555
3556   GTK_RBNODE_SET_FLAG (node, GTK_RBNODE_IS_PRELIT);
3557
3558   _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
3559
3560   if (tree_view->priv->hover_expand)
3561     {
3562       tree_view->priv->auto_expand_timeout =
3563         gdk_threads_add_timeout (AUTO_EXPAND_TIMEOUT, auto_expand_timeout, tree_view);
3564     }
3565 }
3566
3567 static void
3568 prelight_or_select (GtkTreeView *tree_view,
3569                     GtkRBTree   *tree,
3570                     GtkRBNode   *node,
3571                     /* these are in bin_window coords */
3572                     gint         x,
3573                     gint         y)
3574 {
3575   GtkSelectionMode mode = gtk_tree_selection_get_mode (tree_view->priv->selection);
3576
3577   if (tree_view->priv->hover_selection &&
3578       (mode == GTK_SELECTION_SINGLE || mode == GTK_SELECTION_BROWSE) &&
3579       !(tree_view->priv->edited_column &&
3580         gtk_cell_area_get_edit_widget
3581         (gtk_cell_layout_get_area (GTK_CELL_LAYOUT (tree_view->priv->edited_column)))))
3582     {
3583       if (node)
3584         {
3585           if (!GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
3586             {
3587               GtkTreePath *path;
3588
3589               path = _gtk_tree_view_find_path (tree_view, tree, node);
3590               gtk_tree_selection_select_path (tree_view->priv->selection, path);
3591               if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
3592                 {
3593                   tree_view->priv->draw_keyfocus = FALSE;
3594                   gtk_tree_view_real_set_cursor (tree_view, path, FALSE, FALSE);
3595                 }
3596               gtk_tree_path_free (path);
3597             }
3598         }
3599
3600       else if (mode == GTK_SELECTION_SINGLE)
3601         gtk_tree_selection_unselect_all (tree_view->priv->selection);
3602     }
3603
3604     do_prelight (tree_view, tree, node, x, y);
3605 }
3606
3607 static void
3608 ensure_unprelighted (GtkTreeView *tree_view)
3609 {
3610   do_prelight (tree_view,
3611                NULL, NULL,
3612                -1000, -1000); /* coords not possibly over an arrow */
3613
3614   g_assert (tree_view->priv->prelight_node == NULL);
3615 }
3616
3617 static void
3618 update_prelight (GtkTreeView *tree_view,
3619                  gint         x,
3620                  gint         y)
3621 {
3622   int new_y;
3623   GtkRBTree *tree;
3624   GtkRBNode *node;
3625
3626   if (tree_view->priv->tree == NULL)
3627     return;
3628
3629   if (x == -10000)
3630     {
3631       ensure_unprelighted (tree_view);
3632       return;
3633     }
3634
3635   new_y = TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, y);
3636   if (new_y < 0)
3637     new_y = 0;
3638
3639   _gtk_rbtree_find_offset (tree_view->priv->tree,
3640                            new_y, &tree, &node);
3641
3642   if (node)
3643     prelight_or_select (tree_view, tree, node, x, y);
3644 }
3645
3646
3647
3648
3649 /* Our motion arrow is either a box (in the case of the original spot)
3650  * or an arrow.  It is expander_size wide.
3651  */
3652 /*
3653  * 11111111111111
3654  * 01111111111110
3655  * 00111111111100
3656  * 00011111111000
3657  * 00001111110000
3658  * 00000111100000
3659  * 00000111100000
3660  * 00000111100000
3661  * ~ ~ ~ ~ ~ ~ ~
3662  * 00000111100000
3663  * 00000111100000
3664  * 00000111100000
3665  * 00001111110000
3666  * 00011111111000
3667  * 00111111111100
3668  * 01111111111110
3669  * 11111111111111
3670  */
3671
3672 static void
3673 gtk_tree_view_motion_draw_column_motion_arrow (GtkTreeView *tree_view)
3674 {
3675   GtkTreeViewColumnReorder *reorder = tree_view->priv->cur_reorder;
3676   GtkWidget *widget = GTK_WIDGET (tree_view);
3677   cairo_surface_t *mask_image;
3678   cairo_region_t *mask_region;
3679   gint x;
3680   gint y;
3681   gint width;
3682   gint height;
3683   gint arrow_type = DRAG_COLUMN_WINDOW_STATE_UNSET;
3684   GdkWindowAttr attributes;
3685   guint attributes_mask;
3686   cairo_t *cr;
3687
3688   if (!reorder ||
3689       reorder->left_column == tree_view->priv->drag_column ||
3690       reorder->right_column == tree_view->priv->drag_column)
3691     arrow_type = DRAG_COLUMN_WINDOW_STATE_ORIGINAL;
3692   else if (reorder->left_column || reorder->right_column)
3693     {
3694       GtkAllocation left_allocation, right_allocation;
3695       GdkRectangle visible_rect;
3696       GtkWidget *button;
3697
3698       gtk_tree_view_get_visible_rect (tree_view, &visible_rect);
3699       if (reorder->left_column)
3700         {
3701           button = gtk_tree_view_column_get_button (reorder->left_column);
3702           gtk_widget_get_allocation (button, &left_allocation);
3703           x = left_allocation.x + left_allocation.width;
3704         }
3705       else
3706         {
3707           button = gtk_tree_view_column_get_button (reorder->right_column);
3708           gtk_widget_get_allocation (button, &right_allocation);
3709           x = right_allocation.x;
3710         }
3711
3712       if (x < visible_rect.x)
3713         arrow_type = DRAG_COLUMN_WINDOW_STATE_ARROW_LEFT;
3714       else if (x > visible_rect.x + visible_rect.width)
3715         arrow_type = DRAG_COLUMN_WINDOW_STATE_ARROW_RIGHT;
3716       else
3717         arrow_type = DRAG_COLUMN_WINDOW_STATE_ARROW;
3718     }
3719
3720   /* We want to draw the rectangle over the initial location. */
3721   if (arrow_type == DRAG_COLUMN_WINDOW_STATE_ORIGINAL)
3722     {
3723       if (tree_view->priv->drag_column_window_state != DRAG_COLUMN_WINDOW_STATE_ORIGINAL)
3724         {
3725           GtkAllocation drag_allocation;
3726           GtkWidget    *button;
3727
3728           if (tree_view->priv->drag_highlight_window)
3729             {
3730               gdk_window_set_user_data (tree_view->priv->drag_highlight_window,
3731                                         NULL);
3732               gdk_window_destroy (tree_view->priv->drag_highlight_window);
3733             }
3734
3735           button = gtk_tree_view_column_get_button (tree_view->priv->drag_column);
3736           attributes.window_type = GDK_WINDOW_CHILD;
3737           attributes.wclass = GDK_INPUT_OUTPUT;
3738           attributes.x = tree_view->priv->drag_column_x;
3739           attributes.y = 0;
3740           gtk_widget_get_allocation (button, &drag_allocation);
3741           width = attributes.width = drag_allocation.width;
3742           height = attributes.height = drag_allocation.height;
3743           attributes.visual = gtk_widget_get_visual (GTK_WIDGET (tree_view));
3744           attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK;
3745           attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
3746           tree_view->priv->drag_highlight_window = gdk_window_new (tree_view->priv->header_window, &attributes, attributes_mask);
3747           gdk_window_set_user_data (tree_view->priv->drag_highlight_window, GTK_WIDGET (tree_view));
3748
3749           mask_image = cairo_image_surface_create (CAIRO_FORMAT_A1, width, height);
3750           cr = cairo_create (mask_image);
3751
3752           cairo_rectangle (cr, 1, 1, width - 2, height - 2);
3753           cairo_stroke (cr);
3754           cairo_destroy (cr);
3755
3756           mask_region = gdk_cairo_region_create_from_surface (mask_image);
3757           gdk_window_shape_combine_region (tree_view->priv->drag_highlight_window,
3758                                            mask_region, 0, 0);
3759
3760           cairo_region_destroy (mask_region);
3761           cairo_surface_destroy (mask_image);
3762
3763           tree_view->priv->drag_column_window_state = DRAG_COLUMN_WINDOW_STATE_ORIGINAL;
3764         }
3765     }
3766   else if (arrow_type == DRAG_COLUMN_WINDOW_STATE_ARROW)
3767     {
3768       GtkAllocation button_allocation;
3769       GtkWidget    *button;
3770
3771       width = tree_view->priv->expander_size;
3772
3773       /* Get x, y, width, height of arrow */
3774       gdk_window_get_origin (tree_view->priv->header_window, &x, &y);
3775       if (reorder->left_column)
3776         {
3777           button = gtk_tree_view_column_get_button (reorder->left_column);
3778           gtk_widget_get_allocation (button, &button_allocation);
3779           x += button_allocation.x + button_allocation.width - width/2;
3780           height = button_allocation.height;
3781         }
3782       else
3783         {
3784           button = gtk_tree_view_column_get_button (reorder->right_column);
3785           gtk_widget_get_allocation (button, &button_allocation);
3786           x += button_allocation.x - width/2;
3787           height = button_allocation.height;
3788         }
3789       y -= tree_view->priv->expander_size/2; /* The arrow takes up only half the space */
3790       height += tree_view->priv->expander_size;
3791
3792       /* Create the new window */
3793       if (tree_view->priv->drag_column_window_state != DRAG_COLUMN_WINDOW_STATE_ARROW)
3794         {
3795           if (tree_view->priv->drag_highlight_window)
3796             {
3797               gdk_window_set_user_data (tree_view->priv->drag_highlight_window,
3798                                         NULL);
3799               gdk_window_destroy (tree_view->priv->drag_highlight_window);
3800             }
3801
3802           attributes.window_type = GDK_WINDOW_TEMP;
3803           attributes.wclass = GDK_INPUT_OUTPUT;
3804           attributes.visual = gtk_widget_get_visual (GTK_WIDGET (tree_view));
3805           attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK;
3806           attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
3807           attributes.x = x;
3808           attributes.y = y;
3809           attributes.width = width;
3810           attributes.height = height;
3811           tree_view->priv->drag_highlight_window = gdk_window_new (gtk_widget_get_root_window (widget),
3812                                                                    &attributes, attributes_mask);
3813           gdk_window_set_user_data (tree_view->priv->drag_highlight_window, GTK_WIDGET (tree_view));
3814
3815           mask_image = cairo_image_surface_create (CAIRO_FORMAT_A1, width, height);
3816
3817           cr = cairo_create (mask_image);
3818           cairo_move_to (cr, 0, 0);
3819           cairo_line_to (cr, width, 0);
3820           cairo_line_to (cr, width / 2., width / 2);
3821           cairo_move_to (cr, 0, height);
3822           cairo_line_to (cr, width, height);
3823           cairo_line_to (cr, width / 2., height - width / 2.);
3824           cairo_fill (cr);
3825           cairo_destroy (cr);
3826
3827           mask_region = gdk_cairo_region_create_from_surface (mask_image);
3828           gdk_window_shape_combine_region (tree_view->priv->drag_highlight_window,
3829                                            mask_region, 0, 0);
3830
3831           cairo_region_destroy (mask_region);
3832           cairo_surface_destroy (mask_image);
3833         }
3834
3835       tree_view->priv->drag_column_window_state = DRAG_COLUMN_WINDOW_STATE_ARROW;
3836       gdk_window_move (tree_view->priv->drag_highlight_window, x, y);
3837     }
3838   else if (arrow_type == DRAG_COLUMN_WINDOW_STATE_ARROW_LEFT ||
3839            arrow_type == DRAG_COLUMN_WINDOW_STATE_ARROW_RIGHT)
3840     {
3841       GtkAllocation allocation;
3842       GtkWidget    *button;
3843
3844       width = tree_view->priv->expander_size;
3845
3846       /* Get x, y, width, height of arrow */
3847       width = width/2; /* remember, the arrow only takes half the available width */
3848       gdk_window_get_origin (gtk_widget_get_window (widget),
3849                              &x, &y);
3850       if (arrow_type == DRAG_COLUMN_WINDOW_STATE_ARROW_RIGHT)
3851         {
3852           gtk_widget_get_allocation (widget, &allocation);
3853           x += allocation.width - width;
3854         }
3855
3856       if (reorder->left_column)
3857         {
3858           button = gtk_tree_view_column_get_button (reorder->left_column);
3859           gtk_widget_get_allocation (button, &allocation);
3860           height = allocation.height;
3861         }
3862       else
3863         {
3864           button = gtk_tree_view_column_get_button (reorder->right_column);
3865           gtk_widget_get_allocation (button, &allocation);
3866           height = allocation.height;
3867         }
3868
3869       y -= tree_view->priv->expander_size;
3870       height += 2*tree_view->priv->expander_size;
3871
3872       /* Create the new window */
3873       if (tree_view->priv->drag_column_window_state != DRAG_COLUMN_WINDOW_STATE_ARROW_LEFT &&
3874           tree_view->priv->drag_column_window_state != DRAG_COLUMN_WINDOW_STATE_ARROW_RIGHT)
3875         {
3876           if (tree_view->priv->drag_highlight_window)
3877             {
3878               gdk_window_set_user_data (tree_view->priv->drag_highlight_window,
3879                                         NULL);
3880               gdk_window_destroy (tree_view->priv->drag_highlight_window);
3881             }
3882
3883           attributes.window_type = GDK_WINDOW_TEMP;
3884           attributes.wclass = GDK_INPUT_OUTPUT;
3885           attributes.visual = gtk_widget_get_visual (GTK_WIDGET (tree_view));
3886           attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK;
3887           attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
3888           attributes.x = x;
3889           attributes.y = y;
3890           attributes.width = width;
3891           attributes.height = height;
3892           tree_view->priv->drag_highlight_window = gdk_window_new (NULL, &attributes, attributes_mask);
3893           gdk_window_set_user_data (tree_view->priv->drag_highlight_window, GTK_WIDGET (tree_view));
3894
3895           mask_image = cairo_image_surface_create (CAIRO_FORMAT_A1, width, height);
3896
3897           cr = cairo_create (mask_image);
3898           /* mirror if we're on the left */
3899           if (arrow_type == DRAG_COLUMN_WINDOW_STATE_ARROW_LEFT)
3900             {
3901               cairo_translate (cr, width, 0);
3902               cairo_scale (cr, -1, 1);
3903             }
3904           cairo_move_to (cr, 0, 0);
3905           cairo_line_to (cr, width, width);
3906           cairo_line_to (cr, 0, tree_view->priv->expander_size);
3907           cairo_move_to (cr, 0, height);
3908           cairo_line_to (cr, width, height - width);
3909           cairo_line_to (cr, 0, height - tree_view->priv->expander_size);
3910           cairo_fill (cr);
3911           cairo_destroy (cr);
3912
3913           mask_region = gdk_cairo_region_create_from_surface (mask_image);
3914           gdk_window_shape_combine_region (tree_view->priv->drag_highlight_window,
3915                                            mask_region, 0, 0);
3916
3917           cairo_region_destroy (mask_region);
3918           cairo_surface_destroy (mask_image);
3919         }
3920
3921       tree_view->priv->drag_column_window_state = arrow_type;
3922       gdk_window_move (tree_view->priv->drag_highlight_window, x, y);
3923    }
3924   else
3925     {
3926       g_warning (G_STRLOC"Invalid GtkTreeViewColumnReorder struct");
3927       gdk_window_hide (tree_view->priv->drag_highlight_window);
3928       return;
3929     }
3930
3931   gdk_window_show (tree_view->priv->drag_highlight_window);
3932   gdk_window_raise (tree_view->priv->drag_highlight_window);
3933 }
3934
3935 static gboolean
3936 gtk_tree_view_motion_resize_column (GtkWidget      *widget,
3937                                     GdkEventMotion *event)
3938 {
3939   gint x;
3940   gint new_width;
3941   GtkTreeViewColumn *column;
3942   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
3943
3944   column = gtk_tree_view_get_column (tree_view, tree_view->priv->drag_pos);
3945
3946   if (event->is_hint || event->window != gtk_widget_get_window (widget))
3947     gdk_window_get_device_position (gtk_widget_get_window (widget),
3948                                     gdk_event_get_device ((GdkEvent *) event),
3949                                     &x, NULL, NULL);
3950   else
3951     x = event->x;
3952
3953   if (tree_view->priv->hadjustment)
3954     x += gtk_adjustment_get_value (tree_view->priv->hadjustment);
3955
3956   new_width = gtk_tree_view_new_column_width (tree_view,
3957                                               tree_view->priv->drag_pos, &x);
3958   if (x != tree_view->priv->x_drag &&
3959       (new_width != gtk_tree_view_column_get_fixed_width (column)))
3960     {
3961       _gtk_tree_view_column_set_use_resized_width (column, TRUE);
3962
3963       if (gtk_tree_view_column_get_expand (column))
3964         new_width -= tree_view->priv->last_extra_space_per_column;
3965
3966       _gtk_tree_view_column_set_resized_width (column, new_width);
3967
3968
3969       gtk_widget_queue_resize (widget);
3970     }
3971
3972   return FALSE;
3973 }
3974
3975
3976 static void
3977 gtk_tree_view_update_current_reorder (GtkTreeView *tree_view,
3978                                       GdkEvent    *event)
3979 {
3980   GtkTreeViewColumnReorder *reorder = NULL;
3981   GList *list;
3982   gint mouse_x;
3983
3984   gdk_window_get_device_position (tree_view->priv->header_window,
3985                                   gdk_event_get_device (event),
3986                                   &mouse_x, NULL, NULL);
3987   for (list = tree_view->priv->column_drag_info; list; list = list->next)
3988     {
3989       reorder = (GtkTreeViewColumnReorder *) list->data;
3990       if (mouse_x >= reorder->left_align && mouse_x < reorder->right_align)
3991         break;
3992       reorder = NULL;
3993     }
3994
3995   /*  if (reorder && reorder == tree_view->priv->cur_reorder)
3996       return;*/
3997
3998   tree_view->priv->cur_reorder = reorder;
3999   gtk_tree_view_motion_draw_column_motion_arrow (tree_view);
4000 }
4001
4002 static void
4003 gtk_tree_view_vertical_autoscroll (GtkTreeView *tree_view)
4004 {
4005   GdkRectangle visible_rect;
4006   gint y;
4007   gint offset;
4008
4009   gdk_window_get_pointer (tree_view->priv->bin_window, NULL, &y, NULL);
4010   y += tree_view->priv->dy;
4011
4012   gtk_tree_view_get_visible_rect (tree_view, &visible_rect);
4013
4014   /* see if we are near the edge. */
4015   offset = y - (visible_rect.y + 2 * SCROLL_EDGE_SIZE);
4016   if (offset > 0)
4017     {
4018       offset = y - (visible_rect.y + visible_rect.height - 2 * SCROLL_EDGE_SIZE);
4019       if (offset < 0)
4020         return;
4021     }
4022
4023   gtk_adjustment_set_value (tree_view->priv->vadjustment,
4024                             MAX (gtk_adjustment_get_value (tree_view->priv->vadjustment) + offset, 0.0));
4025 }
4026
4027 static gboolean
4028 gtk_tree_view_horizontal_autoscroll (GtkTreeView *tree_view,
4029                                      GdkEvent    *event)
4030 {
4031   GdkRectangle visible_rect;
4032   gint x;
4033   gint offset;
4034
4035   gdk_window_get_device_position (tree_view->priv->bin_window,
4036                                   gdk_event_get_device (event),
4037                                   &x, NULL, NULL);
4038
4039   gtk_tree_view_get_visible_rect (tree_view, &visible_rect);
4040
4041   /* See if we are near the edge. */
4042   offset = x - (visible_rect.x + SCROLL_EDGE_SIZE);
4043   if (offset > 0)
4044     {
4045       offset = x - (visible_rect.x + visible_rect.width - SCROLL_EDGE_SIZE);
4046       if (offset < 0)
4047         return TRUE;
4048     }
4049   offset = offset/3;
4050
4051   gtk_adjustment_set_value (tree_view->priv->hadjustment,
4052                             MAX (gtk_adjustment_get_value (tree_view->priv->hadjustment) + offset, 0.0));
4053
4054   return TRUE;
4055
4056 }
4057
4058 static gboolean
4059 gtk_tree_view_motion_drag_column (GtkWidget      *widget,
4060                                   GdkEventMotion *event)
4061 {
4062   GtkAllocation allocation, button_allocation;
4063   GtkTreeView *tree_view = (GtkTreeView *) widget;
4064   GtkTreeViewColumn *column = tree_view->priv->drag_column;
4065   GtkWidget *button;
4066   gint x, y;
4067
4068   /* Sanity Check */
4069   if ((column == NULL) ||
4070       (event->window != tree_view->priv->drag_window))
4071     return FALSE;
4072
4073   button = gtk_tree_view_column_get_button (column);
4074
4075   /* Handle moving the header */
4076   gdk_window_get_position (tree_view->priv->drag_window, &x, &y);
4077   gtk_widget_get_allocation (widget, &allocation);
4078   gtk_widget_get_allocation (button, &button_allocation);
4079   x = CLAMP (x + (gint)event->x - _gtk_tree_view_column_get_drag_x (column), 0,
4080              MAX (tree_view->priv->width, allocation.width) - button_allocation.width);
4081   gdk_window_move (tree_view->priv->drag_window, x, y);
4082
4083   /* autoscroll, if needed */
4084   gtk_tree_view_horizontal_autoscroll (tree_view, (GdkEvent *) event);
4085   /* Update the current reorder position and arrow; */
4086   gtk_tree_view_update_current_reorder (tree_view, (GdkEvent *) event);
4087
4088   return TRUE;
4089 }
4090
4091 static void
4092 gtk_tree_view_stop_rubber_band (GtkTreeView *tree_view)
4093 {
4094   remove_scroll_timeout (tree_view);
4095   gtk_grab_remove (GTK_WIDGET (tree_view));
4096
4097   if (tree_view->priv->rubber_band_status == RUBBER_BAND_ACTIVE)
4098     {
4099       GtkTreePath *tmp_path;
4100
4101       gtk_widget_queue_draw (GTK_WIDGET (tree_view));
4102
4103       /* The anchor path should be set to the start path */
4104       tmp_path = _gtk_tree_view_find_path (tree_view,
4105                                            tree_view->priv->rubber_band_start_tree,
4106                                            tree_view->priv->rubber_band_start_node);
4107
4108       if (tree_view->priv->anchor)
4109         gtk_tree_row_reference_free (tree_view->priv->anchor);
4110
4111       tree_view->priv->anchor =
4112         gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view),
4113                                           tree_view->priv->model,
4114                                           tmp_path);
4115
4116       gtk_tree_path_free (tmp_path);
4117
4118       /* ... and the cursor to the end path */
4119       tmp_path = _gtk_tree_view_find_path (tree_view,
4120                                            tree_view->priv->rubber_band_end_tree,
4121                                            tree_view->priv->rubber_band_end_node);
4122       gtk_tree_view_real_set_cursor (GTK_TREE_VIEW (tree_view), tmp_path, FALSE, FALSE);
4123       gtk_tree_path_free (tmp_path);
4124
4125       _gtk_tree_selection_emit_changed (tree_view->priv->selection);
4126     }
4127
4128   /* Clear status variables */
4129   tree_view->priv->rubber_band_status = RUBBER_BAND_OFF;
4130   tree_view->priv->rubber_band_extend = FALSE;
4131   tree_view->priv->rubber_band_modify = FALSE;
4132
4133   tree_view->priv->rubber_band_start_node = NULL;
4134   tree_view->priv->rubber_band_start_tree = NULL;
4135   tree_view->priv->rubber_band_end_node = NULL;
4136   tree_view->priv->rubber_band_end_tree = NULL;
4137 }
4138
4139 static void
4140 gtk_tree_view_update_rubber_band_selection_range (GtkTreeView *tree_view,
4141                                                  GtkRBTree   *start_tree,
4142                                                  GtkRBNode   *start_node,
4143                                                  GtkRBTree   *end_tree,
4144                                                  GtkRBNode   *end_node,
4145                                                  gboolean     select,
4146                                                  gboolean     skip_start,
4147                                                  gboolean     skip_end)
4148 {
4149   if (start_node == end_node)
4150     return;
4151
4152   /* We skip the first node and jump inside the loop */
4153   if (skip_start)
4154     goto skip_first;
4155
4156   do
4157     {
4158       /* Small optimization by assuming insensitive nodes are never
4159        * selected.
4160        */
4161       if (!GTK_RBNODE_FLAG_SET (start_node, GTK_RBNODE_IS_SELECTED))
4162         {
4163           GtkTreePath *path;
4164           gboolean selectable;
4165
4166           path = _gtk_tree_view_find_path (tree_view, start_tree, start_node);
4167           selectable = _gtk_tree_selection_row_is_selectable (tree_view->priv->selection, start_node, path);
4168           gtk_tree_path_free (path);
4169
4170           if (!selectable)
4171             goto node_not_selectable;
4172         }
4173
4174       if (select)
4175         {
4176           if (tree_view->priv->rubber_band_extend)
4177             GTK_RBNODE_SET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
4178           else if (tree_view->priv->rubber_band_modify)
4179             {
4180               /* Toggle the selection state */
4181               if (GTK_RBNODE_FLAG_SET (start_node, GTK_RBNODE_IS_SELECTED))
4182                 GTK_RBNODE_UNSET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
4183               else
4184                 GTK_RBNODE_SET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
4185             }
4186           else
4187             GTK_RBNODE_SET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
4188         }
4189       else
4190         {
4191           /* Mirror the above */
4192           if (tree_view->priv->rubber_band_extend)
4193             GTK_RBNODE_UNSET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
4194           else if (tree_view->priv->rubber_band_modify)
4195             {
4196               /* Toggle the selection state */
4197               if (GTK_RBNODE_FLAG_SET (start_node, GTK_RBNODE_IS_SELECTED))
4198                 GTK_RBNODE_UNSET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
4199               else
4200                 GTK_RBNODE_SET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
4201             }
4202           else
4203             GTK_RBNODE_UNSET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
4204         }
4205
4206       _gtk_tree_view_queue_draw_node (tree_view, start_tree, start_node, NULL);
4207
4208 node_not_selectable:
4209       if (start_node == end_node)
4210         break;
4211
4212 skip_first:
4213
4214       if (start_node->children)
4215         {
4216           start_tree = start_node->children;
4217           start_node = start_tree->root;
4218           while (start_node->left != start_tree->nil)
4219             start_node = start_node->left;
4220         }
4221       else
4222         {
4223           _gtk_rbtree_next_full (start_tree, start_node, &start_tree, &start_node);
4224
4225           if (!start_tree)
4226             /* Ran out of tree */
4227             break;
4228         }
4229
4230       if (skip_end && start_node == end_node)
4231         break;
4232     }
4233   while (TRUE);
4234 }
4235
4236 static void
4237 gtk_tree_view_update_rubber_band_selection (GtkTreeView *tree_view)
4238 {
4239   GtkRBTree *start_tree, *end_tree;
4240   GtkRBNode *start_node, *end_node;
4241
4242   _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);
4243   _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);
4244
4245   /* Handle the start area first */
4246   if (!tree_view->priv->rubber_band_start_node)
4247     {
4248       gtk_tree_view_update_rubber_band_selection_range (tree_view,
4249                                                        start_tree,
4250                                                        start_node,
4251                                                        end_tree,
4252                                                        end_node,
4253                                                        TRUE,
4254                                                        FALSE,
4255                                                        FALSE);
4256     }
4257   else if (_gtk_rbtree_node_find_offset (start_tree, start_node) <
4258            _gtk_rbtree_node_find_offset (tree_view->priv->rubber_band_start_tree, tree_view->priv->rubber_band_start_node))
4259     {
4260       /* New node is above the old one; selection became bigger */
4261       gtk_tree_view_update_rubber_band_selection_range (tree_view,
4262                                                        start_tree,
4263                                                        start_node,
4264                                                        tree_view->priv->rubber_band_start_tree,
4265                                                        tree_view->priv->rubber_band_start_node,
4266                                                        TRUE,
4267                                                        FALSE,
4268                                                        TRUE);
4269     }
4270   else if (_gtk_rbtree_node_find_offset (start_tree, start_node) >
4271            _gtk_rbtree_node_find_offset (tree_view->priv->rubber_band_start_tree, tree_view->priv->rubber_band_start_node))
4272     {
4273       /* New node is below the old one; selection became smaller */
4274       gtk_tree_view_update_rubber_band_selection_range (tree_view,
4275                                                        tree_view->priv->rubber_band_start_tree,
4276                                                        tree_view->priv->rubber_band_start_node,
4277                                                        start_tree,
4278                                                        start_node,
4279                                                        FALSE,
4280                                                        FALSE,
4281                                                        TRUE);
4282     }
4283
4284   tree_view->priv->rubber_band_start_tree = start_tree;
4285   tree_view->priv->rubber_band_start_node = start_node;
4286
4287   /* Next, handle the end area */
4288   if (!tree_view->priv->rubber_band_end_node)
4289     {
4290       /* In the event this happens, start_node was also NULL; this case is
4291        * handled above.
4292        */
4293     }
4294   else if (!end_node)
4295     {
4296       /* Find the last node in the tree */
4297       _gtk_rbtree_find_offset (tree_view->priv->tree, tree_view->priv->height - 1,
4298                                &end_tree, &end_node);
4299
4300       /* Selection reached end of the tree */
4301       gtk_tree_view_update_rubber_band_selection_range (tree_view,
4302                                                        tree_view->priv->rubber_band_end_tree,
4303                                                        tree_view->priv->rubber_band_end_node,
4304                                                        end_tree,
4305                                                        end_node,
4306                                                        TRUE,
4307                                                        TRUE,
4308                                                        FALSE);
4309     }
4310   else if (_gtk_rbtree_node_find_offset (end_tree, end_node) >
4311            _gtk_rbtree_node_find_offset (tree_view->priv->rubber_band_end_tree, tree_view->priv->rubber_band_end_node))
4312     {
4313       /* New node is below the old one; selection became bigger */
4314       gtk_tree_view_update_rubber_band_selection_range (tree_view,
4315                                                        tree_view->priv->rubber_band_end_tree,
4316                                                        tree_view->priv->rubber_band_end_node,
4317                                                        end_tree,
4318                                                        end_node,
4319                                                        TRUE,
4320                                                        TRUE,
4321                                                        FALSE);
4322     }
4323   else if (_gtk_rbtree_node_find_offset (end_tree, end_node) <
4324            _gtk_rbtree_node_find_offset (tree_view->priv->rubber_band_end_tree, tree_view->priv->rubber_band_end_node))
4325     {
4326       /* New node is above the old one; selection became smaller */
4327       gtk_tree_view_update_rubber_band_selection_range (tree_view,
4328                                                        end_tree,
4329                                                        end_node,
4330                                                        tree_view->priv->rubber_band_end_tree,
4331                                                        tree_view->priv->rubber_band_end_node,
4332                                                        FALSE,
4333                                                        TRUE,
4334                                                        FALSE);
4335     }
4336
4337   tree_view->priv->rubber_band_end_tree = end_tree;
4338   tree_view->priv->rubber_band_end_node = end_node;
4339 }
4340
4341 static void
4342 gtk_tree_view_update_rubber_band (GtkTreeView *tree_view)
4343 {
4344   gint x, y;
4345   GdkRectangle old_area;
4346   GdkRectangle new_area;
4347   GdkRectangle common;
4348   cairo_region_t *invalid_region;
4349
4350   old_area.x = MIN (tree_view->priv->press_start_x, tree_view->priv->rubber_band_x);
4351   old_area.y = MIN (tree_view->priv->press_start_y, tree_view->priv->rubber_band_y) - tree_view->priv->dy;
4352   old_area.width = ABS (tree_view->priv->rubber_band_x - tree_view->priv->press_start_x) + 1;
4353   old_area.height = ABS (tree_view->priv->rubber_band_y - tree_view->priv->press_start_y) + 1;
4354
4355   gdk_window_get_pointer (tree_view->priv->bin_window, &x, &y, NULL);
4356
4357   x = MAX (x, 0);
4358   y = MAX (y, 0) + tree_view->priv->dy;
4359
4360   new_area.x = MIN (tree_view->priv->press_start_x, x);
4361   new_area.y = MIN (tree_view->priv->press_start_y, y) - tree_view->priv->dy;
4362   new_area.width = ABS (x - tree_view->priv->press_start_x) + 1;
4363   new_area.height = ABS (y - tree_view->priv->press_start_y) + 1;
4364
4365   invalid_region = cairo_region_create_rectangle (&old_area);
4366   cairo_region_union_rectangle (invalid_region, &new_area);
4367
4368   gdk_rectangle_intersect (&old_area, &new_area, &common);
4369   if (common.width > 2 && common.height > 2)
4370     {
4371       cairo_region_t *common_region;
4372
4373       /* make sure the border is invalidated */
4374       common.x += 1;
4375       common.y += 1;
4376       common.width -= 2;
4377       common.height -= 2;
4378
4379       common_region = cairo_region_create_rectangle (&common);
4380
4381       cairo_region_subtract (invalid_region, common_region);
4382       cairo_region_destroy (common_region);
4383     }
4384
4385   gdk_window_invalidate_region (tree_view->priv->bin_window, invalid_region, TRUE);
4386
4387   cairo_region_destroy (invalid_region);
4388
4389   tree_view->priv->rubber_band_x = x;
4390   tree_view->priv->rubber_band_y = y;
4391
4392   gtk_tree_view_update_rubber_band_selection (tree_view);
4393 }
4394
4395 static void
4396 gtk_tree_view_paint_rubber_band (GtkTreeView  *tree_view,
4397                                  cairo_t      *cr)
4398 {
4399   GdkRectangle rect;
4400   GtkStyleContext *context;
4401
4402   cairo_save (cr);
4403
4404   context = gtk_widget_get_style_context (GTK_WIDGET (tree_view));
4405
4406   gtk_style_context_save (context);
4407   gtk_style_context_add_class (context, GTK_STYLE_CLASS_RUBBERBAND);
4408
4409   rect.x = MIN (tree_view->priv->press_start_x, tree_view->priv->rubber_band_x);
4410   rect.y = MIN (tree_view->priv->press_start_y, tree_view->priv->rubber_band_y) - tree_view->priv->dy;
4411   rect.width = ABS (tree_view->priv->press_start_x - tree_view->priv->rubber_band_x) + 1;
4412   rect.height = ABS (tree_view->priv->press_start_y - tree_view->priv->rubber_band_y) + 1;
4413
4414   gdk_cairo_rectangle (cr, &rect);
4415   cairo_clip (cr);
4416
4417   gtk_render_background (context, cr,
4418                          rect.x, rect.y,
4419                          rect.width, rect.height);
4420   gtk_render_frame (context, cr,
4421                     rect.x, rect.y,
4422                     rect.width, rect.height);
4423
4424   gtk_style_context_restore (context);
4425   cairo_restore (cr);
4426 }
4427
4428 static gboolean
4429 gtk_tree_view_motion_bin_window (GtkWidget      *widget,
4430                                  GdkEventMotion *event)
4431 {
4432   GtkTreeView *tree_view;
4433   GtkRBTree *tree;
4434   GtkRBNode *node;
4435   gint new_y;
4436
4437   tree_view = (GtkTreeView *) widget;
4438
4439   if (tree_view->priv->tree == NULL)
4440     return FALSE;
4441
4442   if (tree_view->priv->rubber_band_status == RUBBER_BAND_MAYBE_START)
4443     {
4444       gtk_grab_add (GTK_WIDGET (tree_view));
4445       gtk_tree_view_update_rubber_band (tree_view);
4446
4447       tree_view->priv->rubber_band_status = RUBBER_BAND_ACTIVE;
4448     }
4449   else if (tree_view->priv->rubber_band_status == RUBBER_BAND_ACTIVE)
4450     {
4451       gtk_tree_view_update_rubber_band (tree_view);
4452
4453       add_scroll_timeout (tree_view);
4454     }
4455
4456   /* only check for an initiated drag when a button is pressed */
4457   if (tree_view->priv->pressed_button >= 0
4458       && !tree_view->priv->rubber_band_status)
4459     gtk_tree_view_maybe_begin_dragging_row (tree_view, event);
4460
4461   new_y = TREE_WINDOW_Y_TO_RBTREE_Y(tree_view, event->y);
4462   if (new_y < 0)
4463     new_y = 0;
4464
4465   _gtk_rbtree_find_offset (tree_view->priv->tree, new_y, &tree, &node);
4466
4467   /* If we are currently pressing down a button, we don't want to prelight anything else. */
4468   if ((tree_view->priv->button_pressed_node != NULL) &&
4469       (tree_view->priv->button_pressed_node != node))
4470     node = NULL;
4471
4472   tree_view->priv->event_last_x = event->x;
4473   tree_view->priv->event_last_y = event->y;
4474
4475   prelight_or_select (tree_view, tree, node, event->x, event->y);
4476
4477   return TRUE;
4478 }
4479
4480 static gboolean
4481 gtk_tree_view_motion (GtkWidget      *widget,
4482                       GdkEventMotion *event)
4483 {
4484   GtkTreeView *tree_view;
4485
4486   tree_view = (GtkTreeView *) widget;
4487
4488   /* Resizing a column */
4489   if (tree_view->priv->in_column_resize)
4490     return gtk_tree_view_motion_resize_column (widget, event);
4491
4492   /* Drag column */
4493   if (tree_view->priv->in_column_drag)
4494     return gtk_tree_view_motion_drag_column (widget, event);
4495
4496   /* Sanity check it */
4497   if (event->window == tree_view->priv->bin_window)
4498     return gtk_tree_view_motion_bin_window (widget, event);
4499
4500   return FALSE;
4501 }
4502
4503 /* Invalidate the focus rectangle near the edge of the bin_window; used when
4504  * the tree is empty.
4505  */
4506 static void
4507 invalidate_empty_focus (GtkTreeView *tree_view)
4508 {
4509   GdkRectangle area;
4510
4511   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
4512     return;
4513
4514   area.x = 0;
4515   area.y = 0;
4516   area.width = gdk_window_get_width (tree_view->priv->bin_window);
4517   area.height = gdk_window_get_height (tree_view->priv->bin_window);
4518   gdk_window_invalidate_rect (tree_view->priv->bin_window, &area, FALSE);
4519 }
4520
4521 /* Draws a focus rectangle near the edge of the bin_window; used when the tree
4522  * is empty.
4523  */
4524 static void
4525 draw_empty_focus (GtkTreeView *tree_view, cairo_t *cr)
4526 {
4527   GtkWidget *widget = GTK_WIDGET (tree_view);
4528   gint w, h;
4529
4530   if (!gtk_widget_has_visible_focus (widget))
4531     return;
4532
4533   w = gdk_window_get_width (tree_view->priv->bin_window) - 2;
4534   h = gdk_window_get_height (tree_view->priv->bin_window) - 2;
4535
4536   if (w > 0 && h > 0)
4537     {
4538       GtkStyleContext *context;
4539       GtkStateFlags state;
4540
4541       context = gtk_widget_get_style_context (widget);
4542       state = gtk_widget_get_state_flags (widget);
4543
4544       gtk_style_context_save (context);
4545       gtk_style_context_set_state (context, state);
4546
4547       gtk_render_focus (context, cr, 1, 1, w, h);
4548
4549       gtk_style_context_restore (context);
4550     }
4551 }
4552
4553 typedef enum {
4554   GTK_TREE_VIEW_GRID_LINE,
4555   GTK_TREE_VIEW_TREE_LINE,
4556   GTK_TREE_VIEW_FOREGROUND_LINE
4557 } GtkTreeViewLineType;
4558
4559 static void
4560 gtk_tree_view_draw_line (GtkTreeView         *tree_view,
4561                          cairo_t             *cr,
4562                          GtkTreeViewLineType  type,
4563                          int                  x1,
4564                          int                  y1,
4565                          int                  x2,
4566                          int                  y2)
4567 {
4568   cairo_save (cr);
4569
4570   switch (type)
4571     {
4572     case GTK_TREE_VIEW_TREE_LINE:
4573       cairo_set_source_rgb (cr, 0, 0, 0);
4574       cairo_set_line_width (cr, tree_view->priv->tree_line_width);
4575       if (tree_view->priv->tree_line_dashes[0])
4576         cairo_set_dash (cr,
4577                         tree_view->priv->tree_line_dashes,
4578                         2, 0.5);
4579       break;
4580     case GTK_TREE_VIEW_GRID_LINE:
4581       cairo_set_source_rgb (cr, 0, 0, 0);
4582       cairo_set_line_width (cr, tree_view->priv->grid_line_width);
4583       if (tree_view->priv->grid_line_dashes[0])
4584         cairo_set_dash (cr,
4585                         tree_view->priv->grid_line_dashes,
4586                         2, 0.5);
4587       break;
4588     default:
4589       g_assert_not_reached ();
4590       /* fall through */
4591     case GTK_TREE_VIEW_FOREGROUND_LINE:
4592       {
4593         GtkStyleContext *context;
4594         GtkStateFlags state;
4595         GdkRGBA color;
4596
4597         context = gtk_widget_get_style_context (GTK_WIDGET (tree_view));
4598         state = gtk_widget_get_state_flags (GTK_WIDGET (tree_view));
4599
4600         cairo_set_line_width (cr, 1.0);
4601         gtk_style_context_get_color (context, state, &color);
4602         gdk_cairo_set_source_rgba (cr, &color);
4603       }
4604
4605       break;
4606     }
4607
4608   cairo_move_to (cr, x1 + 0.5, y1 + 0.5);
4609   cairo_line_to (cr, x2 + 0.5, y2 + 0.5);
4610   cairo_stroke (cr);
4611
4612   cairo_restore (cr);
4613 }
4614
4615 static void
4616 gtk_tree_view_draw_grid_lines (GtkTreeView    *tree_view,
4617                                cairo_t        *cr,
4618                                gint            n_visible_columns)
4619 {
4620   GList *list = tree_view->priv->columns;
4621   gint i = 0;
4622   gint current_x = 0;
4623
4624   if (tree_view->priv->grid_lines != GTK_TREE_VIEW_GRID_LINES_VERTICAL
4625       && tree_view->priv->grid_lines != GTK_TREE_VIEW_GRID_LINES_BOTH)
4626     return;
4627
4628   /* Only draw the lines for visible rows and columns */
4629   for (list = tree_view->priv->columns; list; list = list->next, i++)
4630     {
4631       GtkTreeViewColumn *column = list->data;
4632
4633       /* We don't want a line for the last column */
4634       if (i == n_visible_columns - 1)
4635         break;
4636
4637       if (!gtk_tree_view_column_get_visible (column))
4638         continue;
4639
4640       current_x += gtk_tree_view_column_get_width (column);
4641
4642       gtk_tree_view_draw_line (tree_view, cr,
4643                                GTK_TREE_VIEW_GRID_LINE,
4644                                current_x - 1, 0,
4645                                current_x - 1, tree_view->priv->height);
4646     }
4647 }
4648
4649 /* Warning: Very scary function.
4650  * Modify at your own risk
4651  *
4652  * KEEP IN SYNC WITH gtk_tree_view_create_row_drag_icon()!
4653  * FIXME: It's not...
4654  */
4655 static gboolean
4656 gtk_tree_view_bin_draw (GtkWidget      *widget,
4657                         cairo_t        *cr)
4658 {
4659   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
4660   GtkTreePath *path;
4661   GtkRBTree *tree;
4662   GList *list;
4663   GtkRBNode *node;
4664   GtkRBNode *cursor = NULL;
4665   GtkRBTree *cursor_tree = NULL;
4666   GtkRBNode *drag_highlight = NULL;
4667   GtkRBTree *drag_highlight_tree = NULL;
4668   GtkTreeIter iter;
4669   gint new_y;
4670   gint y_offset, cell_offset;
4671   gint max_height;
4672   gint depth;
4673   GdkRectangle background_area;
4674   GdkRectangle cell_area;
4675   GdkRectangle clip;
4676   guint flags;
4677   gint highlight_x;
4678   gint expander_cell_width;
4679   gint bin_window_width;
4680   gint bin_window_height;
4681   GtkTreePath *cursor_path;
4682   GtkTreePath *drag_dest_path;
4683   GList *first_column, *last_column;
4684   gint vertical_separator;
4685   gint horizontal_separator;
4686   gint focus_line_width;
4687   gboolean allow_rules;
4688   gboolean has_can_focus_cell;
4689   gboolean rtl;
4690   gint n_visible_columns;
4691   gint grid_line_width;
4692   gboolean draw_vgrid_lines, draw_hgrid_lines;
4693   GtkStyleContext *context;
4694   GtkStateFlags state;
4695
4696   rtl = (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL);
4697   context = gtk_widget_get_style_context (widget);
4698   state = gtk_widget_get_state_flags (widget);
4699
4700   gtk_widget_style_get (widget,
4701                         "horizontal-separator", &horizontal_separator,
4702                         "vertical-separator", &vertical_separator,
4703                         "allow-rules", &allow_rules,
4704                         "focus-line-width", &focus_line_width,
4705                         NULL);
4706
4707   if (tree_view->priv->tree == NULL)
4708     {
4709       draw_empty_focus (tree_view, cr);
4710       return TRUE;
4711     }
4712
4713   bin_window_width = gdk_window_get_width (tree_view->priv->bin_window);
4714   bin_window_height = gdk_window_get_height (tree_view->priv->bin_window);
4715   cairo_rectangle (cr, 0, 0, bin_window_width, bin_window_height);
4716   cairo_clip (cr);
4717   if (!gdk_cairo_get_clip_rectangle (cr, &clip))
4718     return TRUE;
4719
4720   new_y = TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, clip.y);
4721
4722   if (new_y < 0)
4723     new_y = 0;
4724   y_offset = -_gtk_rbtree_find_offset (tree_view->priv->tree, new_y, &tree, &node);
4725
4726   if (tree_view->priv->height < bin_window_height)
4727     {
4728       gtk_style_context_save (context);
4729       gtk_style_context_set_state (context, state);
4730       gtk_style_context_add_class (context, GTK_STYLE_CLASS_CELL);
4731
4732       gtk_render_background (context, cr,
4733                              0, tree_view->priv->height,
4734                              bin_window_width,
4735                              bin_window_height - tree_view->priv->height);
4736
4737       gtk_style_context_restore (context);
4738     }
4739
4740   if (node == NULL)
4741     return TRUE;
4742
4743   /* find the path for the node */
4744   path = _gtk_tree_view_find_path ((GtkTreeView *)widget,
4745                                    tree,
4746                                    node);
4747   gtk_tree_model_get_iter (tree_view->priv->model,
4748                            &iter,
4749                            path);
4750   depth = gtk_tree_path_get_depth (path);
4751   gtk_tree_path_free (path);
4752
4753   cursor_path = NULL;
4754   drag_dest_path = NULL;
4755
4756   if (tree_view->priv->cursor)
4757     cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
4758
4759   if (cursor_path)
4760     _gtk_tree_view_find_node (tree_view, cursor_path,
4761                               &cursor_tree, &cursor);
4762
4763   if (tree_view->priv->drag_dest_row)
4764     drag_dest_path = gtk_tree_row_reference_get_path (tree_view->priv->drag_dest_row);
4765
4766   if (drag_dest_path)
4767     _gtk_tree_view_find_node (tree_view, drag_dest_path,
4768                               &drag_highlight_tree, &drag_highlight);
4769
4770   draw_vgrid_lines =
4771     tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_VERTICAL
4772     || tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_BOTH;
4773   draw_hgrid_lines =
4774     tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_HORIZONTAL
4775     || tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_BOTH;
4776
4777   if (draw_vgrid_lines || draw_hgrid_lines)
4778     gtk_widget_style_get (widget, "grid-line-width", &grid_line_width, NULL);
4779
4780   n_visible_columns = 0;
4781   for (list = tree_view->priv->columns; list; list = list->next)
4782     {
4783       if (!gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (list->data)))
4784         continue;
4785       n_visible_columns ++;
4786     }
4787
4788   /* Find the last column */
4789   for (last_column = g_list_last (tree_view->priv->columns);
4790        last_column &&
4791        !(gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (last_column->data)));
4792        last_column = last_column->prev)
4793     ;
4794
4795   /* and the first */
4796   for (first_column = g_list_first (tree_view->priv->columns);
4797        first_column &&
4798        !(gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (first_column->data)));
4799        first_column = first_column->next)
4800     ;
4801
4802   /* Actually process the expose event.  To do this, we want to
4803    * start at the first node of the event, and walk the tree in
4804    * order, drawing each successive node.
4805    */
4806
4807   do
4808     {
4809       gboolean parity;
4810       gboolean is_separator = FALSE;
4811       gboolean is_first = FALSE;
4812       gboolean is_last = FALSE;
4813       gint n_col = 0;
4814
4815       is_separator = row_is_separator (tree_view, &iter, NULL);
4816
4817       max_height = gtk_tree_view_get_row_height (tree_view, node);
4818
4819       cell_offset = 0;
4820       highlight_x = 0; /* should match x coord of first cell */
4821       expander_cell_width = 0;
4822
4823       background_area.y = y_offset + clip.y;
4824       background_area.height = max_height;
4825
4826       flags = 0;
4827
4828       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PRELIT))
4829         flags |= GTK_CELL_RENDERER_PRELIT;
4830
4831       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
4832         flags |= GTK_CELL_RENDERER_SELECTED;
4833
4834       parity = _gtk_rbtree_node_find_parity (tree, node);
4835
4836       /* we *need* to set cell data on all cells before the call
4837        * to _has_can_focus_cell, else _has_can_focus_cell() does not
4838        * return a correct value.
4839        */
4840       for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
4841            list;
4842            list = (rtl ? list->prev : list->next))
4843         {
4844           GtkTreeViewColumn *column = list->data;
4845           gtk_tree_view_column_cell_set_cell_data (column,
4846                                                    tree_view->priv->model,
4847                                                    &iter,
4848                                                    GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT),
4849                                                    node->children?TRUE:FALSE);
4850         }
4851
4852       has_can_focus_cell = gtk_tree_view_has_can_focus_cell (tree_view);
4853
4854       for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
4855            list;
4856            list = (rtl ? list->prev : list->next))
4857         {
4858           GtkTreeViewColumn *column = list->data;
4859           GtkRegionFlags row_flags = 0, column_flags = 0;
4860           GtkStateFlags state = 0;
4861           gint width;
4862           gboolean draw_focus;
4863
4864           if (!gtk_tree_view_column_get_visible (column))
4865             continue;
4866
4867           n_col++;
4868           width = gtk_tree_view_column_get_width (column);
4869
4870           if (cell_offset > clip.x + clip.width ||
4871               cell_offset + width < clip.x)
4872             {
4873               cell_offset += width;
4874               continue;
4875             }
4876
4877           if (gtk_tree_view_column_get_sort_indicator (column))
4878             flags |= GTK_CELL_RENDERER_SORTED;
4879           else
4880             flags &= ~GTK_CELL_RENDERER_SORTED;
4881
4882           if (cursor == node)
4883             flags |= GTK_CELL_RENDERER_FOCUSED;
4884           else
4885             flags &= ~GTK_CELL_RENDERER_FOCUSED;
4886
4887           background_area.x = cell_offset;
4888           background_area.width = width;
4889
4890           cell_area = background_area;
4891           cell_area.y += vertical_separator / 2;
4892           cell_area.x += horizontal_separator / 2;
4893           cell_area.height -= vertical_separator;
4894           cell_area.width -= horizontal_separator;
4895
4896           if (draw_vgrid_lines)
4897             {
4898               if (list == first_column)
4899                 {
4900                   cell_area.width -= grid_line_width / 2;
4901                 }
4902               else if (list == last_column)
4903                 {
4904                   cell_area.x += grid_line_width / 2;
4905                   cell_area.width -= grid_line_width / 2;
4906                 }
4907               else
4908                 {
4909                   cell_area.x += grid_line_width / 2;
4910                   cell_area.width -= grid_line_width;
4911                 }
4912             }
4913
4914           if (draw_hgrid_lines)
4915             {
4916               cell_area.y += grid_line_width / 2;
4917               cell_area.height -= grid_line_width;
4918             }
4919
4920           if (!gdk_rectangle_intersect (&clip, &background_area, NULL))
4921             {
4922               cell_offset += gtk_tree_view_column_get_width (column);
4923               continue;
4924             }
4925
4926           gtk_tree_view_column_cell_set_cell_data (column,
4927                                                    tree_view->priv->model,
4928                                                    &iter,
4929                                                    GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT),
4930                                                    node->children?TRUE:FALSE);
4931
4932           /* Select the detail for drawing the cell.  relevant
4933            * factors are parity, sortedness, and whether to
4934            * display rules.
4935            */
4936           if (allow_rules && tree_view->priv->has_rules)
4937             {
4938               if (parity)
4939                 row_flags |= GTK_REGION_ODD;
4940               else
4941                 row_flags |= GTK_REGION_EVEN;
4942             }
4943
4944           if ((flags & GTK_CELL_RENDERER_SORTED) &&
4945               n_visible_columns >= 3)
4946             column_flags |= GTK_REGION_SORTED;
4947
4948           is_first = (rtl ? !list->next : !list->prev);
4949           is_last = (rtl ? !list->prev : !list->next);
4950
4951           if (is_first)
4952             column_flags |= GTK_REGION_FIRST;
4953
4954           if (is_last)
4955             column_flags |= GTK_REGION_LAST;
4956
4957           if ((n_col % 2) == 0)
4958             column_flags |= GTK_REGION_EVEN;
4959           else
4960             column_flags |= GTK_REGION_ODD;
4961
4962           gtk_style_context_save (context);
4963
4964           state = gtk_cell_renderer_get_state (NULL, widget, flags);
4965           gtk_style_context_set_state (context, state);
4966
4967           gtk_style_context_add_class (context, GTK_STYLE_CLASS_CELL);
4968           gtk_style_context_add_region (context, GTK_STYLE_REGION_ROW, row_flags);
4969           gtk_style_context_add_region (context, GTK_STYLE_REGION_COLUMN, column_flags);
4970
4971           if (node == cursor && has_can_focus_cell
4972               && ((column == tree_view->priv->focus_column
4973                    && tree_view->priv->draw_keyfocus &&
4974                    gtk_widget_has_visible_focus (widget))
4975                   || (column == tree_view->priv->edited_column)))
4976             draw_focus = TRUE;
4977           else
4978             draw_focus = FALSE;
4979
4980           /* Draw background */
4981           gtk_render_background (context, cr,
4982                                  background_area.x,
4983                                  background_area.y,
4984                                  background_area.width,
4985                                  background_area.height);
4986
4987           /* Draw frame */
4988           gtk_render_frame (context, cr,
4989                             background_area.x,
4990                             background_area.y,
4991                             background_area.width,
4992                             background_area.height);
4993
4994           if (gtk_tree_view_is_expander_column (tree_view, column))
4995             {
4996               if (!rtl)
4997                 cell_area.x += (depth - 1) * tree_view->priv->level_indentation;
4998               cell_area.width -= (depth - 1) * tree_view->priv->level_indentation;
4999
5000               if (gtk_tree_view_draw_expanders (tree_view))
5001                 {
5002                   if (!rtl)
5003                     cell_area.x += depth * tree_view->priv->expander_size;
5004                   cell_area.width -= depth * tree_view->priv->expander_size;
5005                 }
5006
5007               /* If we have an expander column, the highlight underline
5008                * starts with that column, so that it indicates which
5009                * level of the tree we're dropping at.
5010                */
5011               highlight_x = cell_area.x;
5012               expander_cell_width = cell_area.width;
5013
5014               if (is_separator)
5015                 {
5016                   gtk_style_context_save (context);
5017                   gtk_style_context_add_class (context, GTK_STYLE_CLASS_SEPARATOR);
5018
5019                   gtk_render_line (context, cr,
5020                                    cell_area.x,
5021                                    cell_area.y + cell_area.height / 2,
5022                                    cell_area.x + cell_area.width,
5023                                    cell_area.y + cell_area.height / 2);
5024
5025                   gtk_style_context_restore (context);
5026                 }
5027               else
5028                 {
5029                   _gtk_tree_view_column_cell_render (column,
5030                                                      cr,
5031                                                      &background_area,
5032                                                      &cell_area,
5033                                                      flags,
5034                                                      draw_focus);
5035                 }
5036
5037               if (gtk_tree_view_draw_expanders (tree_view)
5038                   && (node->flags & GTK_RBNODE_IS_PARENT) == GTK_RBNODE_IS_PARENT)
5039                 {
5040                   gtk_tree_view_draw_arrow (GTK_TREE_VIEW (widget),
5041                                             cr,
5042                                             tree,
5043                                             node);
5044                 }
5045             }
5046           else
5047             {
5048               if (is_separator)
5049                 {
5050                   gtk_style_context_save (context);
5051                   gtk_style_context_add_class (context, GTK_STYLE_CLASS_SEPARATOR);
5052
5053                   gtk_render_line (context, cr,
5054                                    cell_area.x,
5055                                    cell_area.y + cell_area.height / 2,
5056                                    cell_area.x + cell_area.width,
5057                                    cell_area.y + cell_area.height / 2);
5058
5059                   gtk_style_context_restore (context);
5060                 }
5061               else
5062                 _gtk_tree_view_column_cell_render (column,
5063                                                    cr,
5064                                                    &background_area,
5065                                                    &cell_area,
5066                                                    flags,
5067                                                    draw_focus);
5068             }
5069
5070           if (draw_hgrid_lines)
5071             {
5072               if (background_area.y > 0)
5073                 gtk_tree_view_draw_line (tree_view, cr,
5074                                          GTK_TREE_VIEW_GRID_LINE,
5075                                          background_area.x, background_area.y,
5076                                          background_area.x + background_area.width,
5077                                          background_area.y);
5078
5079               if (y_offset + max_height >= clip.height)
5080                 gtk_tree_view_draw_line (tree_view, cr,
5081                                          GTK_TREE_VIEW_GRID_LINE,
5082                                          background_area.x, background_area.y + max_height,
5083                                          background_area.x + background_area.width,
5084                                          background_area.y + max_height);
5085             }
5086
5087           if (gtk_tree_view_is_expander_column (tree_view, column) &&
5088               tree_view->priv->tree_lines_enabled)
5089             {
5090               gint x = background_area.x;
5091               gint mult = rtl ? -1 : 1;
5092               gint y0 = background_area.y;
5093               gint y1 = background_area.y + background_area.height/2;
5094               gint y2 = background_area.y + background_area.height;
5095
5096               if (rtl)
5097                 x += background_area.width - 1;
5098
5099               if ((node->flags & GTK_RBNODE_IS_PARENT) == GTK_RBNODE_IS_PARENT
5100                   && depth > 1)
5101                 {
5102                   gtk_tree_view_draw_line (tree_view, cr,
5103                                            GTK_TREE_VIEW_TREE_LINE,
5104                                            x + tree_view->priv->expander_size * (depth - 1.5) * mult,
5105                                            y1,
5106                                            x + tree_view->priv->expander_size * (depth - 1.1) * mult,
5107                                            y1);
5108                 }
5109               else if (depth > 1)
5110                 {
5111                   gtk_tree_view_draw_line (tree_view, cr,
5112                                            GTK_TREE_VIEW_TREE_LINE,
5113                                            x + tree_view->priv->expander_size * (depth - 1.5) * mult,
5114                                            y1,
5115                                            x + tree_view->priv->expander_size * (depth - 0.5) * mult,
5116                                            y1);
5117                 }
5118
5119               if (depth > 1)
5120                 {
5121                   gint i;
5122                   GtkRBNode *tmp_node;
5123                   GtkRBTree *tmp_tree;
5124
5125                   if (!_gtk_rbtree_next (tree, node))
5126                     gtk_tree_view_draw_line (tree_view, cr,
5127                                              GTK_TREE_VIEW_TREE_LINE,
5128                                              x + tree_view->priv->expander_size * (depth - 1.5) * mult,
5129                                              y0,
5130                                              x + tree_view->priv->expander_size * (depth - 1.5) * mult,
5131                                              y1);
5132                   else
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                                              y0,
5137                                              x + tree_view->priv->expander_size * (depth - 1.5) * mult,
5138                                              y2);
5139
5140                   tmp_node = tree->parent_node;
5141                   tmp_tree = tree->parent_tree;
5142
5143                   for (i = depth - 2; i > 0; i--)
5144                     {
5145                       if (_gtk_rbtree_next (tmp_tree, tmp_node))
5146                         gtk_tree_view_draw_line (tree_view, cr,
5147                                                  GTK_TREE_VIEW_TREE_LINE,
5148                                                  x + tree_view->priv->expander_size * (i - 0.5) * mult,
5149                                                  y0,
5150                                                  x + tree_view->priv->expander_size * (i - 0.5) * mult,
5151                                                  y2);
5152
5153                       tmp_node = tmp_tree->parent_node;
5154                       tmp_tree = tmp_tree->parent_tree;
5155                     }
5156                 }
5157             }
5158
5159           gtk_style_context_restore (context);
5160           cell_offset += gtk_tree_view_column_get_width (column);
5161         }
5162
5163       if (node == drag_highlight)
5164         {
5165           /* Draw indicator for the drop
5166            */
5167           gint highlight_y = -1;
5168           GtkRBTree *tree = NULL;
5169           GtkRBNode *node = NULL;
5170
5171           switch (tree_view->priv->drag_dest_pos)
5172             {
5173             case GTK_TREE_VIEW_DROP_BEFORE:
5174               highlight_y = background_area.y - 1;
5175               if (highlight_y < 0)
5176                       highlight_y = 0;
5177               break;
5178
5179             case GTK_TREE_VIEW_DROP_AFTER:
5180               highlight_y = background_area.y + background_area.height - 1;
5181               break;
5182
5183             case GTK_TREE_VIEW_DROP_INTO_OR_BEFORE:
5184             case GTK_TREE_VIEW_DROP_INTO_OR_AFTER:
5185               _gtk_tree_view_find_node (tree_view, drag_dest_path, &tree, &node);
5186
5187               if (tree == NULL)
5188                 break;
5189
5190               gtk_render_focus (context, cr,
5191                                 0, gtk_tree_view_get_row_y_offset (tree_view, tree, node)
5192                                    - focus_line_width / 2,
5193                                 gdk_window_get_width (tree_view->priv->bin_window),
5194                                 gtk_tree_view_get_row_height (tree_view, node)
5195                                    - focus_line_width + 1);
5196               break;
5197             }
5198
5199           if (highlight_y >= 0)
5200             {
5201               gtk_tree_view_draw_line (tree_view, cr,
5202                                        GTK_TREE_VIEW_FOREGROUND_LINE,
5203                                        rtl ? highlight_x + expander_cell_width : highlight_x,
5204                                        highlight_y,
5205                                        rtl ? 0 : bin_window_width,
5206                                        highlight_y);
5207             }
5208         }
5209
5210       /* draw the big row-spanning focus rectangle, if needed */
5211       if (!has_can_focus_cell && node == cursor &&
5212           tree_view->priv->draw_keyfocus &&
5213           gtk_widget_has_visible_focus (widget))
5214         {
5215           gint tmp_y, tmp_height;
5216           GtkStateFlags focus_rect_state = 0;
5217
5218           gtk_style_context_save (context);
5219
5220           focus_rect_state = gtk_cell_renderer_get_state (NULL, widget, flags);
5221           gtk_style_context_set_state (context, focus_rect_state);
5222
5223           if (draw_hgrid_lines)
5224             {
5225               tmp_y = gtk_tree_view_get_row_y_offset (tree_view, tree, node) + grid_line_width / 2;
5226               tmp_height = gtk_tree_view_get_row_height (tree_view, node) - grid_line_width;
5227             }
5228           else
5229             {
5230               tmp_y = gtk_tree_view_get_row_y_offset (tree_view, tree, node);
5231               tmp_height = gtk_tree_view_get_row_height (tree_view, node);
5232             }
5233
5234           gtk_render_focus (context, cr,
5235                             0, tmp_y,
5236                             gdk_window_get_width (tree_view->priv->bin_window),
5237                             tmp_height);
5238
5239           gtk_style_context_restore (context);
5240         }
5241
5242       y_offset += max_height;
5243       if (node->children)
5244         {
5245           GtkTreeIter parent = iter;
5246           gboolean has_child;
5247
5248           tree = node->children;
5249           node = tree->root;
5250
5251           g_assert (node != tree->nil);
5252
5253           while (node->left != tree->nil)
5254             node = node->left;
5255           has_child = gtk_tree_model_iter_children (tree_view->priv->model,
5256                                                     &iter,
5257                                                     &parent);
5258           depth++;
5259
5260           /* Sanity Check! */
5261           TREE_VIEW_INTERNAL_ASSERT (has_child, FALSE);
5262         }
5263       else
5264         {
5265           gboolean done = FALSE;
5266
5267           do
5268             {
5269               node = _gtk_rbtree_next (tree, node);
5270               if (node != NULL)
5271                 {
5272                   gboolean has_next = gtk_tree_model_iter_next (tree_view->priv->model, &iter);
5273                   done = TRUE;
5274
5275                   /* Sanity Check! */
5276                   TREE_VIEW_INTERNAL_ASSERT (has_next, FALSE);
5277                 }
5278               else
5279                 {
5280                   GtkTreeIter parent_iter = iter;
5281                   gboolean has_parent;
5282
5283                   node = tree->parent_node;
5284                   tree = tree->parent_tree;
5285                   if (tree == NULL)
5286                     /* we should go to done to free some memory */
5287                     goto done;
5288                   has_parent = gtk_tree_model_iter_parent (tree_view->priv->model,
5289                                                            &iter,
5290                                                            &parent_iter);
5291                   depth--;
5292
5293                   /* Sanity check */
5294                   TREE_VIEW_INTERNAL_ASSERT (has_parent, FALSE);
5295                 }
5296             }
5297           while (!done);
5298         }
5299     }
5300   while (y_offset < clip.height);
5301
5302 done:
5303   gtk_tree_view_draw_grid_lines (tree_view, cr, n_visible_columns);
5304
5305   if (tree_view->priv->rubber_band_status == RUBBER_BAND_ACTIVE)
5306     gtk_tree_view_paint_rubber_band (tree_view, cr);
5307
5308   if (cursor_path)
5309     gtk_tree_path_free (cursor_path);
5310
5311   if (drag_dest_path)
5312     gtk_tree_path_free (drag_dest_path);
5313
5314   return FALSE;
5315 }
5316
5317 static gboolean
5318 gtk_tree_view_draw (GtkWidget *widget,
5319                     cairo_t   *cr)
5320 {
5321   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
5322   GtkWidget   *button;
5323
5324   if (gtk_cairo_should_draw_window (cr, tree_view->priv->bin_window))
5325     {
5326       GtkStyleContext *context;
5327       GList *tmp_list;
5328
5329       context = gtk_widget_get_style_context (widget);
5330
5331       cairo_save (cr);
5332
5333       gtk_style_context_save (context);
5334       gtk_style_context_add_class (context, GTK_STYLE_CLASS_VIEW);
5335
5336       gtk_cairo_transform_to_window (cr, widget, tree_view->priv->bin_window);
5337
5338       gtk_tree_view_bin_draw (widget, cr);
5339
5340       gtk_style_context_restore (context);
5341       cairo_restore (cr);
5342
5343       /* We can't just chain up to Container::draw as it will try to send the
5344        * event to the headers, so we handle propagating it to our children
5345        * (eg. widgets being edited) ourselves.
5346        */
5347       tmp_list = tree_view->priv->children;
5348       while (tmp_list)
5349         {
5350           GtkTreeViewChild *child = tmp_list->data;
5351           tmp_list = tmp_list->next;
5352
5353           gtk_container_propagate_draw (GTK_CONTAINER (tree_view), child->widget, cr);
5354         }
5355     }
5356
5357   if (gtk_cairo_should_draw_window (cr, tree_view->priv->header_window))
5358     {
5359       GList *list;
5360
5361       for (list = tree_view->priv->columns; list != NULL; list = list->next)
5362         {
5363           GtkTreeViewColumn *column = list->data;
5364
5365           if (column == tree_view->priv->drag_column)
5366             continue;
5367
5368           if (gtk_tree_view_column_get_visible (column))
5369             {
5370               button = gtk_tree_view_column_get_button (column);
5371               gtk_container_propagate_draw (GTK_CONTAINER (tree_view),
5372                                             button, cr);
5373             }
5374         }
5375     }
5376
5377   if (tree_view->priv->drag_window &&
5378       gtk_cairo_should_draw_window (cr, tree_view->priv->drag_window))
5379     {
5380       button = gtk_tree_view_column_get_button (tree_view->priv->drag_column);
5381       gtk_container_propagate_draw (GTK_CONTAINER (tree_view),
5382                                     button, cr);
5383     }
5384
5385   return FALSE;
5386 }
5387
5388 enum
5389 {
5390   DROP_HOME,
5391   DROP_RIGHT,
5392   DROP_LEFT,
5393   DROP_END
5394 };
5395
5396 /* returns 0x1 when no column has been found -- yes it's hackish */
5397 static GtkTreeViewColumn *
5398 gtk_tree_view_get_drop_column (GtkTreeView       *tree_view,
5399                                GtkTreeViewColumn *column,
5400                                gint               drop_position)
5401 {
5402   GtkTreeViewColumn *left_column = NULL;
5403   GtkTreeViewColumn *cur_column = NULL;
5404   GList *tmp_list;
5405
5406   if (!gtk_tree_view_column_get_reorderable (column))
5407     return (GtkTreeViewColumn *)0x1;
5408
5409   switch (drop_position)
5410     {
5411       case DROP_HOME:
5412         /* find first column where we can drop */
5413         tmp_list = tree_view->priv->columns;
5414         if (column == GTK_TREE_VIEW_COLUMN (tmp_list->data))
5415           return (GtkTreeViewColumn *)0x1;
5416
5417         while (tmp_list)
5418           {
5419             g_assert (tmp_list);
5420
5421             cur_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
5422             tmp_list = tmp_list->next;
5423
5424             if (left_column &&
5425                 gtk_tree_view_column_get_visible (left_column) == FALSE)
5426               continue;
5427
5428             if (!tree_view->priv->column_drop_func)
5429               return left_column;
5430
5431             if (!tree_view->priv->column_drop_func (tree_view, column, left_column, cur_column, tree_view->priv->column_drop_func_data))
5432               {
5433                 left_column = cur_column;
5434                 continue;
5435               }
5436
5437             return left_column;
5438           }
5439
5440         if (!tree_view->priv->column_drop_func)
5441           return left_column;
5442
5443         if (tree_view->priv->column_drop_func (tree_view, column, left_column, NULL, tree_view->priv->column_drop_func_data))
5444           return left_column;
5445         else
5446           return (GtkTreeViewColumn *)0x1;
5447         break;
5448
5449       case DROP_RIGHT:
5450         /* find first column after column where we can drop */
5451         tmp_list = tree_view->priv->columns;
5452
5453         for (; tmp_list; tmp_list = tmp_list->next)
5454           if (GTK_TREE_VIEW_COLUMN (tmp_list->data) == column)
5455             break;
5456
5457         if (!tmp_list || !tmp_list->next)
5458           return (GtkTreeViewColumn *)0x1;
5459
5460         tmp_list = tmp_list->next;
5461         left_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
5462         tmp_list = tmp_list->next;
5463
5464         while (tmp_list)
5465           {
5466             g_assert (tmp_list);
5467
5468             cur_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
5469             tmp_list = tmp_list->next;
5470
5471             if (left_column &&
5472                 gtk_tree_view_column_get_visible (left_column) == FALSE)
5473               {
5474                 left_column = cur_column;
5475                 if (tmp_list)
5476                   tmp_list = tmp_list->next;
5477                 continue;
5478               }
5479
5480             if (!tree_view->priv->column_drop_func)
5481               return left_column;
5482
5483             if (!tree_view->priv->column_drop_func (tree_view, column, left_column, cur_column, tree_view->priv->column_drop_func_data))
5484               {
5485                 left_column = cur_column;
5486                 continue;
5487               }
5488
5489             return left_column;
5490           }
5491
5492         if (!tree_view->priv->column_drop_func)
5493           return left_column;
5494
5495         if (tree_view->priv->column_drop_func (tree_view, column, left_column, NULL, tree_view->priv->column_drop_func_data))
5496           return left_column;
5497         else
5498           return (GtkTreeViewColumn *)0x1;
5499         break;
5500
5501       case DROP_LEFT:
5502         /* find first column before column where we can drop */
5503         tmp_list = tree_view->priv->columns;
5504
5505         for (; tmp_list; tmp_list = tmp_list->next)
5506           if (GTK_TREE_VIEW_COLUMN (tmp_list->data) == column)
5507             break;
5508
5509         if (!tmp_list || !tmp_list->prev)
5510           return (GtkTreeViewColumn *)0x1;
5511
5512         tmp_list = tmp_list->prev;
5513         cur_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
5514         tmp_list = tmp_list->prev;
5515
5516         while (tmp_list)
5517           {
5518             g_assert (tmp_list);
5519
5520             left_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
5521
5522             if (left_column &&
5523                 gtk_tree_view_column_get_visible (left_column) == FALSE)
5524               {
5525                 /*if (!tmp_list->prev)
5526                   return (GtkTreeViewColumn *)0x1;
5527                   */
5528 /*
5529                 cur_column = GTK_TREE_VIEW_COLUMN (tmp_list->prev->data);
5530                 tmp_list = tmp_list->prev->prev;
5531                 continue;*/
5532
5533                 cur_column = left_column;
5534                 if (tmp_list)
5535                   tmp_list = tmp_list->prev;
5536                 continue;
5537               }
5538
5539             if (!tree_view->priv->column_drop_func)
5540               return left_column;
5541
5542             if (tree_view->priv->column_drop_func (tree_view, column, left_column, cur_column, tree_view->priv->column_drop_func_data))
5543               return left_column;
5544
5545             cur_column = left_column;
5546             tmp_list = tmp_list->prev;
5547           }
5548
5549         if (!tree_view->priv->column_drop_func)
5550           return NULL;
5551
5552         if (tree_view->priv->column_drop_func (tree_view, column, NULL, cur_column, tree_view->priv->column_drop_func_data))
5553           return NULL;
5554         else
5555           return (GtkTreeViewColumn *)0x1;
5556         break;
5557
5558       case DROP_END:
5559         /* same as DROP_HOME case, but doing it backwards */
5560         tmp_list = g_list_last (tree_view->priv->columns);
5561         cur_column = NULL;
5562
5563         if (column == GTK_TREE_VIEW_COLUMN (tmp_list->data))
5564           return (GtkTreeViewColumn *)0x1;
5565
5566         while (tmp_list)
5567           {
5568             g_assert (tmp_list);
5569
5570             left_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
5571
5572             if (left_column &&
5573                 gtk_tree_view_column_get_visible (left_column) == FALSE)
5574               {
5575                 cur_column = left_column;
5576                 tmp_list = tmp_list->prev;
5577               }
5578
5579             if (!tree_view->priv->column_drop_func)
5580               return left_column;
5581
5582             if (tree_view->priv->column_drop_func (tree_view, column, left_column, cur_column, tree_view->priv->column_drop_func_data))
5583               return left_column;
5584
5585             cur_column = left_column;
5586             tmp_list = tmp_list->prev;
5587           }
5588
5589         if (!tree_view->priv->column_drop_func)
5590           return NULL;
5591
5592         if (tree_view->priv->column_drop_func (tree_view, column, NULL, cur_column, tree_view->priv->column_drop_func_data))
5593           return NULL;
5594         else
5595           return (GtkTreeViewColumn *)0x1;
5596         break;
5597     }
5598
5599   return (GtkTreeViewColumn *)0x1;
5600 }
5601
5602 static gboolean
5603 gtk_tree_view_key_press (GtkWidget   *widget,
5604                          GdkEventKey *event)
5605 {
5606   GtkTreeView *tree_view = (GtkTreeView *) widget;
5607   GtkWidget   *button;
5608
5609   if (tree_view->priv->rubber_band_status)
5610     {
5611       if (event->keyval == GDK_KEY_Escape)
5612         gtk_tree_view_stop_rubber_band (tree_view);
5613
5614       return TRUE;
5615     }
5616
5617   if (tree_view->priv->in_column_drag)
5618     {
5619       if (event->keyval == GDK_KEY_Escape)
5620         {
5621           tree_view->priv->cur_reorder = NULL;
5622           gtk_tree_view_button_release_drag_column (widget, NULL);
5623         }
5624       return TRUE;
5625     }
5626
5627   if (tree_view->priv->headers_visible)
5628     {
5629       GList *focus_column;
5630       gboolean rtl;
5631
5632       rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
5633
5634       for (focus_column = tree_view->priv->columns;
5635            focus_column;
5636            focus_column = focus_column->next)
5637         {
5638           GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN (focus_column->data);
5639
5640           button = gtk_tree_view_column_get_button (column);
5641           if (gtk_widget_has_focus (button))
5642             break;
5643         }
5644
5645       if (focus_column &&
5646           (event->state & GDK_SHIFT_MASK) && (event->state & GDK_MOD1_MASK) &&
5647           (event->keyval == GDK_KEY_Left || event->keyval == GDK_KEY_KP_Left
5648            || event->keyval == GDK_KEY_Right || event->keyval == GDK_KEY_KP_Right))
5649         {
5650           GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN (focus_column->data);
5651           gint max_width, min_width;
5652
5653           if (!gtk_tree_view_column_get_resizable (column))
5654             {
5655               gtk_widget_error_bell (widget);
5656               return TRUE;
5657             }
5658
5659           if (event->keyval == (rtl ? GDK_KEY_Right : GDK_KEY_Left)
5660               || event->keyval == (rtl ? GDK_KEY_KP_Right : GDK_KEY_KP_Left))
5661             {
5662               GtkRequisition button_req;
5663               gint old_width = _gtk_tree_view_column_get_resized_width (column);
5664               gint new_width;
5665
5666               button = gtk_tree_view_column_get_button (column);
5667
5668               gtk_widget_get_preferred_size (button, &button_req, NULL);
5669
5670               new_width = MAX (old_width, gtk_tree_view_column_get_width (column));
5671               new_width -= 2;
5672               if (new_width < 0)
5673                 new_width = 0;
5674
5675               _gtk_tree_view_column_set_resized_width (column, new_width);
5676
5677               min_width = gtk_tree_view_column_get_min_width (column);
5678               if (min_width == -1)
5679                 new_width = MAX (button_req.width, new_width);
5680               else
5681                 {
5682                   new_width = MAX (min_width, new_width);
5683                 }
5684
5685               max_width = gtk_tree_view_column_get_max_width (column);
5686               if (max_width != -1)
5687                 new_width = MIN (new_width, max_width);
5688
5689               _gtk_tree_view_column_set_use_resized_width (column, TRUE);
5690
5691               if (new_width != old_width)
5692                 {
5693                   _gtk_tree_view_column_set_resized_width (column, new_width);
5694                   gtk_widget_queue_resize (widget);
5695                 }
5696               else
5697                 gtk_widget_error_bell (widget);
5698             }
5699           else if (event->keyval == (rtl ? GDK_KEY_Left : GDK_KEY_Right)
5700                    || event->keyval == (rtl ? GDK_KEY_KP_Left : GDK_KEY_KP_Right))
5701             {
5702               gint old_width = _gtk_tree_view_column_get_resized_width (column);
5703               gint new_width;
5704
5705               new_width = MAX (old_width, gtk_tree_view_column_get_width (column));
5706               new_width += 2;
5707
5708               max_width = gtk_tree_view_column_get_max_width (column);
5709               if (max_width != -1)
5710                 new_width = MIN (new_width, max_width);
5711
5712               _gtk_tree_view_column_set_use_resized_width (column, TRUE);
5713
5714               if (new_width != old_width)
5715                 {
5716                   _gtk_tree_view_column_set_resized_width (column, new_width);
5717                   gtk_widget_queue_resize (widget);
5718                 }
5719               else
5720                 gtk_widget_error_bell (widget);
5721             }
5722
5723           return TRUE;
5724         }
5725
5726       if (focus_column &&
5727           (event->state & GDK_MOD1_MASK) &&
5728           (event->keyval == GDK_KEY_Left || event->keyval == GDK_KEY_KP_Left
5729            || event->keyval == GDK_KEY_Right || event->keyval == GDK_KEY_KP_Right
5730            || event->keyval == GDK_KEY_Home || event->keyval == GDK_KEY_KP_Home
5731            || event->keyval == GDK_KEY_End || event->keyval == GDK_KEY_KP_End))
5732         {
5733           GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN (focus_column->data);
5734
5735           if (event->keyval == (rtl ? GDK_KEY_Right : GDK_KEY_Left)
5736               || event->keyval == (rtl ? GDK_KEY_KP_Right : GDK_KEY_KP_Left))
5737             {
5738               GtkTreeViewColumn *col;
5739               col = gtk_tree_view_get_drop_column (tree_view, column, DROP_LEFT);
5740               if (col != (GtkTreeViewColumn *)0x1)
5741                 gtk_tree_view_move_column_after (tree_view, column, col);
5742               else
5743                 gtk_widget_error_bell (widget);
5744             }
5745           else if (event->keyval == (rtl ? GDK_KEY_Left : GDK_KEY_Right)
5746                    || event->keyval == (rtl ? GDK_KEY_KP_Left : GDK_KEY_KP_Right))
5747             {
5748               GtkTreeViewColumn *col;
5749               col = gtk_tree_view_get_drop_column (tree_view, column, DROP_RIGHT);
5750               if (col != (GtkTreeViewColumn *)0x1)
5751                 gtk_tree_view_move_column_after (tree_view, column, col);
5752               else
5753                 gtk_widget_error_bell (widget);
5754             }
5755           else if (event->keyval == GDK_KEY_Home || event->keyval == GDK_KEY_KP_Home)
5756             {
5757               GtkTreeViewColumn *col;
5758               col = gtk_tree_view_get_drop_column (tree_view, column, DROP_HOME);
5759               if (col != (GtkTreeViewColumn *)0x1)
5760                 gtk_tree_view_move_column_after (tree_view, column, col);
5761               else
5762                 gtk_widget_error_bell (widget);
5763             }
5764           else if (event->keyval == GDK_KEY_End || event->keyval == GDK_KEY_KP_End)
5765             {
5766               GtkTreeViewColumn *col;
5767               col = gtk_tree_view_get_drop_column (tree_view, column, DROP_END);
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
5774           return TRUE;
5775         }
5776     }
5777
5778   /* Chain up to the parent class.  It handles the keybindings. */
5779   if (GTK_WIDGET_CLASS (gtk_tree_view_parent_class)->key_press_event (widget, event))
5780     return TRUE;
5781
5782   if (tree_view->priv->search_entry_avoid_unhandled_binding)
5783     {
5784       tree_view->priv->search_entry_avoid_unhandled_binding = FALSE;
5785       return FALSE;
5786     }
5787
5788   /* We pass the event to the search_entry.  If its text changes, then we start
5789    * the typeahead find capabilities. */
5790   if (gtk_widget_has_focus (GTK_WIDGET (tree_view))
5791       && tree_view->priv->enable_search
5792       && !tree_view->priv->search_custom_entry_set)
5793     {
5794       GdkEvent *new_event;
5795       char *old_text;
5796       const char *new_text;
5797       gboolean retval;
5798       GdkScreen *screen;
5799       gboolean text_modified;
5800       gulong popup_menu_id;
5801
5802       gtk_tree_view_ensure_interactive_directory (tree_view);
5803
5804       /* Make a copy of the current text */
5805       old_text = g_strdup (gtk_entry_get_text (GTK_ENTRY (tree_view->priv->search_entry)));
5806       new_event = gdk_event_copy ((GdkEvent *) event);
5807       g_object_unref (((GdkEventKey *) new_event)->window);
5808       ((GdkEventKey *) new_event)->window = g_object_ref (gtk_widget_get_window (tree_view->priv->search_window));
5809       gtk_widget_realize (tree_view->priv->search_window);
5810
5811       popup_menu_id = g_signal_connect (tree_view->priv->search_entry,
5812                                         "popup-menu", G_CALLBACK (gtk_true),
5813                                         NULL);
5814
5815       /* Move the entry off screen */
5816       screen = gtk_widget_get_screen (GTK_WIDGET (tree_view));
5817       gtk_window_move (GTK_WINDOW (tree_view->priv->search_window),
5818                        gdk_screen_get_width (screen) + 1,
5819                        gdk_screen_get_height (screen) + 1);
5820       gtk_widget_show (tree_view->priv->search_window);
5821
5822       /* Send the event to the window.  If the preedit_changed signal is emitted
5823        * during this event, we will set priv->imcontext_changed  */
5824       tree_view->priv->imcontext_changed = FALSE;
5825       retval = gtk_widget_event (tree_view->priv->search_window, new_event);
5826       gdk_event_free (new_event);
5827       gtk_widget_hide (tree_view->priv->search_window);
5828
5829       g_signal_handler_disconnect (tree_view->priv->search_entry,
5830                                    popup_menu_id);
5831
5832       /* We check to make sure that the entry tried to handle the text, and that
5833        * the text has changed.
5834        */
5835       new_text = gtk_entry_get_text (GTK_ENTRY (tree_view->priv->search_entry));
5836       text_modified = strcmp (old_text, new_text) != 0;
5837       g_free (old_text);
5838       if (tree_view->priv->imcontext_changed ||    /* we're in a preedit */
5839           (retval && text_modified))               /* ...or the text was modified */
5840         {
5841           if (gtk_tree_view_real_start_interactive_search (tree_view,
5842                                                            gdk_event_get_device ((GdkEvent *) event),
5843                                                            FALSE))
5844             {
5845               gtk_widget_grab_focus (GTK_WIDGET (tree_view));
5846               return TRUE;
5847             }
5848           else
5849             {
5850               gtk_entry_set_text (GTK_ENTRY (tree_view->priv->search_entry), "");
5851               return FALSE;
5852             }
5853         }
5854     }
5855
5856   return FALSE;
5857 }
5858
5859 static gboolean
5860 gtk_tree_view_key_release (GtkWidget   *widget,
5861                            GdkEventKey *event)
5862 {
5863   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
5864
5865   if (tree_view->priv->rubber_band_status)
5866     return TRUE;
5867
5868   return GTK_WIDGET_CLASS (gtk_tree_view_parent_class)->key_release_event (widget, event);
5869 }
5870
5871 /* FIXME Is this function necessary? Can I get an enter_notify event
5872  * w/o either an expose event or a mouse motion event?
5873  */
5874 static gboolean
5875 gtk_tree_view_enter_notify (GtkWidget        *widget,
5876                             GdkEventCrossing *event)
5877 {
5878   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
5879   GtkRBTree *tree;
5880   GtkRBNode *node;
5881   gint new_y;
5882
5883   /* Sanity check it */
5884   if (event->window != tree_view->priv->bin_window)
5885     return FALSE;
5886
5887   if (tree_view->priv->tree == NULL)
5888     return FALSE;
5889
5890   if (event->mode == GDK_CROSSING_GRAB ||
5891       event->mode == GDK_CROSSING_GTK_GRAB ||
5892       event->mode == GDK_CROSSING_GTK_UNGRAB ||
5893       event->mode == GDK_CROSSING_STATE_CHANGED)
5894     return TRUE;
5895
5896   /* find the node internally */
5897   new_y = TREE_WINDOW_Y_TO_RBTREE_Y(tree_view, event->y);
5898   if (new_y < 0)
5899     new_y = 0;
5900   _gtk_rbtree_find_offset (tree_view->priv->tree, new_y, &tree, &node);
5901
5902   tree_view->priv->event_last_x = event->x;
5903   tree_view->priv->event_last_y = event->y;
5904
5905   if ((tree_view->priv->button_pressed_node == NULL) ||
5906       (tree_view->priv->button_pressed_node == node))
5907     prelight_or_select (tree_view, tree, node, event->x, event->y);
5908
5909   return TRUE;
5910 }
5911
5912 static gboolean
5913 gtk_tree_view_leave_notify (GtkWidget        *widget,
5914                             GdkEventCrossing *event)
5915 {
5916   GtkTreeView *tree_view;
5917
5918   if (event->mode == GDK_CROSSING_GRAB)
5919     return TRUE;
5920
5921   tree_view = GTK_TREE_VIEW (widget);
5922
5923   if (tree_view->priv->prelight_node)
5924     _gtk_tree_view_queue_draw_node (tree_view,
5925                                    tree_view->priv->prelight_tree,
5926                                    tree_view->priv->prelight_node,
5927                                    NULL);
5928
5929   tree_view->priv->event_last_x = -10000;
5930   tree_view->priv->event_last_y = -10000;
5931
5932   prelight_or_select (tree_view,
5933                       NULL, NULL,
5934                       -1000, -1000); /* coords not possibly over an arrow */
5935
5936   return TRUE;
5937 }
5938
5939
5940 static gint
5941 gtk_tree_view_focus_out (GtkWidget     *widget,
5942                          GdkEventFocus *event)
5943 {
5944   GtkTreeView *tree_view;
5945
5946   tree_view = GTK_TREE_VIEW (widget);
5947
5948   gtk_widget_queue_draw (widget);
5949
5950   /* destroy interactive search dialog */
5951   if (tree_view->priv->search_window)
5952     gtk_tree_view_search_dialog_hide (tree_view->priv->search_window, tree_view,
5953                                       gdk_event_get_device ((GdkEvent *) event));
5954
5955   return FALSE;
5956 }
5957
5958
5959 /* Incremental Reflow
5960  */
5961
5962 static void
5963 gtk_tree_view_node_queue_redraw (GtkTreeView *tree_view,
5964                                  GtkRBTree   *tree,
5965                                  GtkRBNode   *node)
5966 {
5967   GtkAllocation allocation;
5968   gint y;
5969
5970   y = _gtk_rbtree_node_find_offset (tree, node)
5971     - gtk_adjustment_get_value (tree_view->priv->vadjustment)
5972     + gtk_tree_view_get_effective_header_height (tree_view);
5973
5974   gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
5975   gtk_widget_queue_draw_area (GTK_WIDGET (tree_view),
5976                               0, y,
5977                               allocation.width,
5978                               GTK_RBNODE_GET_HEIGHT (node));
5979 }
5980
5981 static gboolean
5982 node_is_visible (GtkTreeView *tree_view,
5983                  GtkRBTree   *tree,
5984                  GtkRBNode   *node)
5985 {
5986   int y;
5987   int height;
5988
5989   y = _gtk_rbtree_node_find_offset (tree, node);
5990   height = gtk_tree_view_get_row_height (tree_view, node);
5991
5992   if (y >= gtk_adjustment_get_value (tree_view->priv->vadjustment) &&
5993       y + height <= (gtk_adjustment_get_value (tree_view->priv->vadjustment)
5994                      + gtk_adjustment_get_page_size (tree_view->priv->vadjustment)))
5995     return TRUE;
5996
5997   return FALSE;
5998 }
5999
6000 /* Returns TRUE if it updated the size
6001  */
6002 static gboolean
6003 validate_row (GtkTreeView *tree_view,
6004               GtkRBTree   *tree,
6005               GtkRBNode   *node,
6006               GtkTreeIter *iter,
6007               GtkTreePath *path)
6008 {
6009   GtkTreeViewColumn *column;
6010   GList *list, *first_column, *last_column;
6011   gint height = 0;
6012   gint horizontal_separator;
6013   gint vertical_separator;
6014   gint depth = gtk_tree_path_get_depth (path);
6015   gboolean retval = FALSE;
6016   gboolean is_separator = FALSE;
6017   gboolean draw_vgrid_lines, draw_hgrid_lines;
6018   gint focus_pad;
6019   gint grid_line_width;
6020   gboolean wide_separators;
6021   gint separator_height;
6022
6023   /* double check the row needs validating */
6024   if (! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) &&
6025       ! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
6026     return FALSE;
6027
6028   is_separator = row_is_separator (tree_view, iter, NULL);
6029
6030   gtk_widget_style_get (GTK_WIDGET (tree_view),
6031                         "focus-padding", &focus_pad,
6032                         "horizontal-separator", &horizontal_separator,
6033                         "vertical-separator", &vertical_separator,
6034                         "grid-line-width", &grid_line_width,
6035                         "wide-separators",  &wide_separators,
6036                         "separator-height", &separator_height,
6037                         NULL);
6038
6039   draw_vgrid_lines =
6040     tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_VERTICAL
6041     || tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_BOTH;
6042   draw_hgrid_lines =
6043     tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_HORIZONTAL
6044     || tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_BOTH;
6045
6046   for (last_column = g_list_last (tree_view->priv->columns);
6047        last_column &&
6048        !(gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (last_column->data)));
6049        last_column = last_column->prev)
6050     ;
6051
6052   for (first_column = g_list_first (tree_view->priv->columns);
6053        first_column &&
6054        !(gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (first_column->data)));
6055        first_column = first_column->next)
6056     ;
6057
6058   for (list = tree_view->priv->columns; list; list = list->next)
6059     {
6060       gint padding = 0;
6061       gint original_width;
6062       gint new_width;
6063       gint row_height;
6064
6065       column = list->data;
6066
6067       if (!gtk_tree_view_column_get_visible (column))
6068         continue;
6069
6070       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID) &&
6071           !_gtk_tree_view_column_cell_get_dirty (column))
6072         continue;
6073
6074       original_width = _gtk_tree_view_column_get_requested_width (column);
6075
6076       gtk_tree_view_column_cell_set_cell_data (column, tree_view->priv->model, iter,
6077                                                GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT),
6078                                                node->children?TRUE:FALSE);
6079       gtk_tree_view_column_cell_get_size (column,
6080                                           NULL, NULL, NULL,
6081                                           NULL, &row_height);
6082
6083       if (!is_separator)
6084         {
6085           row_height += vertical_separator;
6086           height = MAX (height, row_height);
6087           height = MAX (height, tree_view->priv->expander_size);
6088         }
6089       else
6090         {
6091           if (wide_separators)
6092             height = separator_height + 2 * focus_pad;
6093           else
6094             height = 2 + 2 * focus_pad;
6095         }
6096
6097       if (gtk_tree_view_is_expander_column (tree_view, column))
6098         {
6099           padding += horizontal_separator + (depth - 1) * tree_view->priv->level_indentation;
6100
6101           if (gtk_tree_view_draw_expanders (tree_view))
6102             padding += depth * tree_view->priv->expander_size;
6103         }
6104       else
6105         padding += horizontal_separator;
6106
6107       if (draw_vgrid_lines)
6108         {
6109           if (list->data == first_column || list->data == last_column)
6110             padding += grid_line_width / 2.0;
6111           else
6112             padding += grid_line_width;
6113         }
6114
6115       /* Update the padding for the column */
6116       _gtk_tree_view_column_push_padding (column, padding);
6117       new_width = _gtk_tree_view_column_get_requested_width (column);
6118
6119       if (new_width > original_width)
6120         retval = TRUE;
6121     }
6122
6123   if (draw_hgrid_lines)
6124     height += grid_line_width;
6125
6126   if (height != GTK_RBNODE_GET_HEIGHT (node))
6127     {
6128       retval = TRUE;
6129       _gtk_rbtree_node_set_height (tree, node, height);
6130     }
6131   _gtk_rbtree_node_mark_valid (tree, node);
6132   tree_view->priv->post_validation_flag = TRUE;
6133
6134   return retval;
6135 }
6136
6137
6138 static void
6139 validate_visible_area (GtkTreeView *tree_view)
6140 {
6141   GtkAllocation allocation;
6142   GtkTreePath *path = NULL;
6143   GtkTreePath *above_path = NULL;
6144   GtkTreeIter iter;
6145   GtkRBTree *tree = NULL;
6146   GtkRBNode *node = NULL;
6147   gboolean need_redraw = FALSE;
6148   gboolean size_changed = FALSE;
6149   gint total_height;
6150   gint area_above = 0;
6151   gint area_below = 0;
6152
6153   if (tree_view->priv->tree == NULL)
6154     return;
6155
6156   if (! GTK_RBNODE_FLAG_SET (tree_view->priv->tree->root, GTK_RBNODE_DESCENDANTS_INVALID) &&
6157       tree_view->priv->scroll_to_path == NULL)
6158     return;
6159
6160   gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
6161   total_height = allocation.height - gtk_tree_view_get_effective_header_height (tree_view);
6162
6163   if (total_height == 0)
6164     return;
6165
6166   /* First, we check to see if we need to scroll anywhere
6167    */
6168   if (tree_view->priv->scroll_to_path)
6169     {
6170       path = gtk_tree_row_reference_get_path (tree_view->priv->scroll_to_path);
6171       if (path && !_gtk_tree_view_find_node (tree_view, path, &tree, &node))
6172         {
6173           /* we are going to scroll, and will update dy */
6174           gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
6175           if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) ||
6176               GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
6177             {
6178               _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
6179               if (validate_row (tree_view, tree, node, &iter, path))
6180                 size_changed = TRUE;
6181             }
6182
6183           if (tree_view->priv->scroll_to_use_align)
6184             {
6185               gint height = gtk_tree_view_get_row_height (tree_view, node);
6186               area_above = (total_height - height) *
6187                 tree_view->priv->scroll_to_row_align;
6188               area_below = total_height - area_above - height;
6189               area_above = MAX (area_above, 0);
6190               area_below = MAX (area_below, 0);
6191             }
6192           else
6193             {
6194               /* two cases:
6195                * 1) row not visible
6196                * 2) row visible
6197                */
6198               gint dy;
6199               gint height = gtk_tree_view_get_row_height (tree_view, node);
6200
6201               dy = _gtk_rbtree_node_find_offset (tree, node);
6202
6203               if (dy >= gtk_adjustment_get_value (tree_view->priv->vadjustment) &&
6204                   dy + height <= (gtk_adjustment_get_value (tree_view->priv->vadjustment)
6205                                   + gtk_adjustment_get_page_size (tree_view->priv->vadjustment)))
6206                 {
6207                   /* row visible: keep the row at the same position */
6208                   area_above = dy - gtk_adjustment_get_value (tree_view->priv->vadjustment);
6209                   area_below = (gtk_adjustment_get_value (tree_view->priv->vadjustment) +
6210                                 gtk_adjustment_get_page_size (tree_view->priv->vadjustment))
6211                                - dy - height;
6212                 }
6213               else
6214                 {
6215                   /* row not visible */
6216                   if (dy >= 0
6217                       && dy + height <= gtk_adjustment_get_page_size (tree_view->priv->vadjustment))
6218                     {
6219                       /* row at the beginning -- fixed */
6220                       area_above = dy;
6221                       area_below = gtk_adjustment_get_page_size (tree_view->priv->vadjustment)
6222                                    - area_above - height;
6223                     }
6224                   else if (dy >= (gtk_adjustment_get_upper (tree_view->priv->vadjustment) -
6225                                   gtk_adjustment_get_page_size (tree_view->priv->vadjustment)))
6226                     {
6227                       /* row at the end -- fixed */
6228                       area_above = dy - (gtk_adjustment_get_upper (tree_view->priv->vadjustment) -
6229                                    gtk_adjustment_get_page_size (tree_view->priv->vadjustment));
6230                       area_below = gtk_adjustment_get_page_size (tree_view->priv->vadjustment) -
6231                                    area_above - height;
6232
6233                       if (area_below < 0)
6234                         {
6235                           area_above = gtk_adjustment_get_page_size (tree_view->priv->vadjustment) - height;
6236                           area_below = 0;
6237                         }
6238                     }
6239                   else
6240                     {
6241                       /* row somewhere in the middle, bring it to the top
6242                        * of the view
6243                        */
6244                       area_above = 0;
6245                       area_below = total_height - height;
6246                     }
6247                 }
6248             }
6249         }
6250       else
6251         /* the scroll to isn't valid; ignore it.
6252          */
6253         {
6254           if (tree_view->priv->scroll_to_path && !path)
6255             {
6256               gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
6257               tree_view->priv->scroll_to_path = NULL;
6258             }
6259           if (path)
6260             gtk_tree_path_free (path);
6261           path = NULL;
6262         }
6263     }
6264
6265   /* We didn't have a scroll_to set, so we just handle things normally
6266    */
6267   if (path == NULL)
6268     {
6269       gint offset;
6270
6271       offset = _gtk_rbtree_find_offset (tree_view->priv->tree,
6272                                         TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, 0),
6273                                         &tree, &node);
6274       if (node == NULL)
6275         {
6276           /* In this case, nothing has been validated */
6277           path = gtk_tree_path_new_first ();
6278           _gtk_tree_view_find_node (tree_view, path, &tree, &node);
6279         }
6280       else
6281         {
6282           path = _gtk_tree_view_find_path (tree_view, tree, node);
6283           total_height += offset;
6284         }
6285
6286       gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
6287
6288       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) ||
6289           GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
6290         {
6291           _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
6292           if (validate_row (tree_view, tree, node, &iter, path))
6293             size_changed = TRUE;
6294         }
6295       area_above = 0;
6296       area_below = total_height - gtk_tree_view_get_row_height (tree_view, node);
6297     }
6298
6299   above_path = gtk_tree_path_copy (path);
6300
6301   /* if we do not validate any row above the new top_row, we will make sure
6302    * that the row immediately above top_row has been validated. (if we do not
6303    * do this, _gtk_rbtree_find_offset will find the row above top_row, because
6304    * when invalidated that row's height will be zero. and this will mess up
6305    * scrolling).
6306    */
6307   if (area_above == 0)
6308     {
6309       GtkRBTree *tmptree;
6310       GtkRBNode *tmpnode;
6311
6312       _gtk_tree_view_find_node (tree_view, above_path, &tmptree, &tmpnode);
6313       _gtk_rbtree_prev_full (tmptree, tmpnode, &tmptree, &tmpnode);
6314
6315       if (tmpnode)
6316         {
6317           GtkTreePath *tmppath;
6318           GtkTreeIter tmpiter;
6319
6320           tmppath = _gtk_tree_view_find_path (tree_view, tmptree, tmpnode);
6321           gtk_tree_model_get_iter (tree_view->priv->model, &tmpiter, tmppath);
6322
6323           if (GTK_RBNODE_FLAG_SET (tmpnode, GTK_RBNODE_INVALID) ||
6324               GTK_RBNODE_FLAG_SET (tmpnode, GTK_RBNODE_COLUMN_INVALID))
6325             {
6326               _gtk_tree_view_queue_draw_node (tree_view, tmptree, tmpnode, NULL);
6327               if (validate_row (tree_view, tmptree, tmpnode, &tmpiter, tmppath))
6328                 size_changed = TRUE;
6329             }
6330
6331           gtk_tree_path_free (tmppath);
6332         }
6333     }
6334
6335   /* Now, we walk forwards and backwards, measuring rows. Unfortunately,
6336    * backwards is much slower then forward, as there is no iter_prev function.
6337    * We go forwards first in case we run out of tree.  Then we go backwards to
6338    * fill out the top.
6339    */
6340   while (node && area_below > 0)
6341     {
6342       if (node->children)
6343         {
6344           GtkTreeIter parent = iter;
6345           gboolean has_child;
6346
6347           tree = node->children;
6348           node = tree->root;
6349
6350           g_assert (node != tree->nil);
6351
6352           while (node->left != tree->nil)
6353             node = node->left;
6354           has_child = gtk_tree_model_iter_children (tree_view->priv->model,
6355                                                     &iter,
6356                                                     &parent);
6357           TREE_VIEW_INTERNAL_ASSERT_VOID (has_child);
6358           gtk_tree_path_down (path);
6359         }
6360       else
6361         {
6362           gboolean done = FALSE;
6363           do
6364             {
6365               node = _gtk_rbtree_next (tree, node);
6366               if (node != NULL)
6367                 {
6368                   gboolean has_next = gtk_tree_model_iter_next (tree_view->priv->model, &iter);
6369                   done = TRUE;
6370                   gtk_tree_path_next (path);
6371
6372                   /* Sanity Check! */
6373                   TREE_VIEW_INTERNAL_ASSERT_VOID (has_next);
6374                 }
6375               else
6376                 {
6377                   GtkTreeIter parent_iter = iter;
6378                   gboolean has_parent;
6379
6380                   node = tree->parent_node;
6381                   tree = tree->parent_tree;
6382                   if (tree == NULL)
6383                     break;
6384                   has_parent = gtk_tree_model_iter_parent (tree_view->priv->model,
6385                                                            &iter,
6386                                                            &parent_iter);
6387                   gtk_tree_path_up (path);
6388
6389                   /* Sanity check */
6390                   TREE_VIEW_INTERNAL_ASSERT_VOID (has_parent);
6391                 }
6392             }
6393           while (!done);
6394         }
6395
6396       if (!node)
6397         break;
6398
6399       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) ||
6400           GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
6401         {
6402           _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
6403           if (validate_row (tree_view, tree, node, &iter, path))
6404               size_changed = TRUE;
6405         }
6406
6407       area_below -= gtk_tree_view_get_row_height (tree_view, node);
6408     }
6409   gtk_tree_path_free (path);
6410
6411   /* If we ran out of tree, and have extra area_below left, we need to add it
6412    * to area_above */
6413   if (area_below > 0)
6414     area_above += area_below;
6415
6416   _gtk_tree_view_find_node (tree_view, above_path, &tree, &node);
6417
6418   /* We walk backwards */
6419   while (area_above > 0)
6420     {
6421       _gtk_rbtree_prev_full (tree, node, &tree, &node);
6422
6423       /* Always find the new path in the tree.  We cannot just assume
6424        * a gtk_tree_path_prev() is enough here, as there might be children
6425        * in between this node and the previous sibling node.  If this
6426        * appears to be a performance hotspot in profiles, we can look into
6427        * intrigate logic for keeping path, node and iter in sync like
6428        * we do for forward walks.  (Which will be hard because of the lacking
6429        * iter_prev).
6430        */
6431
6432       if (node == NULL)
6433         break;
6434
6435       gtk_tree_path_free (above_path);
6436       above_path = _gtk_tree_view_find_path (tree_view, tree, node);
6437
6438       gtk_tree_model_get_iter (tree_view->priv->model, &iter, above_path);
6439
6440       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) ||
6441           GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
6442         {
6443           _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
6444           if (validate_row (tree_view, tree, node, &iter, above_path))
6445             size_changed = TRUE;
6446         }
6447       area_above -= gtk_tree_view_get_row_height (tree_view, node);
6448     }
6449
6450   /* if we scrolled to a path, we need to set the dy here,
6451    * and sync the top row accordingly
6452    */
6453   if (tree_view->priv->scroll_to_path)
6454     {
6455       gtk_tree_view_set_top_row (tree_view, above_path, -area_above);
6456       gtk_tree_view_top_row_to_dy (tree_view);
6457
6458       need_redraw = TRUE;
6459     }
6460   else if (tree_view->priv->height <= gtk_adjustment_get_page_size (tree_view->priv->vadjustment))
6461     {
6462       /* when we are not scrolling, we should never set dy to something
6463        * else than zero. we update top_row to be in sync with dy = 0.
6464        */
6465       gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment), 0);
6466       gtk_tree_view_dy_to_top_row (tree_view);
6467     }
6468   else if (gtk_adjustment_get_value (tree_view->priv->vadjustment) + gtk_adjustment_get_page_size (tree_view->priv->vadjustment) > tree_view->priv->height)
6469     {
6470       gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment), tree_view->priv->height - gtk_adjustment_get_page_size (tree_view->priv->vadjustment));
6471       gtk_tree_view_dy_to_top_row (tree_view);
6472     }
6473   else
6474     gtk_tree_view_top_row_to_dy (tree_view);
6475
6476   /* update width/height and queue a resize */
6477   if (size_changed)
6478     {
6479       GtkRequisition requisition;
6480
6481       /* We temporarily guess a size, under the assumption that it will be the
6482        * same when we get our next size_allocate.  If we don't do this, we'll be
6483        * in an inconsistent state if we call top_row_to_dy. */
6484
6485       gtk_widget_get_preferred_size (GTK_WIDGET (tree_view),
6486                                      &requisition, NULL);
6487       gtk_adjustment_set_upper (tree_view->priv->hadjustment,
6488                                 MAX (gtk_adjustment_get_upper (tree_view->priv->hadjustment), requisition.width));
6489       gtk_adjustment_set_upper (tree_view->priv->vadjustment,
6490                                 MAX (gtk_adjustment_get_upper (tree_view->priv->vadjustment), requisition.height));
6491       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
6492     }
6493
6494   if (tree_view->priv->scroll_to_path)
6495     {
6496       gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
6497       tree_view->priv->scroll_to_path = NULL;
6498     }
6499
6500   if (above_path)
6501     gtk_tree_path_free (above_path);
6502
6503   if (tree_view->priv->scroll_to_column)
6504     {
6505       tree_view->priv->scroll_to_column = NULL;
6506     }
6507   if (need_redraw)
6508     gtk_widget_queue_draw (GTK_WIDGET (tree_view));
6509 }
6510
6511 static void
6512 initialize_fixed_height_mode (GtkTreeView *tree_view)
6513 {
6514   if (!tree_view->priv->tree)
6515     return;
6516
6517   if (tree_view->priv->fixed_height < 0)
6518     {
6519       GtkTreeIter iter;
6520       GtkTreePath *path;
6521
6522       GtkRBTree *tree = NULL;
6523       GtkRBNode *node = NULL;
6524
6525       tree = tree_view->priv->tree;
6526       node = tree->root;
6527
6528       path = _gtk_tree_view_find_path (tree_view, tree, node);
6529       gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
6530
6531       validate_row (tree_view, tree, node, &iter, path);
6532
6533       gtk_tree_path_free (path);
6534
6535       tree_view->priv->fixed_height = gtk_tree_view_get_row_height (tree_view, node);
6536     }
6537
6538    _gtk_rbtree_set_fixed_height (tree_view->priv->tree,
6539                                  tree_view->priv->fixed_height, TRUE);
6540 }
6541
6542 /* Our strategy for finding nodes to validate is a little convoluted.  We find
6543  * the left-most uninvalidated node.  We then try walking right, validating
6544  * nodes.  Once we find a valid node, we repeat the previous process of finding
6545  * the first invalid node.
6546  */
6547
6548 static gboolean
6549 do_validate_rows (GtkTreeView *tree_view, gboolean queue_resize)
6550 {
6551   GtkRBTree *tree = NULL;
6552   GtkRBNode *node = NULL;
6553   gboolean validated_area = FALSE;
6554   gint retval = TRUE;
6555   GtkTreePath *path = NULL;
6556   GtkTreeIter iter;
6557   GTimer *timer;
6558   gint i = 0;
6559
6560   gint y = -1;
6561   gint prev_height = -1;
6562   gboolean fixed_height = TRUE;
6563
6564   g_assert (tree_view);
6565
6566   if (tree_view->priv->tree == NULL)
6567       return FALSE;
6568
6569   if (tree_view->priv->fixed_height_mode)
6570     {
6571       if (tree_view->priv->fixed_height < 0)
6572         initialize_fixed_height_mode (tree_view);
6573
6574       return FALSE;
6575     }
6576
6577   timer = g_timer_new ();
6578   g_timer_start (timer);
6579
6580   do
6581     {
6582       gboolean changed = FALSE;
6583
6584       if (! GTK_RBNODE_FLAG_SET (tree_view->priv->tree->root, GTK_RBNODE_DESCENDANTS_INVALID))
6585         {
6586           retval = FALSE;
6587           goto done;
6588         }
6589
6590       if (path != NULL)
6591         {
6592           node = _gtk_rbtree_next (tree, node);
6593           if (node != NULL)
6594             {
6595               TREE_VIEW_INTERNAL_ASSERT (gtk_tree_model_iter_next (tree_view->priv->model, &iter), FALSE);
6596               gtk_tree_path_next (path);
6597             }
6598           else
6599             {
6600               gtk_tree_path_free (path);
6601               path = NULL;
6602             }
6603         }
6604
6605       if (path == NULL)
6606         {
6607           tree = tree_view->priv->tree;
6608           node = tree_view->priv->tree->root;
6609
6610           g_assert (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_DESCENDANTS_INVALID));
6611
6612           do
6613             {
6614               if (node->left != tree->nil &&
6615                   GTK_RBNODE_FLAG_SET (node->left, GTK_RBNODE_DESCENDANTS_INVALID))
6616                 {
6617                   node = node->left;
6618                 }
6619               else if (node->right != tree->nil &&
6620                        GTK_RBNODE_FLAG_SET (node->right, GTK_RBNODE_DESCENDANTS_INVALID))
6621                 {
6622                   node = node->right;
6623                 }
6624               else if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) ||
6625                        GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
6626                 {
6627                   break;
6628                 }
6629               else if (node->children != NULL)
6630                 {
6631                   tree = node->children;
6632                   node = tree->root;
6633                 }
6634               else
6635                 /* RBTree corruption!  All bad */
6636                 g_assert_not_reached ();
6637             }
6638           while (TRUE);
6639           path = _gtk_tree_view_find_path (tree_view, tree, node);
6640           gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
6641         }
6642
6643       changed = validate_row (tree_view, tree, node, &iter, path);
6644       validated_area = changed || validated_area;
6645
6646       if (changed)
6647         {
6648           gint offset = gtk_tree_view_get_row_y_offset (tree_view, tree, node);
6649
6650           if (y == -1 || y > offset)
6651             y = offset;
6652         }
6653
6654       if (!tree_view->priv->fixed_height_check)
6655         {
6656           gint height;
6657
6658           height = gtk_tree_view_get_row_height (tree_view, node);
6659           if (prev_height < 0)
6660             prev_height = height;
6661           else if (prev_height != height)
6662             fixed_height = FALSE;
6663         }
6664
6665       i++;
6666     }
6667   while (g_timer_elapsed (timer, NULL) < GTK_TREE_VIEW_TIME_MS_PER_IDLE / 1000.);
6668
6669   if (!tree_view->priv->fixed_height_check)
6670    {
6671      if (fixed_height)
6672        _gtk_rbtree_set_fixed_height (tree_view->priv->tree, prev_height, FALSE);
6673
6674      tree_view->priv->fixed_height_check = 1;
6675    }
6676
6677  done:
6678   if (validated_area)
6679     {
6680       GtkRequisition requisition;
6681
6682       /* We temporarily guess a size, under the assumption that it will be the
6683        * same when we get our next size_allocate.  If we don't do this, we'll be
6684        * in an inconsistent state when we call top_row_to_dy. */
6685
6686       /* FIXME: This is called from size_request, for some reason it is not infinitely
6687        * recursing, we cannot call gtk_widget_get_preferred_size() here because that's
6688        * not allowed (from inside ->get_preferred_width/height() implementations, one
6689        * should call the vfuncs directly). However what is desired here is the full
6690        * size including any margins and limited by any alignment (i.e. after
6691        * GtkWidget:adjust_size_request() is called).
6692        *
6693        * Currently bypassing this but the real solution is to not update the scroll adjustments
6694        * untill we've recieved an allocation (never update scroll adjustments from size-requests).
6695        */
6696       gtk_tree_view_size_request (GTK_WIDGET (tree_view), &requisition, FALSE);
6697
6698       /* If rows above the current position have changed height, this has
6699        * affected the current view and thus needs a redraw.
6700        */
6701       if (y != -1 && y < gtk_adjustment_get_value (tree_view->priv->vadjustment))
6702         gtk_widget_queue_draw (GTK_WIDGET (tree_view));
6703
6704       gtk_adjustment_set_upper (tree_view->priv->hadjustment,
6705                                 MAX (gtk_adjustment_get_upper (tree_view->priv->hadjustment), requisition.width));
6706       gtk_adjustment_set_upper (tree_view->priv->vadjustment,
6707                                 MAX (gtk_adjustment_get_upper (tree_view->priv->vadjustment), requisition.height));
6708
6709       if (queue_resize)
6710         gtk_widget_queue_resize_no_redraw (GTK_WIDGET (tree_view));
6711     }
6712
6713   if (path) gtk_tree_path_free (path);
6714   g_timer_destroy (timer);
6715
6716   return retval;
6717 }
6718
6719 static gboolean
6720 validate_rows (GtkTreeView *tree_view)
6721 {
6722   gboolean retval;
6723
6724   retval = do_validate_rows (tree_view, TRUE);
6725
6726   if (! retval && tree_view->priv->validate_rows_timer)
6727     {
6728       g_source_remove (tree_view->priv->validate_rows_timer);
6729       tree_view->priv->validate_rows_timer = 0;
6730     }
6731
6732   return retval;
6733 }
6734
6735 static gboolean
6736 validate_rows_handler (GtkTreeView *tree_view)
6737 {
6738   gboolean retval;
6739
6740   retval = do_validate_rows (tree_view, TRUE);
6741   if (! retval && tree_view->priv->validate_rows_timer)
6742     {
6743       g_source_remove (tree_view->priv->validate_rows_timer);
6744       tree_view->priv->validate_rows_timer = 0;
6745     }
6746
6747   return retval;
6748 }
6749
6750 static gboolean
6751 do_presize_handler (GtkTreeView *tree_view)
6752 {
6753   if (tree_view->priv->mark_rows_col_dirty)
6754     {
6755       if (tree_view->priv->tree)
6756         _gtk_rbtree_column_invalid (tree_view->priv->tree);
6757       tree_view->priv->mark_rows_col_dirty = FALSE;
6758     }
6759   validate_visible_area (tree_view);
6760   tree_view->priv->presize_handler_timer = 0;
6761
6762   if (tree_view->priv->fixed_height_mode)
6763     {
6764       GtkRequisition requisition;
6765
6766       gtk_widget_get_preferred_size (GTK_WIDGET (tree_view),
6767                                      &requisition, NULL);
6768
6769       gtk_adjustment_set_upper (tree_view->priv->hadjustment,
6770                                 MAX (gtk_adjustment_get_upper (tree_view->priv->hadjustment), requisition.width));
6771       gtk_adjustment_set_upper (tree_view->priv->vadjustment,
6772                                 MAX (gtk_adjustment_get_upper (tree_view->priv->vadjustment), requisition.height));
6773       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
6774     }
6775
6776   return FALSE;
6777 }
6778
6779 static gboolean
6780 presize_handler_callback (gpointer data)
6781 {
6782   do_presize_handler (GTK_TREE_VIEW (data));
6783
6784   return FALSE;
6785 }
6786
6787 static void
6788 install_presize_handler (GtkTreeView *tree_view)
6789 {
6790   if (! gtk_widget_get_realized (GTK_WIDGET (tree_view)))
6791     return;
6792
6793   if (! tree_view->priv->presize_handler_timer)
6794     {
6795       tree_view->priv->presize_handler_timer =
6796         gdk_threads_add_idle_full (GTK_PRIORITY_RESIZE - 2, presize_handler_callback, tree_view, NULL);
6797     }
6798   if (! tree_view->priv->validate_rows_timer)
6799     {
6800       tree_view->priv->validate_rows_timer =
6801         gdk_threads_add_idle_full (GTK_TREE_VIEW_PRIORITY_VALIDATE, (GSourceFunc) validate_rows_handler, tree_view, NULL);
6802     }
6803 }
6804
6805 static void
6806 gtk_tree_view_bin_process_updates (GtkTreeView *tree_view)
6807 {
6808   /* Prior to drawing, we make sure the visible area is validated. */
6809   if (tree_view->priv->presize_handler_timer)
6810     {
6811       g_source_remove (tree_view->priv->presize_handler_timer);
6812       tree_view->priv->presize_handler_timer = 0;
6813
6814       do_presize_handler (tree_view);
6815     }
6816
6817   gdk_window_process_updates (tree_view->priv->bin_window, TRUE);
6818 }
6819
6820 static gboolean
6821 scroll_sync_handler (GtkTreeView *tree_view)
6822 {
6823   if (tree_view->priv->height <= gtk_adjustment_get_page_size (tree_view->priv->vadjustment))
6824     gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment), 0);
6825   else if (gtk_tree_row_reference_valid (tree_view->priv->top_row))
6826     gtk_tree_view_top_row_to_dy (tree_view);
6827   else
6828     gtk_tree_view_dy_to_top_row (tree_view);
6829
6830   tree_view->priv->scroll_sync_timer = 0;
6831
6832   return FALSE;
6833 }
6834
6835 static void
6836 install_scroll_sync_handler (GtkTreeView *tree_view)
6837 {
6838   if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
6839     return;
6840
6841   if (!tree_view->priv->scroll_sync_timer)
6842     {
6843       tree_view->priv->scroll_sync_timer =
6844         gdk_threads_add_idle_full (GTK_TREE_VIEW_PRIORITY_SCROLL_SYNC, (GSourceFunc) scroll_sync_handler, tree_view, NULL);
6845     }
6846 }
6847
6848 static void
6849 gtk_tree_view_set_top_row (GtkTreeView *tree_view,
6850                            GtkTreePath *path,
6851                            gint         offset)
6852 {
6853   gtk_tree_row_reference_free (tree_view->priv->top_row);
6854
6855   if (!path)
6856     {
6857       tree_view->priv->top_row = NULL;
6858       tree_view->priv->top_row_dy = 0;
6859     }
6860   else
6861     {
6862       tree_view->priv->top_row = gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view), tree_view->priv->model, path);
6863       tree_view->priv->top_row_dy = offset;
6864     }
6865 }
6866
6867 /* Always call this iff dy is in the visible range.  If the tree is empty, then
6868  * it's set to be NULL, and top_row_dy is 0;
6869  */
6870 static void
6871 gtk_tree_view_dy_to_top_row (GtkTreeView *tree_view)
6872 {
6873   gint offset;
6874   GtkTreePath *path;
6875   GtkRBTree *tree;
6876   GtkRBNode *node;
6877
6878   if (tree_view->priv->tree == NULL)
6879     {
6880       gtk_tree_view_set_top_row (tree_view, NULL, 0);
6881     }
6882   else
6883     {
6884       offset = _gtk_rbtree_find_offset (tree_view->priv->tree,
6885                                         tree_view->priv->dy,
6886                                         &tree, &node);
6887
6888       if (tree == NULL)
6889         {
6890           gtk_tree_view_set_top_row (tree_view, NULL, 0);
6891         }
6892       else
6893         {
6894           path = _gtk_tree_view_find_path (tree_view, tree, node);
6895           gtk_tree_view_set_top_row (tree_view, path, offset);
6896           gtk_tree_path_free (path);
6897         }
6898     }
6899 }
6900
6901 static void
6902 gtk_tree_view_top_row_to_dy (GtkTreeView *tree_view)
6903 {
6904   GtkTreePath *path;
6905   GtkRBTree *tree;
6906   GtkRBNode *node;
6907   int new_dy;
6908
6909   /* Avoid recursive calls */
6910   if (tree_view->priv->in_top_row_to_dy)
6911     return;
6912
6913   if (tree_view->priv->top_row)
6914     path = gtk_tree_row_reference_get_path (tree_view->priv->top_row);
6915   else
6916     path = NULL;
6917
6918   if (!path)
6919     tree = NULL;
6920   else
6921     _gtk_tree_view_find_node (tree_view, path, &tree, &node);
6922
6923   if (path)
6924     gtk_tree_path_free (path);
6925
6926   if (tree == NULL)
6927     {
6928       /* keep dy and set new toprow */
6929       gtk_tree_row_reference_free (tree_view->priv->top_row);
6930       tree_view->priv->top_row = NULL;
6931       tree_view->priv->top_row_dy = 0;
6932       /* DO NOT install the idle handler */
6933       gtk_tree_view_dy_to_top_row (tree_view);
6934       return;
6935     }
6936
6937   if (gtk_tree_view_get_row_height (tree_view, node)
6938       < tree_view->priv->top_row_dy)
6939     {
6940       /* new top row -- do NOT install the idle handler */
6941       gtk_tree_view_dy_to_top_row (tree_view);
6942       return;
6943     }
6944
6945   new_dy = _gtk_rbtree_node_find_offset (tree, node);
6946   new_dy += tree_view->priv->top_row_dy;
6947
6948   if (new_dy + gtk_adjustment_get_page_size (tree_view->priv->vadjustment) > tree_view->priv->height)
6949     new_dy = tree_view->priv->height - gtk_adjustment_get_page_size (tree_view->priv->vadjustment);
6950
6951   new_dy = MAX (0, new_dy);
6952
6953   tree_view->priv->in_top_row_to_dy = TRUE;
6954   gtk_adjustment_set_value (tree_view->priv->vadjustment, (gdouble)new_dy);
6955   tree_view->priv->in_top_row_to_dy = FALSE;
6956 }
6957
6958
6959 void
6960 _gtk_tree_view_install_mark_rows_col_dirty (GtkTreeView *tree_view,
6961                                             gboolean     install_handler)
6962 {
6963   tree_view->priv->mark_rows_col_dirty = TRUE;
6964
6965   if (install_handler)
6966     install_presize_handler (tree_view);
6967 }
6968
6969 /*
6970  * This function works synchronously (due to the while (validate_rows...)
6971  * loop).
6972  *
6973  * There was a check for column_type != GTK_TREE_VIEW_COLUMN_AUTOSIZE
6974  * here. You now need to check that yourself.
6975  */
6976 void
6977 _gtk_tree_view_column_autosize (GtkTreeView *tree_view,
6978                                 GtkTreeViewColumn *column)
6979 {
6980   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
6981   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (column));
6982
6983   _gtk_tree_view_column_cell_set_dirty (column, FALSE);
6984
6985   do_presize_handler (tree_view);
6986   while (validate_rows (tree_view));
6987
6988   gtk_widget_queue_resize (GTK_WIDGET (tree_view));
6989 }
6990
6991 /* Drag-and-drop */
6992
6993 static void
6994 set_source_row (GdkDragContext *context,
6995                 GtkTreeModel   *model,
6996                 GtkTreePath    *source_row)
6997 {
6998   g_object_set_data_full (G_OBJECT (context),
6999                           I_("gtk-tree-view-source-row"),
7000                           source_row ? gtk_tree_row_reference_new (model, source_row) : NULL,
7001                           (GDestroyNotify) (source_row ? gtk_tree_row_reference_free : NULL));
7002 }
7003
7004 static GtkTreePath*
7005 get_source_row (GdkDragContext *context)
7006 {
7007   GtkTreeRowReference *ref =
7008     g_object_get_data (G_OBJECT (context), "gtk-tree-view-source-row");
7009
7010   if (ref)
7011     return gtk_tree_row_reference_get_path (ref);
7012   else
7013     return NULL;
7014 }
7015
7016 typedef struct
7017 {
7018   GtkTreeRowReference *dest_row;
7019   guint                path_down_mode   : 1;
7020   guint                empty_view_drop  : 1;
7021   guint                drop_append_mode : 1;
7022 }
7023 DestRow;
7024
7025 static void
7026 dest_row_free (gpointer data)
7027 {
7028   DestRow *dr = (DestRow *)data;
7029
7030   gtk_tree_row_reference_free (dr->dest_row);
7031   g_slice_free (DestRow, dr);
7032 }
7033
7034 static void
7035 set_dest_row (GdkDragContext *context,
7036               GtkTreeModel   *model,
7037               GtkTreePath    *dest_row,
7038               gboolean        path_down_mode,
7039               gboolean        empty_view_drop,
7040               gboolean        drop_append_mode)
7041 {
7042   DestRow *dr;
7043
7044   if (!dest_row)
7045     {
7046       g_object_set_data_full (G_OBJECT (context), I_("gtk-tree-view-dest-row"),
7047                               NULL, NULL);
7048       return;
7049     }
7050
7051   dr = g_slice_new (DestRow);
7052
7053   dr->dest_row = gtk_tree_row_reference_new (model, dest_row);
7054   dr->path_down_mode = path_down_mode != FALSE;
7055   dr->empty_view_drop = empty_view_drop != FALSE;
7056   dr->drop_append_mode = drop_append_mode != FALSE;
7057
7058   g_object_set_data_full (G_OBJECT (context), I_("gtk-tree-view-dest-row"),
7059                           dr, (GDestroyNotify) dest_row_free);
7060 }
7061
7062 static GtkTreePath*
7063 get_dest_row (GdkDragContext *context,
7064               gboolean       *path_down_mode)
7065 {
7066   DestRow *dr =
7067     g_object_get_data (G_OBJECT (context), "gtk-tree-view-dest-row");
7068
7069   if (dr)
7070     {
7071       GtkTreePath *path = NULL;
7072
7073       if (path_down_mode)
7074         *path_down_mode = dr->path_down_mode;
7075
7076       if (dr->dest_row)
7077         path = gtk_tree_row_reference_get_path (dr->dest_row);
7078       else if (dr->empty_view_drop)
7079         path = gtk_tree_path_new_from_indices (0, -1);
7080       else
7081         path = NULL;
7082
7083       if (path && dr->drop_append_mode)
7084         gtk_tree_path_next (path);
7085
7086       return path;
7087     }
7088   else
7089     return NULL;
7090 }
7091
7092 /* Get/set whether drag_motion requested the drag data and
7093  * drag_data_received should thus not actually insert the data,
7094  * since the data doesn't result from a drop.
7095  */
7096 static void
7097 set_status_pending (GdkDragContext *context,
7098                     GdkDragAction   suggested_action)
7099 {
7100   g_object_set_data (G_OBJECT (context),
7101                      I_("gtk-tree-view-status-pending"),
7102                      GINT_TO_POINTER (suggested_action));
7103 }
7104
7105 static GdkDragAction
7106 get_status_pending (GdkDragContext *context)
7107 {
7108   return GPOINTER_TO_INT (g_object_get_data (G_OBJECT (context),
7109                                              "gtk-tree-view-status-pending"));
7110 }
7111
7112 static TreeViewDragInfo*
7113 get_info (GtkTreeView *tree_view)
7114 {
7115   return g_object_get_data (G_OBJECT (tree_view), "gtk-tree-view-drag-info");
7116 }
7117
7118 static void
7119 destroy_info (TreeViewDragInfo *di)
7120 {
7121   g_slice_free (TreeViewDragInfo, di);
7122 }
7123
7124 static TreeViewDragInfo*
7125 ensure_info (GtkTreeView *tree_view)
7126 {
7127   TreeViewDragInfo *di;
7128
7129   di = get_info (tree_view);
7130
7131   if (di == NULL)
7132     {
7133       di = g_slice_new0 (TreeViewDragInfo);
7134
7135       g_object_set_data_full (G_OBJECT (tree_view),
7136                               I_("gtk-tree-view-drag-info"),
7137                               di,
7138                               (GDestroyNotify) destroy_info);
7139     }
7140
7141   return di;
7142 }
7143
7144 static void
7145 remove_info (GtkTreeView *tree_view)
7146 {
7147   g_object_set_data (G_OBJECT (tree_view), I_("gtk-tree-view-drag-info"), NULL);
7148 }
7149
7150 #if 0
7151 static gint
7152 drag_scan_timeout (gpointer data)
7153 {
7154   GtkTreeView *tree_view;
7155   gint x, y;
7156   GdkModifierType state;
7157   GtkTreePath *path = NULL;
7158   GtkTreeViewColumn *column = NULL;
7159   GdkRectangle visible_rect;
7160
7161   GDK_THREADS_ENTER ();
7162
7163   tree_view = GTK_TREE_VIEW (data);
7164
7165   gdk_window_get_pointer (tree_view->priv->bin_window,
7166                           &x, &y, &state);
7167
7168   gtk_tree_view_get_visible_rect (tree_view, &visible_rect);
7169
7170   /* See if we are near the edge. */
7171   if ((x - visible_rect.x) < SCROLL_EDGE_SIZE ||
7172       (visible_rect.x + visible_rect.width - x) < SCROLL_EDGE_SIZE ||
7173       (y - visible_rect.y) < SCROLL_EDGE_SIZE ||
7174       (visible_rect.y + visible_rect.height - y) < SCROLL_EDGE_SIZE)
7175     {
7176       gtk_tree_view_get_path_at_pos (tree_view,
7177                                      tree_view->priv->bin_window,
7178                                      x, y,
7179                                      &path,
7180                                      &column,
7181                                      NULL,
7182                                      NULL);
7183
7184       if (path != NULL)
7185         {
7186           gtk_tree_view_scroll_to_cell (tree_view,
7187                                         path,
7188                                         column,
7189                                         TRUE,
7190                                         0.5, 0.5);
7191
7192           gtk_tree_path_free (path);
7193         }
7194     }
7195
7196   GDK_THREADS_LEAVE ();
7197
7198   return TRUE;
7199 }
7200 #endif /* 0 */
7201
7202 static void
7203 add_scroll_timeout (GtkTreeView *tree_view)
7204 {
7205   if (tree_view->priv->scroll_timeout == 0)
7206     {
7207       tree_view->priv->scroll_timeout =
7208         gdk_threads_add_timeout (150, scroll_row_timeout, tree_view);
7209     }
7210 }
7211
7212 static void
7213 remove_scroll_timeout (GtkTreeView *tree_view)
7214 {
7215   if (tree_view->priv->scroll_timeout != 0)
7216     {
7217       g_source_remove (tree_view->priv->scroll_timeout);
7218       tree_view->priv->scroll_timeout = 0;
7219     }
7220 }
7221
7222 static gboolean
7223 check_model_dnd (GtkTreeModel *model,
7224                  GType         required_iface,
7225                  const gchar  *signal)
7226 {
7227   if (model == NULL || !G_TYPE_CHECK_INSTANCE_TYPE ((model), required_iface))
7228     {
7229       g_warning ("You must override the default '%s' handler "
7230                  "on GtkTreeView when using models that don't support "
7231                  "the %s interface and enabling drag-and-drop. The simplest way to do this "
7232                  "is to connect to '%s' and call "
7233                  "g_signal_stop_emission_by_name() in your signal handler to prevent "
7234                  "the default handler from running. Look at the source code "
7235                  "for the default handler in gtktreeview.c to get an idea what "
7236                  "your handler should do. (gtktreeview.c is in the GTK source "
7237                  "code.) If you're using GTK from a language other than C, "
7238                  "there may be a more natural way to override default handlers, e.g. via derivation.",
7239                  signal, g_type_name (required_iface), signal);
7240       return FALSE;
7241     }
7242   else
7243     return TRUE;
7244 }
7245
7246 static void
7247 remove_open_timeout (GtkTreeView *tree_view)
7248 {
7249   if (tree_view->priv->open_dest_timeout != 0)
7250     {
7251       g_source_remove (tree_view->priv->open_dest_timeout);
7252       tree_view->priv->open_dest_timeout = 0;
7253     }
7254 }
7255
7256
7257 static gint
7258 open_row_timeout (gpointer data)
7259 {
7260   GtkTreeView *tree_view = data;
7261   GtkTreePath *dest_path = NULL;
7262   GtkTreeViewDropPosition pos;
7263   gboolean result = FALSE;
7264
7265   gtk_tree_view_get_drag_dest_row (tree_view,
7266                                    &dest_path,
7267                                    &pos);
7268
7269   if (dest_path &&
7270       (pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER ||
7271        pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE))
7272     {
7273       gtk_tree_view_expand_row (tree_view, dest_path, FALSE);
7274       tree_view->priv->open_dest_timeout = 0;
7275
7276       gtk_tree_path_free (dest_path);
7277     }
7278   else
7279     {
7280       if (dest_path)
7281         gtk_tree_path_free (dest_path);
7282
7283       result = TRUE;
7284     }
7285
7286   return result;
7287 }
7288
7289 static gboolean
7290 scroll_row_timeout (gpointer data)
7291 {
7292   GtkTreeView *tree_view = data;
7293
7294   gtk_tree_view_vertical_autoscroll (tree_view);
7295
7296   if (tree_view->priv->rubber_band_status == RUBBER_BAND_ACTIVE)
7297     gtk_tree_view_update_rubber_band (tree_view);
7298
7299   return TRUE;
7300 }
7301
7302 /* Returns TRUE if event should not be propagated to parent widgets */
7303 static gboolean
7304 set_destination_row (GtkTreeView    *tree_view,
7305                      GdkDragContext *context,
7306                      /* coordinates relative to the widget */
7307                      gint            x,
7308                      gint            y,
7309                      GdkDragAction  *suggested_action,
7310                      GdkAtom        *target)
7311 {
7312   GtkTreePath *path = NULL;
7313   GtkTreeViewDropPosition pos;
7314   GtkTreeViewDropPosition old_pos;
7315   TreeViewDragInfo *di;
7316   GtkWidget *widget;
7317   GtkTreePath *old_dest_path = NULL;
7318   gboolean can_drop = FALSE;
7319
7320   *suggested_action = 0;
7321   *target = GDK_NONE;
7322
7323   widget = GTK_WIDGET (tree_view);
7324
7325   di = get_info (tree_view);
7326
7327   if (di == NULL || y - gtk_tree_view_get_effective_header_height (tree_view) < 0)
7328     {
7329       /* someone unset us as a drag dest, note that if
7330        * we return FALSE drag_leave isn't called
7331        */
7332
7333       gtk_tree_view_set_drag_dest_row (tree_view,
7334                                        NULL,
7335                                        GTK_TREE_VIEW_DROP_BEFORE);
7336
7337       remove_scroll_timeout (GTK_TREE_VIEW (widget));
7338       remove_open_timeout (GTK_TREE_VIEW (widget));
7339
7340       return FALSE; /* no longer a drop site */
7341     }
7342
7343   *target = gtk_drag_dest_find_target (widget, context,
7344                                        gtk_drag_dest_get_target_list (widget));
7345   if (*target == GDK_NONE)
7346     {
7347       return FALSE;
7348     }
7349
7350   if (!gtk_tree_view_get_dest_row_at_pos (tree_view,
7351                                           x, y,
7352                                           &path,
7353                                           &pos))
7354     {
7355       gint n_children;
7356       GtkTreeModel *model;
7357
7358       remove_open_timeout (tree_view);
7359
7360       /* the row got dropped on empty space, let's setup a special case
7361        */
7362
7363       if (path)
7364         gtk_tree_path_free (path);
7365
7366       model = gtk_tree_view_get_model (tree_view);
7367
7368       n_children = gtk_tree_model_iter_n_children (model, NULL);
7369       if (n_children)
7370         {
7371           pos = GTK_TREE_VIEW_DROP_AFTER;
7372           path = gtk_tree_path_new_from_indices (n_children - 1, -1);
7373         }
7374       else
7375         {
7376           pos = GTK_TREE_VIEW_DROP_BEFORE;
7377           path = gtk_tree_path_new_from_indices (0, -1);
7378         }
7379
7380       can_drop = TRUE;
7381
7382       goto out;
7383     }
7384
7385   g_assert (path);
7386
7387   /* If we left the current row's "open" zone, unset the timeout for
7388    * opening the row
7389    */
7390   gtk_tree_view_get_drag_dest_row (tree_view,
7391                                    &old_dest_path,
7392                                    &old_pos);
7393
7394   if (old_dest_path &&
7395       (gtk_tree_path_compare (path, old_dest_path) != 0 ||
7396        !(pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER ||
7397          pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE)))
7398     remove_open_timeout (tree_view);
7399
7400   if (old_dest_path)
7401     gtk_tree_path_free (old_dest_path);
7402
7403   if (TRUE /* FIXME if the location droppable predicate */)
7404     {
7405       can_drop = TRUE;
7406     }
7407
7408 out:
7409   if (can_drop)
7410     {
7411       GtkWidget *source_widget;
7412
7413       *suggested_action = gdk_drag_context_get_suggested_action (context);
7414       source_widget = gtk_drag_get_source_widget (context);
7415
7416       if (source_widget == widget)
7417         {
7418           /* Default to MOVE, unless the user has
7419            * pressed ctrl or shift to affect available actions
7420            */
7421           if ((gdk_drag_context_get_actions (context) & GDK_ACTION_MOVE) != 0)
7422             *suggested_action = GDK_ACTION_MOVE;
7423         }
7424
7425       gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
7426                                        path, pos);
7427     }
7428   else
7429     {
7430       /* can't drop here */
7431       remove_open_timeout (tree_view);
7432
7433       gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
7434                                        NULL,
7435                                        GTK_TREE_VIEW_DROP_BEFORE);
7436     }
7437
7438   if (path)
7439     gtk_tree_path_free (path);
7440
7441   return TRUE;
7442 }
7443
7444 static GtkTreePath*
7445 get_logical_dest_row (GtkTreeView *tree_view,
7446                       gboolean    *path_down_mode,
7447                       gboolean    *drop_append_mode)
7448 {
7449   /* adjust path to point to the row the drop goes in front of */
7450   GtkTreePath *path = NULL;
7451   GtkTreeViewDropPosition pos;
7452
7453   g_return_val_if_fail (path_down_mode != NULL, NULL);
7454   g_return_val_if_fail (drop_append_mode != NULL, NULL);
7455
7456   *path_down_mode = FALSE;
7457   *drop_append_mode = 0;
7458
7459   gtk_tree_view_get_drag_dest_row (tree_view, &path, &pos);
7460
7461   if (path == NULL)
7462     return NULL;
7463
7464   if (pos == GTK_TREE_VIEW_DROP_BEFORE)
7465     ; /* do nothing */
7466   else if (pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE ||
7467            pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER)
7468     *path_down_mode = TRUE;
7469   else
7470     {
7471       GtkTreeIter iter;
7472       GtkTreeModel *model = gtk_tree_view_get_model (tree_view);
7473
7474       g_assert (pos == GTK_TREE_VIEW_DROP_AFTER);
7475
7476       if (!gtk_tree_model_get_iter (model, &iter, path) ||
7477           !gtk_tree_model_iter_next (model, &iter))
7478         *drop_append_mode = 1;
7479       else
7480         {
7481           *drop_append_mode = 0;
7482           gtk_tree_path_next (path);
7483         }
7484     }
7485
7486   return path;
7487 }
7488
7489 static gboolean
7490 gtk_tree_view_maybe_begin_dragging_row (GtkTreeView      *tree_view,
7491                                         GdkEventMotion   *event)
7492 {
7493   GtkWidget *widget = GTK_WIDGET (tree_view);
7494   GdkDragContext *context;
7495   TreeViewDragInfo *di;
7496   GtkTreePath *path = NULL;
7497   gint button;
7498   gint cell_x, cell_y;
7499   GtkTreeModel *model;
7500   gboolean retval = FALSE;
7501
7502   di = get_info (tree_view);
7503
7504   if (di == NULL || !di->source_set)
7505     goto out;
7506
7507   if (tree_view->priv->pressed_button < 0)
7508     goto out;
7509
7510   if (!gtk_drag_check_threshold (widget,
7511                                  tree_view->priv->press_start_x,
7512                                  tree_view->priv->press_start_y,
7513                                  event->x, event->y))
7514     goto out;
7515
7516   model = gtk_tree_view_get_model (tree_view);
7517
7518   if (model == NULL)
7519     goto out;
7520
7521   button = tree_view->priv->pressed_button;
7522   tree_view->priv->pressed_button = -1;
7523
7524   gtk_tree_view_get_path_at_pos (tree_view,
7525                                  tree_view->priv->press_start_x,
7526                                  tree_view->priv->press_start_y,
7527                                  &path,
7528                                  NULL,
7529                                  &cell_x,
7530                                  &cell_y);
7531
7532   if (path == NULL)
7533     goto out;
7534
7535   if (!GTK_IS_TREE_DRAG_SOURCE (model) ||
7536       !gtk_tree_drag_source_row_draggable (GTK_TREE_DRAG_SOURCE (model),
7537                                            path))
7538     goto out;
7539
7540   if (!(GDK_BUTTON1_MASK << (button - 1) & di->start_button_mask))
7541     goto out;
7542
7543   /* Now we can begin the drag */
7544
7545   retval = TRUE;
7546
7547   context = gtk_drag_begin (widget,
7548                             gtk_drag_source_get_target_list (widget),
7549                             di->source_actions,
7550                             button,
7551                             (GdkEvent*)event);
7552
7553   set_source_row (context, model, path);
7554
7555  out:
7556   if (path)
7557     gtk_tree_path_free (path);
7558
7559   return retval;
7560 }
7561
7562
7563 static void
7564 gtk_tree_view_drag_begin (GtkWidget      *widget,
7565                           GdkDragContext *context)
7566 {
7567   GtkTreeView *tree_view;
7568   GtkTreePath *path = NULL;
7569   gint cell_x, cell_y;
7570   cairo_surface_t *row_pix;
7571   TreeViewDragInfo *di;
7572
7573   tree_view = GTK_TREE_VIEW (widget);
7574
7575   /* if the user uses a custom DND source impl, we don't set the icon here */
7576   di = get_info (tree_view);
7577
7578   if (di == NULL || !di->source_set)
7579     return;
7580
7581   gtk_tree_view_get_path_at_pos (tree_view,
7582                                  tree_view->priv->press_start_x,
7583                                  tree_view->priv->press_start_y,
7584                                  &path,
7585                                  NULL,
7586                                  &cell_x,
7587                                  &cell_y);
7588
7589   g_return_if_fail (path != NULL);
7590
7591   row_pix = gtk_tree_view_create_row_drag_icon (tree_view,
7592                                                 path);
7593   cairo_surface_set_device_offset (row_pix,
7594                                    /* the + 1 is for the black border in the icon */
7595                                    - (tree_view->priv->press_start_x + 1),
7596                                    - (cell_y + 1));
7597
7598   gtk_drag_set_icon_surface (context, row_pix);
7599
7600   cairo_surface_destroy (row_pix);
7601   gtk_tree_path_free (path);
7602 }
7603
7604 static void
7605 gtk_tree_view_drag_end (GtkWidget      *widget,
7606                         GdkDragContext *context)
7607 {
7608   /* do nothing */
7609 }
7610
7611 /* Default signal implementations for the drag signals */
7612 static void
7613 gtk_tree_view_drag_data_get (GtkWidget        *widget,
7614                              GdkDragContext   *context,
7615                              GtkSelectionData *selection_data,
7616                              guint             info,
7617                              guint             time)
7618 {
7619   GtkTreeView *tree_view;
7620   GtkTreeModel *model;
7621   TreeViewDragInfo *di;
7622   GtkTreePath *source_row;
7623
7624   tree_view = GTK_TREE_VIEW (widget);
7625
7626   model = gtk_tree_view_get_model (tree_view);
7627
7628   if (model == NULL)
7629     return;
7630
7631   di = get_info (GTK_TREE_VIEW (widget));
7632
7633   if (di == NULL)
7634     return;
7635
7636   source_row = get_source_row (context);
7637
7638   if (source_row == NULL)
7639     return;
7640
7641   /* We can implement the GTK_TREE_MODEL_ROW target generically for
7642    * any model; for DragSource models there are some other targets
7643    * we also support.
7644    */
7645
7646   if (GTK_IS_TREE_DRAG_SOURCE (model) &&
7647       gtk_tree_drag_source_drag_data_get (GTK_TREE_DRAG_SOURCE (model),
7648                                           source_row,
7649                                           selection_data))
7650     goto done;
7651
7652   /* If drag_data_get does nothing, try providing row data. */
7653   if (gtk_selection_data_get_target (selection_data) == gdk_atom_intern_static_string ("GTK_TREE_MODEL_ROW"))
7654     {
7655       gtk_tree_set_row_drag_data (selection_data,
7656                                   model,
7657                                   source_row);
7658     }
7659
7660  done:
7661   gtk_tree_path_free (source_row);
7662 }
7663
7664
7665 static void
7666 gtk_tree_view_drag_data_delete (GtkWidget      *widget,
7667                                 GdkDragContext *context)
7668 {
7669   TreeViewDragInfo *di;
7670   GtkTreeModel *model;
7671   GtkTreeView *tree_view;
7672   GtkTreePath *source_row;
7673
7674   tree_view = GTK_TREE_VIEW (widget);
7675   model = gtk_tree_view_get_model (tree_view);
7676
7677   if (!check_model_dnd (model, GTK_TYPE_TREE_DRAG_SOURCE, "drag_data_delete"))
7678     return;
7679
7680   di = get_info (tree_view);
7681
7682   if (di == NULL)
7683     return;
7684
7685   source_row = get_source_row (context);
7686
7687   if (source_row == NULL)
7688     return;
7689
7690   gtk_tree_drag_source_drag_data_delete (GTK_TREE_DRAG_SOURCE (model),
7691                                          source_row);
7692
7693   gtk_tree_path_free (source_row);
7694
7695   set_source_row (context, NULL, NULL);
7696 }
7697
7698 static void
7699 gtk_tree_view_drag_leave (GtkWidget      *widget,
7700                           GdkDragContext *context,
7701                           guint             time)
7702 {
7703   /* unset any highlight row */
7704   gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
7705                                    NULL,
7706                                    GTK_TREE_VIEW_DROP_BEFORE);
7707
7708   remove_scroll_timeout (GTK_TREE_VIEW (widget));
7709   remove_open_timeout (GTK_TREE_VIEW (widget));
7710 }
7711
7712
7713 static gboolean
7714 gtk_tree_view_drag_motion (GtkWidget        *widget,
7715                            GdkDragContext   *context,
7716                            /* coordinates relative to the widget */
7717                            gint              x,
7718                            gint              y,
7719                            guint             time)
7720 {
7721   gboolean empty;
7722   GtkTreePath *path = NULL;
7723   GtkTreeViewDropPosition pos;
7724   GtkTreeView *tree_view;
7725   GdkDragAction suggested_action = 0;
7726   GdkAtom target;
7727
7728   tree_view = GTK_TREE_VIEW (widget);
7729
7730   if (!set_destination_row (tree_view, context, x, y, &suggested_action, &target))
7731     return FALSE;
7732
7733   gtk_tree_view_get_drag_dest_row (tree_view, &path, &pos);
7734
7735   /* we only know this *after* set_desination_row */
7736   empty = tree_view->priv->empty_view_drop;
7737
7738   if (path == NULL && !empty)
7739     {
7740       /* Can't drop here. */
7741       gdk_drag_status (context, 0, time);
7742     }
7743   else
7744     {
7745       if (tree_view->priv->open_dest_timeout == 0 &&
7746           (pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER ||
7747            pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE))
7748         {
7749           tree_view->priv->open_dest_timeout =
7750             gdk_threads_add_timeout (AUTO_EXPAND_TIMEOUT, open_row_timeout, tree_view);
7751         }
7752       else
7753         {
7754           add_scroll_timeout (tree_view);
7755         }
7756
7757       if (target == gdk_atom_intern_static_string ("GTK_TREE_MODEL_ROW"))
7758         {
7759           /* Request data so we can use the source row when
7760            * determining whether to accept the drop
7761            */
7762           set_status_pending (context, suggested_action);
7763           gtk_drag_get_data (widget, context, target, time);
7764         }
7765       else
7766         {
7767           set_status_pending (context, 0);
7768           gdk_drag_status (context, suggested_action, time);
7769         }
7770     }
7771
7772   if (path)
7773     gtk_tree_path_free (path);
7774
7775   return TRUE;
7776 }
7777
7778
7779 static gboolean
7780 gtk_tree_view_drag_drop (GtkWidget        *widget,
7781                          GdkDragContext   *context,
7782                          /* coordinates relative to the widget */
7783                          gint              x,
7784                          gint              y,
7785                          guint             time)
7786 {
7787   GtkTreeView *tree_view;
7788   GtkTreePath *path;
7789   GdkDragAction suggested_action = 0;
7790   GdkAtom target = GDK_NONE;
7791   TreeViewDragInfo *di;
7792   GtkTreeModel *model;
7793   gboolean path_down_mode;
7794   gboolean drop_append_mode;
7795
7796   tree_view = GTK_TREE_VIEW (widget);
7797
7798   model = gtk_tree_view_get_model (tree_view);
7799
7800   remove_scroll_timeout (GTK_TREE_VIEW (widget));
7801   remove_open_timeout (GTK_TREE_VIEW (widget));
7802
7803   di = get_info (tree_view);
7804
7805   if (di == NULL)
7806     return FALSE;
7807
7808   if (!check_model_dnd (model, GTK_TYPE_TREE_DRAG_DEST, "drag_drop"))
7809     return FALSE;
7810
7811   if (!set_destination_row (tree_view, context, x, y, &suggested_action, &target))
7812     return FALSE;
7813
7814   path = get_logical_dest_row (tree_view, &path_down_mode, &drop_append_mode);
7815
7816   if (target != GDK_NONE && path != NULL)
7817     {
7818       /* in case a motion had requested drag data, change things so we
7819        * treat drag data receives as a drop.
7820        */
7821       set_status_pending (context, 0);
7822       set_dest_row (context, model, path,
7823                     path_down_mode, tree_view->priv->empty_view_drop,
7824                     drop_append_mode);
7825     }
7826
7827   if (path)
7828     gtk_tree_path_free (path);
7829
7830   /* Unset this thing */
7831   gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
7832                                    NULL,
7833                                    GTK_TREE_VIEW_DROP_BEFORE);
7834
7835   if (target != GDK_NONE)
7836     {
7837       gtk_drag_get_data (widget, context, target, time);
7838       return TRUE;
7839     }
7840   else
7841     return FALSE;
7842 }
7843
7844 static void
7845 gtk_tree_view_drag_data_received (GtkWidget        *widget,
7846                                   GdkDragContext   *context,
7847                                   /* coordinates relative to the widget */
7848                                   gint              x,
7849                                   gint              y,
7850                                   GtkSelectionData *selection_data,
7851                                   guint             info,
7852                                   guint             time)
7853 {
7854   GtkTreePath *path;
7855   TreeViewDragInfo *di;
7856   gboolean accepted = FALSE;
7857   GtkTreeModel *model;
7858   GtkTreeView *tree_view;
7859   GtkTreePath *dest_row;
7860   GdkDragAction suggested_action;
7861   gboolean path_down_mode;
7862   gboolean drop_append_mode;
7863
7864   tree_view = GTK_TREE_VIEW (widget);
7865
7866   model = gtk_tree_view_get_model (tree_view);
7867
7868   if (!check_model_dnd (model, GTK_TYPE_TREE_DRAG_DEST, "drag_data_received"))
7869     return;
7870
7871   di = get_info (tree_view);
7872
7873   if (di == NULL)
7874     return;
7875
7876   suggested_action = get_status_pending (context);
7877
7878   if (suggested_action)
7879     {
7880       /* We are getting this data due to a request in drag_motion,
7881        * rather than due to a request in drag_drop, so we are just
7882        * supposed to call drag_status, not actually paste in the
7883        * data.
7884        */
7885       path = get_logical_dest_row (tree_view, &path_down_mode,
7886                                    &drop_append_mode);
7887
7888       if (path == NULL)
7889         suggested_action = 0;
7890       else if (path_down_mode)
7891         gtk_tree_path_down (path);
7892
7893       if (suggested_action)
7894         {
7895           if (!gtk_tree_drag_dest_row_drop_possible (GTK_TREE_DRAG_DEST (model),
7896                                                      path,
7897                                                      selection_data))
7898             {
7899               if (path_down_mode)
7900                 {
7901                   path_down_mode = FALSE;
7902                   gtk_tree_path_up (path);
7903
7904                   if (!gtk_tree_drag_dest_row_drop_possible (GTK_TREE_DRAG_DEST (model),
7905                                                              path,
7906                                                              selection_data))
7907                     suggested_action = 0;
7908                 }
7909               else
7910                 suggested_action = 0;
7911             }
7912         }
7913
7914       gdk_drag_status (context, suggested_action, time);
7915
7916       if (path)
7917         gtk_tree_path_free (path);
7918
7919       /* If you can't drop, remove user drop indicator until the next motion */
7920       if (suggested_action == 0)
7921         gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
7922                                          NULL,
7923                                          GTK_TREE_VIEW_DROP_BEFORE);
7924
7925       return;
7926     }
7927
7928   dest_row = get_dest_row (context, &path_down_mode);
7929
7930   if (dest_row == NULL)
7931     return;
7932
7933   if (gtk_selection_data_get_length (selection_data) >= 0)
7934     {
7935       if (path_down_mode)
7936         {
7937           gtk_tree_path_down (dest_row);
7938           if (!gtk_tree_drag_dest_row_drop_possible (GTK_TREE_DRAG_DEST (model),
7939                                                      dest_row, selection_data))
7940             gtk_tree_path_up (dest_row);
7941         }
7942     }
7943
7944   if (gtk_selection_data_get_length (selection_data) >= 0)
7945     {
7946       if (gtk_tree_drag_dest_drag_data_received (GTK_TREE_DRAG_DEST (model),
7947                                                  dest_row,
7948                                                  selection_data))
7949         accepted = TRUE;
7950     }
7951
7952   gtk_drag_finish (context,
7953                    accepted,
7954                    (gdk_drag_context_get_selected_action (context) == GDK_ACTION_MOVE),
7955                    time);
7956
7957   if (gtk_tree_path_get_depth (dest_row) == 1
7958       && gtk_tree_path_get_indices (dest_row)[0] == 0)
7959     {
7960       /* special special case drag to "0", scroll to first item */
7961       if (!tree_view->priv->scroll_to_path)
7962         gtk_tree_view_scroll_to_cell (tree_view, dest_row, NULL, FALSE, 0.0, 0.0);
7963     }
7964
7965   gtk_tree_path_free (dest_row);
7966
7967   /* drop dest_row */
7968   set_dest_row (context, NULL, NULL, FALSE, FALSE, FALSE);
7969 }
7970
7971
7972
7973 /* GtkContainer Methods
7974  */
7975
7976
7977 static void
7978 gtk_tree_view_remove (GtkContainer *container,
7979                       GtkWidget    *widget)
7980 {
7981   GtkTreeView *tree_view = GTK_TREE_VIEW (container);
7982   GtkTreeViewChild *child = NULL;
7983   GList *tmp_list;
7984
7985   tmp_list = tree_view->priv->children;
7986   while (tmp_list)
7987     {
7988       child = tmp_list->data;
7989       if (child->widget == widget)
7990         {
7991           gtk_widget_unparent (widget);
7992
7993           tree_view->priv->children = g_list_remove_link (tree_view->priv->children, tmp_list);
7994           g_list_free_1 (tmp_list);
7995           g_slice_free (GtkTreeViewChild, child);
7996           return;
7997         }
7998
7999       tmp_list = tmp_list->next;
8000     }
8001
8002   tmp_list = tree_view->priv->columns;
8003
8004   while (tmp_list)
8005     {
8006       GtkTreeViewColumn *column;
8007       GtkWidget         *button;
8008
8009       column = tmp_list->data;
8010       button = gtk_tree_view_column_get_button (column);
8011
8012       if (button == widget)
8013         {
8014           gtk_widget_unparent (widget);
8015           return;
8016         }
8017       tmp_list = tmp_list->next;
8018     }
8019 }
8020
8021 static void
8022 gtk_tree_view_forall (GtkContainer *container,
8023                       gboolean      include_internals,
8024                       GtkCallback   callback,
8025                       gpointer      callback_data)
8026 {
8027   GtkTreeView *tree_view = GTK_TREE_VIEW (container);
8028   GtkTreeViewChild *child = NULL;
8029   GtkTreeViewColumn *column;
8030   GtkWidget *button;
8031   GList *tmp_list;
8032
8033   tmp_list = tree_view->priv->children;
8034   while (tmp_list)
8035     {
8036       child = tmp_list->data;
8037       tmp_list = tmp_list->next;
8038
8039       (* callback) (child->widget, callback_data);
8040     }
8041   if (include_internals == FALSE)
8042     return;
8043
8044   for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list = tmp_list->next)
8045     {
8046       column = tmp_list->data;
8047       button = gtk_tree_view_column_get_button (column);
8048
8049       if (button)
8050         (* callback) (button, callback_data);
8051     }
8052 }
8053
8054 /* Returns TRUE is any of the columns contains a cell that can-focus.
8055  * If this is not the case, a column-spanning focus rectangle will be
8056  * drawn.
8057  */
8058 static gboolean
8059 gtk_tree_view_has_can_focus_cell (GtkTreeView *tree_view)
8060 {
8061   GList *list;
8062
8063   for (list = tree_view->priv->columns; list; list = list->next)
8064     {
8065       GtkTreeViewColumn *column = list->data;
8066
8067       if (!gtk_tree_view_column_get_visible (column))
8068         continue;
8069       if (gtk_cell_area_is_activatable (gtk_cell_layout_get_area (GTK_CELL_LAYOUT (column))))
8070         return TRUE;
8071     }
8072
8073   return FALSE;
8074 }
8075
8076 static void
8077 column_sizing_notify (GObject    *object,
8078                       GParamSpec *pspec,
8079                       gpointer    data)
8080 {
8081   GtkTreeViewColumn *c = GTK_TREE_VIEW_COLUMN (object);
8082
8083   if (gtk_tree_view_column_get_sizing (c) != GTK_TREE_VIEW_COLUMN_FIXED)
8084     /* disable fixed height mode */
8085     g_object_set (data, "fixed-height-mode", FALSE, NULL);
8086 }
8087
8088 /**
8089  * gtk_tree_view_set_fixed_height_mode:
8090  * @tree_view: a #GtkTreeView
8091  * @enable: %TRUE to enable fixed height mode
8092  *
8093  * Enables or disables the fixed height mode of @tree_view.
8094  * Fixed height mode speeds up #GtkTreeView by assuming that all
8095  * rows have the same height.
8096  * Only enable this option if all rows are the same height and all
8097  * columns are of type %GTK_TREE_VIEW_COLUMN_FIXED.
8098  *
8099  * Since: 2.6
8100  **/
8101 void
8102 gtk_tree_view_set_fixed_height_mode (GtkTreeView *tree_view,
8103                                      gboolean     enable)
8104 {
8105   GList *l;
8106
8107   enable = enable != FALSE;
8108
8109   if (enable == tree_view->priv->fixed_height_mode)
8110     return;
8111
8112   if (!enable)
8113     {
8114       tree_view->priv->fixed_height_mode = 0;
8115       tree_view->priv->fixed_height = -1;
8116
8117       /* force a revalidation */
8118       install_presize_handler (tree_view);
8119     }
8120   else
8121     {
8122       /* make sure all columns are of type FIXED */
8123       for (l = tree_view->priv->columns; l; l = l->next)
8124         {
8125           GtkTreeViewColumn *c = l->data;
8126
8127           g_return_if_fail (gtk_tree_view_column_get_sizing (c) == GTK_TREE_VIEW_COLUMN_FIXED);
8128         }
8129
8130       /* yes, we really have to do this is in a separate loop */
8131       for (l = tree_view->priv->columns; l; l = l->next)
8132         g_signal_connect (l->data, "notify::sizing",
8133                           G_CALLBACK (column_sizing_notify), tree_view);
8134
8135       tree_view->priv->fixed_height_mode = 1;
8136       tree_view->priv->fixed_height = -1;
8137
8138       if (tree_view->priv->tree)
8139         initialize_fixed_height_mode (tree_view);
8140     }
8141
8142   g_object_notify (G_OBJECT (tree_view), "fixed-height-mode");
8143 }
8144
8145 /**
8146  * gtk_tree_view_get_fixed_height_mode:
8147  * @tree_view: a #GtkTreeView
8148  *
8149  * Returns whether fixed height mode is turned on for @tree_view.
8150  *
8151  * Return value: %TRUE if @tree_view is in fixed height mode
8152  *
8153  * Since: 2.6
8154  **/
8155 gboolean
8156 gtk_tree_view_get_fixed_height_mode (GtkTreeView *tree_view)
8157 {
8158   return tree_view->priv->fixed_height_mode;
8159 }
8160
8161 /* Returns TRUE if the focus is within the headers, after the focus operation is
8162  * done
8163  */
8164 static gboolean
8165 gtk_tree_view_header_focus (GtkTreeView      *tree_view,
8166                             GtkDirectionType  dir,
8167                             gboolean          clamp_column_visible)
8168 {
8169   GtkTreeViewColumn *column;
8170   GtkWidget *focus_child;
8171   GtkWidget *button;
8172   GList *last_column, *first_column;
8173   GList *tmp_list;
8174   gboolean rtl;
8175
8176   if (! tree_view->priv->headers_visible)
8177     return FALSE;
8178
8179   focus_child = gtk_container_get_focus_child (GTK_CONTAINER (tree_view));
8180
8181   first_column = tree_view->priv->columns;
8182   while (first_column)
8183     {
8184       column = GTK_TREE_VIEW_COLUMN (first_column->data);
8185       button = gtk_tree_view_column_get_button (column);
8186
8187       if (gtk_widget_get_can_focus (button) &&
8188           gtk_tree_view_column_get_visible (column) &&
8189           (gtk_tree_view_column_get_clickable (column) ||
8190            gtk_tree_view_column_get_reorderable (column)))
8191         break;
8192       first_column = first_column->next;
8193     }
8194
8195   /* No headers are visible, or are focusable.  We can't focus in or out.
8196    */
8197   if (first_column == NULL)
8198     return FALSE;
8199
8200   last_column = g_list_last (tree_view->priv->columns);
8201   while (last_column)
8202     {
8203       column = GTK_TREE_VIEW_COLUMN (last_column->data);
8204       button = gtk_tree_view_column_get_button (column);
8205
8206       if (gtk_widget_get_can_focus (button) &&
8207           gtk_tree_view_column_get_visible (column) &&
8208           (gtk_tree_view_column_get_clickable (column) ||
8209            gtk_tree_view_column_get_reorderable (column)))
8210         break;
8211       last_column = last_column->prev;
8212     }
8213
8214
8215   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
8216
8217   switch (dir)
8218     {
8219     case GTK_DIR_TAB_BACKWARD:
8220     case GTK_DIR_TAB_FORWARD:
8221     case GTK_DIR_UP:
8222     case GTK_DIR_DOWN:
8223       if (focus_child == NULL)
8224         {
8225           if (tree_view->priv->focus_column != NULL)
8226             button = gtk_tree_view_column_get_button (tree_view->priv->focus_column);
8227           else
8228             button = NULL;
8229
8230           if (button && gtk_widget_get_can_focus (button))
8231             focus_child = button;
8232           else
8233             focus_child = gtk_tree_view_column_get_button (GTK_TREE_VIEW_COLUMN (first_column->data));
8234
8235           gtk_widget_grab_focus (focus_child);
8236           break;
8237         }
8238       return FALSE;
8239
8240     case GTK_DIR_LEFT:
8241     case GTK_DIR_RIGHT:
8242       if (focus_child == NULL)
8243         {
8244           if (tree_view->priv->focus_column != NULL)
8245             focus_child = gtk_tree_view_column_get_button (tree_view->priv->focus_column);
8246           else if (dir == GTK_DIR_LEFT)
8247             focus_child = gtk_tree_view_column_get_button (GTK_TREE_VIEW_COLUMN (last_column->data));
8248           else
8249             focus_child = gtk_tree_view_column_get_button (GTK_TREE_VIEW_COLUMN (first_column->data));
8250
8251           gtk_widget_grab_focus (focus_child);
8252           break;
8253         }
8254
8255       if (gtk_widget_child_focus (focus_child, dir))
8256         {
8257           /* The focus moves inside the button. */
8258           /* This is probably a great example of bad UI */
8259           break;
8260         }
8261
8262       /* We need to move the focus among the row of buttons. */
8263       for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list = tmp_list->next)
8264         if (gtk_tree_view_column_get_button (GTK_TREE_VIEW_COLUMN (tmp_list->data)) == focus_child)
8265           break;
8266
8267       if ((tmp_list == first_column && dir == (rtl ? GTK_DIR_RIGHT : GTK_DIR_LEFT))
8268           || (tmp_list == last_column && dir == (rtl ? GTK_DIR_LEFT : GTK_DIR_RIGHT)))
8269         {
8270           gtk_widget_error_bell (GTK_WIDGET (tree_view));
8271           break;
8272         }
8273
8274       while (tmp_list)
8275         {
8276           GtkTreeViewColumn *column;
8277           GtkWidget         *button;
8278
8279           if (dir == (rtl ? GTK_DIR_LEFT : GTK_DIR_RIGHT))
8280             tmp_list = tmp_list->next;
8281           else
8282             tmp_list = tmp_list->prev;
8283
8284           if (tmp_list == NULL)
8285             {
8286               g_warning ("Internal button not found");
8287               break;
8288             }
8289           column = tmp_list->data;
8290           button = gtk_tree_view_column_get_button (column);
8291           if (button &&
8292               gtk_tree_view_column_get_visible (column) &&
8293               gtk_widget_get_can_focus (button))
8294             {
8295               focus_child = button;
8296               gtk_widget_grab_focus (button);
8297               break;
8298             }
8299         }
8300       break;
8301     default:
8302       g_assert_not_reached ();
8303       break;
8304     }
8305
8306   /* if focus child is non-null, we assume it's been set to the current focus child
8307    */
8308   if (focus_child)
8309     {
8310       for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list = tmp_list->next)
8311         if (gtk_tree_view_column_get_button (GTK_TREE_VIEW_COLUMN (tmp_list->data)) == focus_child)
8312           {
8313             tree_view->priv->focus_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
8314             break;
8315           }
8316
8317       if (clamp_column_visible)
8318         {
8319           gtk_tree_view_clamp_column_visible (tree_view,
8320                                               tree_view->priv->focus_column,
8321                                               FALSE);
8322         }
8323     }
8324
8325   return (focus_child != NULL);
8326 }
8327
8328 /* This function returns in 'path' the first focusable path, if the given path
8329  * is already focusable, it's the returned one.
8330  */
8331 static gboolean
8332 search_first_focusable_path (GtkTreeView  *tree_view,
8333                              GtkTreePath **path,
8334                              gboolean      search_forward,
8335                              GtkRBTree   **new_tree,
8336                              GtkRBNode   **new_node)
8337 {
8338   GtkRBTree *tree = NULL;
8339   GtkRBNode *node = NULL;
8340
8341   if (!path || !*path)
8342     return FALSE;
8343
8344   _gtk_tree_view_find_node (tree_view, *path, &tree, &node);
8345
8346   if (!tree || !node)
8347     return FALSE;
8348
8349   while (node && row_is_separator (tree_view, NULL, *path))
8350     {
8351       if (search_forward)
8352         _gtk_rbtree_next_full (tree, node, &tree, &node);
8353       else
8354         _gtk_rbtree_prev_full (tree, node, &tree, &node);
8355
8356       if (*path)
8357         gtk_tree_path_free (*path);
8358
8359       if (node)
8360         *path = _gtk_tree_view_find_path (tree_view, tree, node);
8361       else
8362         *path = NULL;
8363     }
8364
8365   if (new_tree)
8366     *new_tree = tree;
8367
8368   if (new_node)
8369     *new_node = node;
8370
8371   return (*path != NULL);
8372 }
8373
8374 static gint
8375 gtk_tree_view_focus (GtkWidget        *widget,
8376                      GtkDirectionType  direction)
8377 {
8378   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
8379   GtkContainer *container = GTK_CONTAINER (widget);
8380   GtkWidget *focus_child;
8381
8382   if (!gtk_widget_is_sensitive (widget) || !gtk_widget_get_can_focus (widget))
8383     return FALSE;
8384
8385   focus_child = gtk_container_get_focus_child (container);
8386
8387   gtk_tree_view_stop_editing (GTK_TREE_VIEW (widget), FALSE);
8388   /* Case 1.  Headers currently have focus. */
8389   if (focus_child)
8390     {
8391       switch (direction)
8392         {
8393         case GTK_DIR_LEFT:
8394         case GTK_DIR_RIGHT:
8395           gtk_tree_view_header_focus (tree_view, direction, TRUE);
8396           return TRUE;
8397         case GTK_DIR_TAB_BACKWARD:
8398         case GTK_DIR_UP:
8399           return FALSE;
8400         case GTK_DIR_TAB_FORWARD:
8401         case GTK_DIR_DOWN:
8402           gtk_widget_grab_focus (widget);
8403           return TRUE;
8404         default:
8405           g_assert_not_reached ();
8406           return FALSE;
8407         }
8408     }
8409
8410   /* Case 2. We don't have focus at all. */
8411   if (!gtk_widget_has_focus (widget))
8412     {
8413       gtk_widget_grab_focus (widget);
8414       return TRUE;
8415     }
8416
8417   /* Case 3. We have focus already. */
8418   if (direction == GTK_DIR_TAB_BACKWARD)
8419     return (gtk_tree_view_header_focus (tree_view, direction, FALSE));
8420   else if (direction == GTK_DIR_TAB_FORWARD)
8421     return FALSE;
8422
8423   /* Other directions caught by the keybindings */
8424   gtk_widget_grab_focus (widget);
8425   return TRUE;
8426 }
8427
8428 static void
8429 gtk_tree_view_grab_focus (GtkWidget *widget)
8430 {
8431   GTK_WIDGET_CLASS (gtk_tree_view_parent_class)->grab_focus (widget);
8432
8433   gtk_tree_view_focus_to_cursor (GTK_TREE_VIEW (widget));
8434 }
8435
8436 static void
8437 gtk_tree_view_style_updated (GtkWidget *widget)
8438 {
8439   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
8440   GList *list;
8441   GtkTreeViewColumn *column;
8442
8443   GTK_WIDGET_CLASS (gtk_tree_view_parent_class)->style_updated (widget);
8444
8445   if (gtk_widget_get_realized (widget))
8446     {
8447       GtkStyleContext *context;
8448
8449       context = gtk_widget_get_style_context (widget);
8450
8451       gtk_style_context_save (context);
8452       gtk_style_context_add_class (context, GTK_STYLE_CLASS_VIEW);
8453       gtk_style_context_set_background (context, tree_view->priv->bin_window);
8454       gtk_style_context_restore (context);
8455
8456       gtk_style_context_set_background (context, tree_view->priv->header_window);
8457
8458       gtk_tree_view_set_grid_lines (tree_view, tree_view->priv->grid_lines);
8459       gtk_tree_view_set_enable_tree_lines (tree_view, tree_view->priv->tree_lines_enabled);
8460     }
8461
8462   gtk_widget_style_get (widget,
8463                         "expander-size", &tree_view->priv->expander_size,
8464                         NULL);
8465   tree_view->priv->expander_size += EXPANDER_EXTRA_PADDING;
8466
8467   for (list = tree_view->priv->columns; list; list = list->next)
8468     {
8469       column = list->data;
8470       _gtk_tree_view_column_cell_set_dirty (column, TRUE);
8471     }
8472
8473   tree_view->priv->fixed_height = -1;
8474   _gtk_rbtree_mark_invalid (tree_view->priv->tree);
8475
8476   gtk_widget_queue_resize (widget);
8477 }
8478
8479
8480 static void
8481 gtk_tree_view_set_focus_child (GtkContainer *container,
8482                                GtkWidget    *child)
8483 {
8484   GtkTreeView *tree_view = GTK_TREE_VIEW (container);
8485   GList *list;
8486
8487   for (list = tree_view->priv->columns; list; list = list->next)
8488     {
8489       if (gtk_tree_view_column_get_button (GTK_TREE_VIEW_COLUMN (list->data)) == child)
8490         {
8491           tree_view->priv->focus_column = GTK_TREE_VIEW_COLUMN (list->data);
8492           break;
8493         }
8494     }
8495
8496   GTK_CONTAINER_CLASS (gtk_tree_view_parent_class)->set_focus_child (container, child);
8497 }
8498
8499 static GtkWidgetPath *
8500 gtk_tree_view_get_path_for_child (GtkContainer *container,
8501                                   GtkWidget    *child)
8502 {
8503   GtkTreeView *tree_view = GTK_TREE_VIEW (container);
8504   GtkWidgetPath *path;
8505   gboolean rtl;
8506   GList *list;
8507   gint n_col = 0;
8508
8509   path = GTK_CONTAINER_CLASS (gtk_tree_view_parent_class)->get_path_for_child (container, child);
8510   rtl = (gtk_widget_get_direction (GTK_WIDGET (container)) == GTK_TEXT_DIR_RTL);
8511
8512   for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
8513        list;
8514        list = (rtl ? list->prev : list->next))
8515     {
8516       GtkTreeViewColumn *column = list->data;
8517       GtkRegionFlags flags = 0;
8518
8519       if (!gtk_tree_view_column_get_visible (column))
8520         continue;
8521
8522       n_col++;
8523
8524       if (gtk_tree_view_column_get_widget (column) != child &&
8525           gtk_tree_view_column_get_button (column) != child)
8526         continue;
8527
8528       if ((n_col % 2) == 0)
8529         flags |= GTK_REGION_EVEN;
8530       else
8531         flags |= GTK_REGION_ODD;
8532
8533       if (n_col == 1)
8534         flags |= GTK_REGION_FIRST;
8535
8536       if ((rtl && !list->prev) ||
8537           (!rtl && !list->next))
8538         flags |= GTK_REGION_LAST;
8539
8540       gtk_widget_path_iter_add_region (path, -1, GTK_STYLE_REGION_COLUMN_HEADER, flags);
8541       break;
8542     }
8543
8544   gtk_widget_path_append_for_widget (path, child);
8545
8546   return path;
8547 }
8548
8549 static gboolean
8550 gtk_tree_view_real_move_cursor (GtkTreeView       *tree_view,
8551                                 GtkMovementStep    step,
8552                                 gint               count)
8553 {
8554   GdkModifierType state;
8555
8556   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
8557   g_return_val_if_fail (step == GTK_MOVEMENT_LOGICAL_POSITIONS ||
8558                         step == GTK_MOVEMENT_VISUAL_POSITIONS ||
8559                         step == GTK_MOVEMENT_DISPLAY_LINES ||
8560                         step == GTK_MOVEMENT_PAGES ||
8561                         step == GTK_MOVEMENT_BUFFER_ENDS, FALSE);
8562
8563   if (tree_view->priv->tree == NULL)
8564     return FALSE;
8565   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
8566     return FALSE;
8567
8568   gtk_tree_view_stop_editing (tree_view, FALSE);
8569   tree_view->priv->draw_keyfocus = TRUE;
8570   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
8571
8572   if (gtk_get_current_event_state (&state))
8573     {
8574       GdkModifierType extend_mod_mask;
8575       GdkModifierType modify_mod_mask;
8576
8577       extend_mod_mask =
8578         gtk_widget_get_modifier_mask (GTK_WIDGET (tree_view),
8579                                       GDK_MODIFIER_INTENT_EXTEND_SELECTION);
8580
8581       modify_mod_mask =
8582         gtk_widget_get_modifier_mask (GTK_WIDGET (tree_view),
8583                                       GDK_MODIFIER_INTENT_MODIFY_SELECTION);
8584
8585       if ((state & modify_mod_mask) == modify_mod_mask)
8586         tree_view->priv->modify_selection_pressed = TRUE;
8587       if ((state & extend_mod_mask) == extend_mod_mask)
8588         tree_view->priv->extend_selection_pressed = TRUE;
8589     }
8590   /* else we assume not pressed */
8591
8592   switch (step)
8593     {
8594       /* currently we make no distinction.  When we go bi-di, we need to */
8595     case GTK_MOVEMENT_LOGICAL_POSITIONS:
8596     case GTK_MOVEMENT_VISUAL_POSITIONS:
8597       gtk_tree_view_move_cursor_left_right (tree_view, count);
8598       break;
8599     case GTK_MOVEMENT_DISPLAY_LINES:
8600       gtk_tree_view_move_cursor_up_down (tree_view, count);
8601       break;
8602     case GTK_MOVEMENT_PAGES:
8603       gtk_tree_view_move_cursor_page_up_down (tree_view, count);
8604       break;
8605     case GTK_MOVEMENT_BUFFER_ENDS:
8606       gtk_tree_view_move_cursor_start_end (tree_view, count);
8607       break;
8608     default:
8609       g_assert_not_reached ();
8610     }
8611
8612   tree_view->priv->modify_selection_pressed = FALSE;
8613   tree_view->priv->extend_selection_pressed = FALSE;
8614
8615   return TRUE;
8616 }
8617
8618 static void
8619 gtk_tree_view_put (GtkTreeView *tree_view,
8620                    GtkWidget   *child_widget,
8621                    /* in bin_window coordinates */
8622                    gint         x,
8623                    gint         y,
8624                    gint         width,
8625                    gint         height)
8626 {
8627   GtkTreeViewChild *child;
8628
8629   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
8630   g_return_if_fail (GTK_IS_WIDGET (child_widget));
8631
8632   child = g_slice_new (GtkTreeViewChild);
8633
8634   child->widget = child_widget;
8635   child->x = x;
8636   child->y = y;
8637   child->width = width;
8638   child->height = height;
8639
8640   tree_view->priv->children = g_list_append (tree_view->priv->children, child);
8641
8642   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
8643     gtk_widget_set_parent_window (child->widget, tree_view->priv->bin_window);
8644
8645   gtk_widget_set_parent (child_widget, GTK_WIDGET (tree_view));
8646 }
8647
8648 void
8649 _gtk_tree_view_child_move_resize (GtkTreeView *tree_view,
8650                                   GtkWidget   *widget,
8651                                   /* in tree coordinates */
8652                                   gint         x,
8653                                   gint         y,
8654                                   gint         width,
8655                                   gint         height)
8656 {
8657   GtkTreeViewChild *child = NULL;
8658   GList *list;
8659   GdkRectangle allocation;
8660
8661   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
8662   g_return_if_fail (GTK_IS_WIDGET (widget));
8663
8664   for (list = tree_view->priv->children; list; list = list->next)
8665     {
8666       if (((GtkTreeViewChild *)list->data)->widget == widget)
8667         {
8668           child = list->data;
8669           break;
8670         }
8671     }
8672   if (child == NULL)
8673     return;
8674
8675   allocation.x = child->x = x;
8676   allocation.y = child->y = y;
8677   allocation.width = child->width = width;
8678   allocation.height = child->height = height;
8679
8680   if (gtk_widget_get_realized (widget))
8681     gtk_widget_size_allocate (widget, &allocation);
8682 }
8683
8684
8685 /* TreeModel Callbacks
8686  */
8687
8688 static void
8689 gtk_tree_view_row_changed (GtkTreeModel *model,
8690                            GtkTreePath  *path,
8691                            GtkTreeIter  *iter,
8692                            gpointer      data)
8693 {
8694   GtkTreeView *tree_view = (GtkTreeView *)data;
8695   GtkRBTree *tree;
8696   GtkRBNode *node;
8697   gboolean free_path = FALSE;
8698   GList *list;
8699   GtkTreePath *cursor_path;
8700
8701   g_return_if_fail (path != NULL || iter != NULL);
8702
8703   if (tree_view->priv->cursor != NULL)
8704     cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
8705   else
8706     cursor_path = NULL;
8707
8708   if (tree_view->priv->edited_column &&
8709       (cursor_path == NULL || gtk_tree_path_compare (cursor_path, path) == 0))
8710     gtk_tree_view_stop_editing (tree_view, TRUE);
8711
8712   if (cursor_path != NULL)
8713     gtk_tree_path_free (cursor_path);
8714
8715   if (path == NULL)
8716     {
8717       path = gtk_tree_model_get_path (model, iter);
8718       free_path = TRUE;
8719     }
8720   else if (iter == NULL)
8721     gtk_tree_model_get_iter (model, iter, path);
8722
8723   if (_gtk_tree_view_find_node (tree_view,
8724                                 path,
8725                                 &tree,
8726                                 &node))
8727     /* We aren't actually showing the node */
8728     goto done;
8729
8730   if (tree == NULL)
8731     goto done;
8732
8733   if (tree_view->priv->fixed_height_mode
8734       && tree_view->priv->fixed_height >= 0)
8735     {
8736       _gtk_rbtree_node_set_height (tree, node, tree_view->priv->fixed_height);
8737       if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
8738         gtk_tree_view_node_queue_redraw (tree_view, tree, node);
8739     }
8740   else
8741     {
8742       _gtk_rbtree_node_mark_invalid (tree, node);
8743       for (list = tree_view->priv->columns; list; list = list->next)
8744         {
8745           GtkTreeViewColumn *column;
8746
8747           column = list->data;
8748           if (!gtk_tree_view_column_get_visible (column))
8749             continue;
8750
8751           if (gtk_tree_view_column_get_sizing (column) == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
8752             {
8753               _gtk_tree_view_column_cell_set_dirty (column, TRUE);
8754             }
8755         }
8756     }
8757
8758  done:
8759   if (!tree_view->priv->fixed_height_mode &&
8760       gtk_widget_get_realized (GTK_WIDGET (tree_view)))
8761     install_presize_handler (tree_view);
8762   if (free_path)
8763     gtk_tree_path_free (path);
8764 }
8765
8766 static void
8767 gtk_tree_view_row_inserted (GtkTreeModel *model,
8768                             GtkTreePath  *path,
8769                             GtkTreeIter  *iter,
8770                             gpointer      data)
8771 {
8772   GtkTreeView *tree_view = (GtkTreeView *) data;
8773   gint *indices;
8774   GtkRBTree *tmptree, *tree;
8775   GtkRBNode *tmpnode = NULL;
8776   gint depth;
8777   gint i = 0;
8778   gint height;
8779   gboolean free_path = FALSE;
8780   gboolean node_visible = TRUE;
8781
8782   g_return_if_fail (path != NULL || iter != NULL);
8783
8784   if (tree_view->priv->fixed_height_mode
8785       && tree_view->priv->fixed_height >= 0)
8786     height = tree_view->priv->fixed_height;
8787   else
8788     height = 0;
8789
8790   if (path == NULL)
8791     {
8792       path = gtk_tree_model_get_path (model, iter);
8793       free_path = TRUE;
8794     }
8795   else if (iter == NULL)
8796     gtk_tree_model_get_iter (model, iter, path);
8797
8798   if (tree_view->priv->tree == NULL)
8799     tree_view->priv->tree = _gtk_rbtree_new ();
8800
8801   tmptree = tree = tree_view->priv->tree;
8802
8803   /* Update all row-references */
8804   gtk_tree_row_reference_inserted (G_OBJECT (data), path);
8805   depth = gtk_tree_path_get_depth (path);
8806   indices = gtk_tree_path_get_indices (path);
8807
8808   /* First, find the parent tree */
8809   while (i < depth - 1)
8810     {
8811       if (tmptree == NULL)
8812         {
8813           /* We aren't showing the node */
8814           node_visible = FALSE;
8815           goto done;
8816         }
8817
8818       tmpnode = _gtk_rbtree_find_count (tmptree, indices[i] + 1);
8819       if (tmpnode == NULL)
8820         {
8821           g_warning ("A node was inserted with a parent that's not in the tree.\n" \
8822                      "This possibly means that a GtkTreeModel inserted a child node\n" \
8823                      "before the parent was inserted.");
8824           goto done;
8825         }
8826       else if (!GTK_RBNODE_FLAG_SET (tmpnode, GTK_RBNODE_IS_PARENT))
8827         {
8828           /* FIXME enforce correct behavior on model, probably */
8829           /* In theory, the model should have emitted has_child_toggled here.  We
8830            * try to catch it anyway, just to be safe, in case the model hasn't.
8831            */
8832           GtkTreePath *tmppath = _gtk_tree_view_find_path (tree_view,
8833                                                            tree,
8834                                                            tmpnode);
8835           gtk_tree_view_row_has_child_toggled (model, tmppath, NULL, data);
8836           gtk_tree_path_free (tmppath);
8837           goto done;
8838         }
8839
8840       tmptree = tmpnode->children;
8841       tree = tmptree;
8842       i++;
8843     }
8844
8845   if (tree == NULL)
8846     {
8847       node_visible = FALSE;
8848       goto done;
8849     }
8850
8851   /* ref the node */
8852   gtk_tree_model_ref_node (tree_view->priv->model, iter);
8853   if (indices[depth - 1] == 0)
8854     {
8855       tmpnode = _gtk_rbtree_find_count (tree, 1);
8856       tmpnode = _gtk_rbtree_insert_before (tree, tmpnode, height, FALSE);
8857     }
8858   else
8859     {
8860       tmpnode = _gtk_rbtree_find_count (tree, indices[depth - 1]);
8861       tmpnode = _gtk_rbtree_insert_after (tree, tmpnode, height, FALSE);
8862     }
8863
8864  done:
8865   if (height > 0)
8866     {
8867       if (tree)
8868         _gtk_rbtree_node_mark_valid (tree, tmpnode);
8869
8870       if (node_visible && node_is_visible (tree_view, tree, tmpnode))
8871         gtk_widget_queue_resize (GTK_WIDGET (tree_view));
8872       else
8873         gtk_widget_queue_resize_no_redraw (GTK_WIDGET (tree_view));
8874     }
8875   else
8876     install_presize_handler (tree_view);
8877   if (free_path)
8878     gtk_tree_path_free (path);
8879 }
8880
8881 static void
8882 gtk_tree_view_row_has_child_toggled (GtkTreeModel *model,
8883                                      GtkTreePath  *path,
8884                                      GtkTreeIter  *iter,
8885                                      gpointer      data)
8886 {
8887   GtkTreeView *tree_view = (GtkTreeView *)data;
8888   GtkTreeIter real_iter;
8889   gboolean has_child;
8890   GtkRBTree *tree;
8891   GtkRBNode *node;
8892   gboolean free_path = FALSE;
8893
8894   g_return_if_fail (path != NULL || iter != NULL);
8895
8896   if (iter)
8897     real_iter = *iter;
8898
8899   if (path == NULL)
8900     {
8901       path = gtk_tree_model_get_path (model, iter);
8902       free_path = TRUE;
8903     }
8904   else if (iter == NULL)
8905     gtk_tree_model_get_iter (model, &real_iter, path);
8906
8907   if (_gtk_tree_view_find_node (tree_view,
8908                                 path,
8909                                 &tree,
8910                                 &node))
8911     /* We aren't actually showing the node */
8912     goto done;
8913
8914   if (tree == NULL)
8915     goto done;
8916
8917   has_child = gtk_tree_model_iter_has_child (model, &real_iter);
8918   /* Sanity check.
8919    */
8920   if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT) == has_child)
8921     goto done;
8922
8923   if (has_child)
8924     GTK_RBNODE_SET_FLAG (node, GTK_RBNODE_IS_PARENT);
8925   else
8926     GTK_RBNODE_UNSET_FLAG (node, GTK_RBNODE_IS_PARENT);
8927
8928   if (has_child && tree_view->priv->is_list)
8929     {
8930       tree_view->priv->is_list = FALSE;
8931       if (tree_view->priv->show_expanders)
8932         {
8933           GList *list;
8934
8935           for (list = tree_view->priv->columns; list; list = list->next)
8936             if (gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (list->data)))
8937               {
8938                 _gtk_tree_view_column_cell_set_dirty (GTK_TREE_VIEW_COLUMN (list->data), TRUE);
8939                 break;
8940               }
8941         }
8942       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
8943     }
8944   else
8945     {
8946       _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
8947     }
8948
8949  done:
8950   if (free_path)
8951     gtk_tree_path_free (path);
8952 }
8953
8954 static void
8955 count_children_helper (GtkRBTree *tree,
8956                        GtkRBNode *node,
8957                        gpointer   data)
8958 {
8959   if (node->children)
8960     _gtk_rbtree_traverse (node->children, node->children->root, G_POST_ORDER, count_children_helper, data);
8961   (*((gint *)data))++;
8962 }
8963
8964 static void
8965 check_selection_helper (GtkRBTree *tree,
8966                         GtkRBNode *node,
8967                         gpointer   data)
8968 {
8969   gint *value = (gint *)data;
8970
8971   *value = GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED);
8972
8973   if (node->children && !*value)
8974     _gtk_rbtree_traverse (node->children, node->children->root, G_POST_ORDER, check_selection_helper, data);
8975 }
8976
8977 static void
8978 gtk_tree_view_row_deleted (GtkTreeModel *model,
8979                            GtkTreePath  *path,
8980                            gpointer      data)
8981 {
8982   GtkTreeView *tree_view = (GtkTreeView *)data;
8983   GtkRBTree *tree;
8984   GtkRBNode *node;
8985   GList *list;
8986   gint selection_changed = FALSE;
8987   GtkStyleContext *context;
8988
8989   g_return_if_fail (path != NULL);
8990
8991   gtk_tree_row_reference_deleted (G_OBJECT (data), path);
8992
8993   if (_gtk_tree_view_find_node (tree_view, path, &tree, &node))
8994     return;
8995
8996   if (tree == NULL)
8997     return;
8998
8999   /* check if the selection has been changed */
9000   _gtk_rbtree_traverse (tree, node, G_POST_ORDER,
9001                         check_selection_helper, &selection_changed);
9002
9003   for (list = tree_view->priv->columns; list; list = list->next)
9004     if (gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (list->data)) &&
9005         gtk_tree_view_column_get_sizing (GTK_TREE_VIEW_COLUMN (list->data)) == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
9006       _gtk_tree_view_column_cell_set_dirty ((GtkTreeViewColumn *)list->data, TRUE);
9007
9008   /* Ensure we don't have a dangling pointer to a dead node */
9009   ensure_unprelighted (tree_view);
9010
9011   /* Cancel editting if we've started */
9012   gtk_tree_view_stop_editing (tree_view, TRUE);
9013
9014   if (tree_view->priv->destroy_count_func)
9015     {
9016       gint child_count = 0;
9017       if (node->children)
9018         _gtk_rbtree_traverse (node->children, node->children->root, G_POST_ORDER, count_children_helper, &child_count);
9019       tree_view->priv->destroy_count_func (tree_view, path, child_count, tree_view->priv->destroy_count_data);
9020     }
9021
9022   if (tree->root->count == 1)
9023     {
9024       if (tree_view->priv->tree == tree)
9025         tree_view->priv->tree = NULL;
9026
9027       _gtk_rbtree_remove (tree);
9028     }
9029   else
9030     {
9031       _gtk_rbtree_remove_node (tree, node);
9032     }
9033
9034   if (! gtk_tree_row_reference_valid (tree_view->priv->top_row))
9035     {
9036       gtk_tree_row_reference_free (tree_view->priv->top_row);
9037       tree_view->priv->top_row = NULL;
9038     }
9039
9040   /* Cancel any ongoing animation happening within the row */
9041   context = gtk_widget_get_style_context (GTK_WIDGET (tree_view));
9042   gtk_style_context_cancel_animations (context, node);
9043
9044   install_scroll_sync_handler (tree_view);
9045
9046   gtk_widget_queue_resize (GTK_WIDGET (tree_view));
9047
9048   if (selection_changed)
9049     g_signal_emit_by_name (tree_view->priv->selection, "changed");
9050 }
9051
9052 static void
9053 gtk_tree_view_rows_reordered (GtkTreeModel *model,
9054                               GtkTreePath  *parent,
9055                               GtkTreeIter  *iter,
9056                               gint         *new_order,
9057                               gpointer      data)
9058 {
9059   GtkTreeView *tree_view = GTK_TREE_VIEW (data);
9060   GtkRBTree *tree;
9061   GtkRBNode *node;
9062   gint len;
9063
9064   len = gtk_tree_model_iter_n_children (model, iter);
9065
9066   if (len < 2)
9067     return;
9068
9069   gtk_tree_row_reference_reordered (G_OBJECT (data),
9070                                     parent,
9071                                     iter,
9072                                     new_order);
9073
9074   if (_gtk_tree_view_find_node (tree_view,
9075                                 parent,
9076                                 &tree,
9077                                 &node))
9078     return;
9079
9080   /* We need to special case the parent path */
9081   if (tree == NULL)
9082     tree = tree_view->priv->tree;
9083   else
9084     tree = node->children;
9085
9086   if (tree == NULL)
9087     return;
9088
9089   if (tree_view->priv->edited_column)
9090     gtk_tree_view_stop_editing (tree_view, TRUE);
9091
9092   /* we need to be unprelighted */
9093   ensure_unprelighted (tree_view);
9094
9095   _gtk_rbtree_reorder (tree, new_order, len);
9096
9097   gtk_widget_queue_draw (GTK_WIDGET (tree_view));
9098
9099   gtk_tree_view_dy_to_top_row (tree_view);
9100 }
9101
9102
9103 /* Internal tree functions
9104  */
9105
9106
9107 static void
9108 gtk_tree_view_get_background_xrange (GtkTreeView       *tree_view,
9109                                      GtkRBTree         *tree,
9110                                      GtkTreeViewColumn *column,
9111                                      gint              *x1,
9112                                      gint              *x2)
9113 {
9114   GtkTreeViewColumn *tmp_column = NULL;
9115   gint total_width;
9116   GList *list;
9117   gboolean rtl;
9118
9119   if (x1)
9120     *x1 = 0;
9121
9122   if (x2)
9123     *x2 = 0;
9124
9125   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
9126
9127   total_width = 0;
9128   for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
9129        list;
9130        list = (rtl ? list->prev : list->next))
9131     {
9132       tmp_column = list->data;
9133
9134       if (tmp_column == column)
9135         break;
9136
9137       if (gtk_tree_view_column_get_visible (tmp_column))
9138         total_width += gtk_tree_view_column_get_width (tmp_column);
9139     }
9140
9141   if (tmp_column != column)
9142     {
9143       g_warning (G_STRLOC": passed-in column isn't in the tree");
9144       return;
9145     }
9146
9147   if (x1)
9148     *x1 = total_width;
9149
9150   if (x2)
9151     {
9152       if (gtk_tree_view_column_get_visible (column))
9153         *x2 = total_width + gtk_tree_view_column_get_width (column);
9154       else
9155         *x2 = total_width; /* width of 0 */
9156     }
9157 }
9158
9159 static void
9160 gtk_tree_view_get_arrow_xrange (GtkTreeView *tree_view,
9161                                 GtkRBTree   *tree,
9162                                 gint        *x1,
9163                                 gint        *x2)
9164 {
9165   gint x_offset = 0;
9166   GList *list;
9167   GtkTreeViewColumn *tmp_column = NULL;
9168   gint total_width;
9169   gboolean indent_expanders;
9170   gboolean rtl;
9171
9172   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
9173
9174   total_width = 0;
9175   for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
9176        list;
9177        list = (rtl ? list->prev : list->next))
9178     {
9179       tmp_column = list->data;
9180
9181       if (gtk_tree_view_is_expander_column (tree_view, tmp_column))
9182         {
9183           if (rtl)
9184             x_offset = total_width + gtk_tree_view_column_get_width (tmp_column) - tree_view->priv->expander_size;
9185           else
9186             x_offset = total_width;
9187           break;
9188         }
9189
9190       if (gtk_tree_view_column_get_visible (tmp_column))
9191         total_width += gtk_tree_view_column_get_width (tmp_column);
9192     }
9193
9194   gtk_widget_style_get (GTK_WIDGET (tree_view),
9195                         "indent-expanders", &indent_expanders,
9196                         NULL);
9197
9198   if (indent_expanders)
9199     {
9200       if (rtl)
9201         x_offset -= tree_view->priv->expander_size * _gtk_rbtree_get_depth (tree);
9202       else
9203         x_offset += tree_view->priv->expander_size * _gtk_rbtree_get_depth (tree);
9204     }
9205
9206   *x1 = x_offset;
9207
9208   if (tmp_column &&
9209       gtk_tree_view_column_get_visible (tmp_column))
9210     /* +1 because x2 isn't included in the range. */
9211     *x2 = *x1 + tree_view->priv->expander_size + 1;
9212   else
9213     *x2 = *x1;
9214 }
9215
9216 static void
9217 gtk_tree_view_build_tree (GtkTreeView *tree_view,
9218                           GtkRBTree   *tree,
9219                           GtkTreeIter *iter,
9220                           gint         depth,
9221                           gboolean     recurse)
9222 {
9223   GtkRBNode *temp = NULL;
9224   GtkTreePath *path = NULL;
9225
9226   do
9227     {
9228       gtk_tree_model_ref_node (tree_view->priv->model, iter);
9229       temp = _gtk_rbtree_insert_after (tree, temp, 0, FALSE);
9230
9231       if (tree_view->priv->fixed_height > 0)
9232         {
9233           if (GTK_RBNODE_FLAG_SET (temp, GTK_RBNODE_INVALID))
9234             {
9235               _gtk_rbtree_node_set_height (tree, temp, tree_view->priv->fixed_height);
9236               _gtk_rbtree_node_mark_valid (tree, temp);
9237             }
9238         }
9239
9240       if (tree_view->priv->is_list)
9241         continue;
9242
9243       if (recurse)
9244         {
9245           GtkTreeIter child;
9246
9247           if (!path)
9248             path = gtk_tree_model_get_path (tree_view->priv->model, iter);
9249           else
9250             gtk_tree_path_next (path);
9251
9252           if (gtk_tree_model_iter_children (tree_view->priv->model, &child, iter))
9253             {
9254               gboolean expand;
9255
9256               g_signal_emit (tree_view, tree_view_signals[TEST_EXPAND_ROW], 0, iter, path, &expand);
9257
9258               if (gtk_tree_model_iter_has_child (tree_view->priv->model, iter)
9259                   && !expand)
9260                 {
9261                   temp->children = _gtk_rbtree_new ();
9262                   temp->children->parent_tree = tree;
9263                   temp->children->parent_node = temp;
9264                   gtk_tree_view_build_tree (tree_view, temp->children, &child, depth + 1, recurse);
9265                 }
9266             }
9267         }
9268
9269       if (gtk_tree_model_iter_has_child (tree_view->priv->model, iter))
9270         {
9271           if ((temp->flags&GTK_RBNODE_IS_PARENT) != GTK_RBNODE_IS_PARENT)
9272             temp->flags ^= GTK_RBNODE_IS_PARENT;
9273         }
9274     }
9275   while (gtk_tree_model_iter_next (tree_view->priv->model, iter));
9276
9277   if (path)
9278     gtk_tree_path_free (path);
9279 }
9280
9281 /* Make sure the node is visible vertically */
9282 static void
9283 gtk_tree_view_clamp_node_visible (GtkTreeView *tree_view,
9284                                   GtkRBTree   *tree,
9285                                   GtkRBNode   *node)
9286 {
9287   gint node_dy, height;
9288   GtkTreePath *path = NULL;
9289
9290   if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
9291     return;
9292
9293   /* just return if the node is visible, avoiding a costly expose */
9294   node_dy = _gtk_rbtree_node_find_offset (tree, node);
9295   height = gtk_tree_view_get_row_height (tree_view, node);
9296   if (! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID)
9297       && node_dy >= gtk_adjustment_get_value (tree_view->priv->vadjustment)
9298       && node_dy + height <= (gtk_adjustment_get_value (tree_view->priv->vadjustment)
9299                               + gtk_adjustment_get_page_size (tree_view->priv->vadjustment)))
9300     return;
9301
9302   path = _gtk_tree_view_find_path (tree_view, tree, node);
9303   if (path)
9304     {
9305       /* We process updates because we want to clear old selected items when we scroll.
9306        * if this is removed, we get a "selection streak" at the bottom. */
9307       gtk_tree_view_bin_process_updates (tree_view);
9308
9309       gtk_tree_view_scroll_to_cell (tree_view, path, NULL, FALSE, 0.0, 0.0);
9310       gtk_tree_path_free (path);
9311     }
9312 }
9313
9314 static void
9315 gtk_tree_view_clamp_column_visible (GtkTreeView       *tree_view,
9316                                     GtkTreeViewColumn *column,
9317                                     gboolean           focus_to_cell)
9318 {
9319   GtkAllocation allocation;
9320   gint x, width;
9321
9322   if (column == NULL)
9323     return;
9324
9325   gtk_widget_get_allocation (gtk_tree_view_column_get_button (column), &allocation);
9326   x = allocation.x;
9327   width = allocation.width;
9328
9329   if (width > gtk_adjustment_get_page_size (tree_view->priv->hadjustment))
9330     {
9331       /* The column is larger than the horizontal page size.  If the
9332        * column has cells which can be focussed individually, then we make
9333        * sure the cell which gets focus is fully visible (if even the
9334        * focus cell is bigger than the page size, we make sure the
9335        * left-hand side of the cell is visible).
9336        *
9337        * If the column does not have an activatable cell, we
9338        * make sure the left-hand side of the column is visible.
9339        */
9340
9341       if (focus_to_cell && gtk_tree_view_has_can_focus_cell (tree_view))
9342         {
9343           GtkCellArea *cell_area;
9344           GtkCellRenderer *focus_cell;
9345
9346           cell_area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (column));
9347           focus_cell = gtk_cell_area_get_focus_cell (cell_area);
9348
9349           if (gtk_tree_view_column_cell_get_position (column, focus_cell,
9350                                                       &x, &width))
9351             {
9352               if (width < gtk_adjustment_get_page_size (tree_view->priv->hadjustment))
9353                 {
9354                   if (gtk_adjustment_get_value (tree_view->priv->hadjustment) + gtk_adjustment_get_page_size (tree_view->priv->hadjustment) < x + width)
9355                     gtk_adjustment_set_value (tree_view->priv->hadjustment,
9356                                               x + width - gtk_adjustment_get_page_size (tree_view->priv->hadjustment));
9357                   else if (gtk_adjustment_get_value (tree_view->priv->hadjustment) > x)
9358                     gtk_adjustment_set_value (tree_view->priv->hadjustment, x);
9359                 }
9360             }
9361         }
9362
9363       gtk_adjustment_set_value (tree_view->priv->hadjustment, x);
9364     }
9365   else
9366     {
9367       if ((gtk_adjustment_get_value (tree_view->priv->hadjustment) + gtk_adjustment_get_page_size (tree_view->priv->hadjustment)) < (x + width))
9368           gtk_adjustment_set_value (tree_view->priv->hadjustment,
9369                                     x + width - gtk_adjustment_get_page_size (tree_view->priv->hadjustment));
9370       else if (gtk_adjustment_get_value (tree_view->priv->hadjustment) > x)
9371         gtk_adjustment_set_value (tree_view->priv->hadjustment, x);
9372   }
9373 }
9374
9375 /* This function could be more efficient.  I'll optimize it if profiling seems
9376  * to imply that it is important */
9377 GtkTreePath *
9378 _gtk_tree_view_find_path (GtkTreeView *tree_view,
9379                           GtkRBTree   *tree,
9380                           GtkRBNode   *node)
9381 {
9382   GtkTreePath *path;
9383   GtkRBTree *tmp_tree;
9384   GtkRBNode *tmp_node, *last;
9385   gint count;
9386
9387   path = gtk_tree_path_new ();
9388
9389   g_return_val_if_fail (node != NULL, path);
9390   g_return_val_if_fail (node != tree->nil, path);
9391
9392   count = 1 + node->left->count;
9393
9394   last = node;
9395   tmp_node = node->parent;
9396   tmp_tree = tree;
9397   while (tmp_tree)
9398     {
9399       while (tmp_node != tmp_tree->nil)
9400         {
9401           if (tmp_node->right == last)
9402             count += 1 + tmp_node->left->count;
9403           last = tmp_node;
9404           tmp_node = tmp_node->parent;
9405         }
9406       gtk_tree_path_prepend_index (path, count - 1);
9407       last = tmp_tree->parent_node;
9408       tmp_tree = tmp_tree->parent_tree;
9409       if (last)
9410         {
9411           count = 1 + last->left->count;
9412           tmp_node = last->parent;
9413         }
9414     }
9415   return path;
9416 }
9417
9418 /* Returns TRUE if we ran out of tree before finding the path.  If the path is
9419  * invalid (ie. points to a node that's not in the tree), *tree and *node are
9420  * both set to NULL.
9421  */
9422 gboolean
9423 _gtk_tree_view_find_node (GtkTreeView  *tree_view,
9424                           GtkTreePath  *path,
9425                           GtkRBTree   **tree,
9426                           GtkRBNode   **node)
9427 {
9428   GtkRBNode *tmpnode = NULL;
9429   GtkRBTree *tmptree = tree_view->priv->tree;
9430   gint *indices = gtk_tree_path_get_indices (path);
9431   gint depth = gtk_tree_path_get_depth (path);
9432   gint i = 0;
9433
9434   *node = NULL;
9435   *tree = NULL;
9436
9437   if (depth == 0 || tmptree == NULL)
9438     return FALSE;
9439   do
9440     {
9441       tmpnode = _gtk_rbtree_find_count (tmptree, indices[i] + 1);
9442       ++i;
9443       if (tmpnode == NULL)
9444         {
9445           *tree = NULL;
9446           *node = NULL;
9447           return FALSE;
9448         }
9449       if (i >= depth)
9450         {
9451           *tree = tmptree;
9452           *node = tmpnode;
9453           return FALSE;
9454         }
9455       *tree = tmptree;
9456       *node = tmpnode;
9457       tmptree = tmpnode->children;
9458       if (tmptree == NULL)
9459         return TRUE;
9460     }
9461   while (1);
9462 }
9463
9464 static gboolean
9465 gtk_tree_view_is_expander_column (GtkTreeView       *tree_view,
9466                                   GtkTreeViewColumn *column)
9467 {
9468   GList *list;
9469
9470   if (tree_view->priv->is_list)
9471     return FALSE;
9472
9473   if (tree_view->priv->expander_column != NULL)
9474     {
9475       if (tree_view->priv->expander_column == column)
9476         return TRUE;
9477       return FALSE;
9478     }
9479   else
9480     {
9481       for (list = tree_view->priv->columns;
9482            list;
9483            list = list->next)
9484         if (gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (list->data)))
9485           break;
9486       if (list && list->data == column)
9487         return TRUE;
9488     }
9489   return FALSE;
9490 }
9491
9492 static inline gboolean
9493 gtk_tree_view_draw_expanders (GtkTreeView *tree_view)
9494 {
9495   if (!tree_view->priv->is_list && tree_view->priv->show_expanders)
9496     return TRUE;
9497   /* else */
9498   return FALSE;
9499 }
9500
9501 static void
9502 gtk_tree_view_add_move_binding (GtkBindingSet  *binding_set,
9503                                 guint           keyval,
9504                                 guint           modmask,
9505                                 gboolean        add_shifted_binding,
9506                                 GtkMovementStep step,
9507                                 gint            count)
9508 {
9509
9510   gtk_binding_entry_add_signal (binding_set, keyval, modmask,
9511                                 "move-cursor", 2,
9512                                 G_TYPE_ENUM, step,
9513                                 G_TYPE_INT, count);
9514
9515   if (add_shifted_binding)
9516     gtk_binding_entry_add_signal (binding_set, keyval, GDK_SHIFT_MASK,
9517                                   "move-cursor", 2,
9518                                   G_TYPE_ENUM, step,
9519                                   G_TYPE_INT, count);
9520
9521   if ((modmask & GDK_CONTROL_MASK) == GDK_CONTROL_MASK)
9522    return;
9523
9524   gtk_binding_entry_add_signal (binding_set, keyval, GDK_CONTROL_MASK | GDK_SHIFT_MASK,
9525                                 "move-cursor", 2,
9526                                 G_TYPE_ENUM, step,
9527                                 G_TYPE_INT, count);
9528
9529   gtk_binding_entry_add_signal (binding_set, keyval, GDK_CONTROL_MASK,
9530                                 "move-cursor", 2,
9531                                 G_TYPE_ENUM, step,
9532                                 G_TYPE_INT, count);
9533 }
9534
9535 static gint
9536 gtk_tree_view_unref_tree_helper (GtkTreeModel *model,
9537                                  GtkTreeIter  *iter,
9538                                  GtkRBTree    *tree,
9539                                  GtkRBNode    *node)
9540 {
9541   gint retval = FALSE;
9542   do
9543     {
9544       g_return_val_if_fail (node != NULL, FALSE);
9545
9546       if (node->children)
9547         {
9548           GtkTreeIter child;
9549           GtkRBTree *new_tree;
9550           GtkRBNode *new_node;
9551
9552           new_tree = node->children;
9553           new_node = new_tree->root;
9554
9555           while (new_node && new_node->left != new_tree->nil)
9556             new_node = new_node->left;
9557
9558           if (!gtk_tree_model_iter_children (model, &child, iter))
9559             return FALSE;
9560
9561           retval = retval || gtk_tree_view_unref_tree_helper (model, &child, new_tree, new_node);
9562         }
9563
9564       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
9565         retval = TRUE;
9566       gtk_tree_model_unref_node (model, iter);
9567       node = _gtk_rbtree_next (tree, node);
9568     }
9569   while (gtk_tree_model_iter_next (model, iter));
9570
9571   return retval;
9572 }
9573
9574 static gint
9575 gtk_tree_view_unref_and_check_selection_tree (GtkTreeView *tree_view,
9576                                               GtkRBTree   *tree)
9577 {
9578   GtkTreeIter iter;
9579   GtkTreePath *path;
9580   GtkRBNode *node;
9581   gint retval;
9582
9583   if (!tree)
9584     return FALSE;
9585
9586   node = tree->root;
9587   while (node && node->left != tree->nil)
9588     node = node->left;
9589
9590   g_return_val_if_fail (node != NULL, FALSE);
9591   path = _gtk_tree_view_find_path (tree_view, tree, node);
9592   gtk_tree_model_get_iter (GTK_TREE_MODEL (tree_view->priv->model),
9593                            &iter, path);
9594   retval = gtk_tree_view_unref_tree_helper (GTK_TREE_MODEL (tree_view->priv->model), &iter, tree, node);
9595   gtk_tree_path_free (path);
9596
9597   return retval;
9598 }
9599
9600 static void
9601 gtk_tree_view_set_column_drag_info (GtkTreeView       *tree_view,
9602                                     GtkTreeViewColumn *column)
9603 {
9604   GtkTreeViewColumn *left_column;
9605   GtkTreeViewColumn *cur_column = NULL;
9606   GtkTreeViewColumnReorder *reorder;
9607   gboolean rtl;
9608   GList *tmp_list;
9609   gint left;
9610
9611   /* We want to precalculate the motion list such that we know what column slots
9612    * are available.
9613    */
9614   left_column = NULL;
9615   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
9616
9617   /* First, identify all possible drop spots */
9618   if (rtl)
9619     tmp_list = g_list_last (tree_view->priv->columns);
9620   else
9621     tmp_list = g_list_first (tree_view->priv->columns);
9622
9623   while (tmp_list)
9624     {
9625       cur_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
9626       tmp_list = rtl?g_list_previous (tmp_list):g_list_next (tmp_list);
9627
9628       if (gtk_tree_view_column_get_visible (cur_column) == FALSE)
9629         continue;
9630
9631       /* If it's not the column moving and func tells us to skip over the column, we continue. */
9632       if (left_column != column && cur_column != column &&
9633           tree_view->priv->column_drop_func &&
9634           ! tree_view->priv->column_drop_func (tree_view, column, left_column, cur_column, tree_view->priv->column_drop_func_data))
9635         {
9636           left_column = cur_column;
9637           continue;
9638         }
9639       reorder = g_slice_new0 (GtkTreeViewColumnReorder);
9640       reorder->left_column = left_column;
9641       left_column = reorder->right_column = cur_column;
9642
9643       tree_view->priv->column_drag_info = g_list_append (tree_view->priv->column_drag_info, reorder);
9644     }
9645
9646   /* Add the last one */
9647   if (tree_view->priv->column_drop_func == NULL ||
9648       ((left_column != column) &&
9649        tree_view->priv->column_drop_func (tree_view, column, left_column, NULL, tree_view->priv->column_drop_func_data)))
9650     {
9651       reorder = g_slice_new0 (GtkTreeViewColumnReorder);
9652       reorder->left_column = left_column;
9653       reorder->right_column = NULL;
9654       tree_view->priv->column_drag_info = g_list_append (tree_view->priv->column_drag_info, reorder);
9655     }
9656
9657   /* We quickly check to see if it even makes sense to reorder columns. */
9658   /* If there is nothing that can be moved, then we return */
9659
9660   if (tree_view->priv->column_drag_info == NULL)
9661     return;
9662
9663   /* We know there are always 2 slots possbile, as you can always return column. */
9664   /* If that's all there is, return */
9665   if (tree_view->priv->column_drag_info->next == NULL ||
9666       (tree_view->priv->column_drag_info->next->next == NULL &&
9667        ((GtkTreeViewColumnReorder *)tree_view->priv->column_drag_info->data)->right_column == column &&
9668        ((GtkTreeViewColumnReorder *)tree_view->priv->column_drag_info->next->data)->left_column == column))
9669     {
9670       for (tmp_list = tree_view->priv->column_drag_info; tmp_list; tmp_list = tmp_list->next)
9671         g_slice_free (GtkTreeViewColumnReorder, tmp_list->data);
9672       g_list_free (tree_view->priv->column_drag_info);
9673       tree_view->priv->column_drag_info = NULL;
9674       return;
9675     }
9676   /* We fill in the ranges for the columns, now that we've isolated them */
9677   left = - TREE_VIEW_COLUMN_DRAG_DEAD_MULTIPLIER (tree_view);
9678
9679   for (tmp_list = tree_view->priv->column_drag_info; tmp_list; tmp_list = tmp_list->next)
9680     {
9681       reorder = (GtkTreeViewColumnReorder *) tmp_list->data;
9682
9683       reorder->left_align = left;
9684       if (tmp_list->next != NULL)
9685         {
9686           GtkAllocation right_allocation, left_allocation;
9687           GtkWidget    *left_button, *right_button;
9688
9689           g_assert (tmp_list->next->data);
9690
9691           right_button = gtk_tree_view_column_get_button (reorder->right_column);
9692           left_button  = gtk_tree_view_column_get_button
9693             (((GtkTreeViewColumnReorder *)tmp_list->next->data)->left_column);
9694
9695           gtk_widget_get_allocation (right_button, &right_allocation);
9696           gtk_widget_get_allocation (left_button, &left_allocation);
9697           left = reorder->right_align = (right_allocation.x + right_allocation.width + left_allocation.x) / 2;
9698         }
9699       else
9700         {
9701           reorder->right_align = gdk_window_get_width (tree_view->priv->header_window)
9702                                  + TREE_VIEW_COLUMN_DRAG_DEAD_MULTIPLIER (tree_view);
9703         }
9704     }
9705 }
9706
9707 void
9708 _gtk_tree_view_column_start_drag (GtkTreeView       *tree_view,
9709                                   GtkTreeViewColumn *column,
9710                                   GdkDevice         *device)
9711 {
9712   GdkEvent *send_event;
9713   GtkAllocation allocation;
9714   GtkAllocation button_allocation;
9715   GdkScreen *screen = gtk_widget_get_screen (GTK_WIDGET (tree_view));
9716   GtkWidget *button;
9717   GdkDevice *pointer, *keyboard;
9718
9719   g_return_if_fail (tree_view->priv->column_drag_info == NULL);
9720   g_return_if_fail (tree_view->priv->cur_reorder == NULL);
9721
9722   gtk_tree_view_set_column_drag_info (tree_view, column);
9723
9724   if (tree_view->priv->column_drag_info == NULL)
9725     return;
9726
9727   button = gtk_tree_view_column_get_button (column);
9728
9729   if (tree_view->priv->drag_window == NULL)
9730     {
9731       GdkWindowAttr attributes;
9732       guint attributes_mask;
9733
9734       gtk_widget_get_allocation (button, &button_allocation);
9735
9736       attributes.window_type = GDK_WINDOW_CHILD;
9737       attributes.wclass = GDK_INPUT_OUTPUT;
9738       attributes.x = button_allocation.x;
9739       attributes.y = 0;
9740       attributes.width = button_allocation.width;
9741       attributes.height = button_allocation.height;
9742       attributes.visual = gtk_widget_get_visual (GTK_WIDGET (tree_view));
9743       attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK;
9744       attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
9745
9746       tree_view->priv->drag_window = gdk_window_new (tree_view->priv->bin_window,
9747                                                      &attributes,
9748                                                      attributes_mask);
9749       gdk_window_set_user_data (tree_view->priv->drag_window, GTK_WIDGET (tree_view));
9750     }
9751
9752   if (gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD)
9753     {
9754       keyboard = device;
9755       pointer = gdk_device_get_associated_device (device);
9756     }
9757   else
9758     {
9759       pointer = device;
9760       keyboard = gdk_device_get_associated_device (device);
9761     }
9762
9763   gdk_device_ungrab (pointer, GDK_CURRENT_TIME);
9764   gdk_device_ungrab (keyboard, GDK_CURRENT_TIME);
9765
9766   gtk_grab_remove (button);
9767
9768   send_event = gdk_event_new (GDK_LEAVE_NOTIFY);
9769   send_event->crossing.send_event = TRUE;
9770   send_event->crossing.window = g_object_ref (gtk_button_get_event_window (GTK_BUTTON (button)));
9771   send_event->crossing.subwindow = NULL;
9772   send_event->crossing.detail = GDK_NOTIFY_ANCESTOR;
9773   send_event->crossing.time = GDK_CURRENT_TIME;
9774   gdk_event_set_device (send_event, device);
9775
9776   gtk_propagate_event (button, send_event);
9777   gdk_event_free (send_event);
9778
9779   send_event = gdk_event_new (GDK_BUTTON_RELEASE);
9780   send_event->button.window = g_object_ref (gdk_screen_get_root_window (screen));
9781   send_event->button.send_event = TRUE;
9782   send_event->button.time = GDK_CURRENT_TIME;
9783   send_event->button.x = -1;
9784   send_event->button.y = -1;
9785   send_event->button.axes = NULL;
9786   send_event->button.state = 0;
9787   send_event->button.button = 1;
9788   send_event->button.x_root = 0;
9789   send_event->button.y_root = 0;
9790   gdk_event_set_device (send_event, device);
9791
9792   gtk_propagate_event (button, send_event);
9793   gdk_event_free (send_event);
9794
9795   /* Kids, don't try this at home */
9796   g_object_ref (button);
9797   gtk_container_remove (GTK_CONTAINER (tree_view), button);
9798   gtk_widget_set_parent_window (button, tree_view->priv->drag_window);
9799   gtk_widget_set_parent (button, GTK_WIDGET (tree_view));
9800   g_object_unref (button);
9801
9802   gtk_widget_get_allocation (button, &button_allocation);
9803   tree_view->priv->drag_column_x = button_allocation.x;
9804   allocation = button_allocation;
9805   allocation.x = 0;
9806   gtk_widget_size_allocate (button, &allocation);
9807   gtk_widget_set_parent_window (button, tree_view->priv->drag_window);
9808
9809   tree_view->priv->drag_column = column;
9810   gdk_window_show (tree_view->priv->drag_window);
9811
9812   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
9813   while (gtk_events_pending ())
9814     gtk_main_iteration ();
9815
9816   tree_view->priv->in_column_drag = TRUE;
9817
9818   gdk_device_grab (pointer,
9819                    tree_view->priv->drag_window,
9820                    GDK_OWNERSHIP_NONE,
9821                    FALSE,
9822                    GDK_POINTER_MOTION_MASK|GDK_BUTTON_RELEASE_MASK,
9823                    NULL,
9824                    GDK_CURRENT_TIME);
9825   gdk_device_grab (keyboard,
9826                    tree_view->priv->drag_window,
9827                    GDK_OWNERSHIP_NONE,
9828                    FALSE,
9829                    GDK_KEY_PRESS_MASK|GDK_KEY_RELEASE_MASK,
9830                    NULL,
9831                    GDK_CURRENT_TIME);
9832 }
9833
9834 static void
9835 gtk_tree_view_queue_draw_arrow (GtkTreeView        *tree_view,
9836                                 GtkRBTree          *tree,
9837                                 GtkRBNode          *node)
9838 {
9839   GtkAllocation allocation;
9840   GdkRectangle rect;
9841
9842   if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
9843     return;
9844
9845   gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
9846   rect.x = 0;
9847   rect.width = MAX (tree_view->priv->expander_size, MAX (tree_view->priv->width, allocation.width));
9848
9849   rect.y = gtk_tree_view_get_row_y_offset (tree_view, tree, node);
9850   rect.height = gtk_tree_view_get_row_height (tree_view, node);
9851
9852   gdk_window_invalidate_rect (tree_view->priv->bin_window, &rect, TRUE);
9853 }
9854
9855 void
9856 _gtk_tree_view_queue_draw_node (GtkTreeView        *tree_view,
9857                                 GtkRBTree          *tree,
9858                                 GtkRBNode          *node,
9859                                 const GdkRectangle *clip_rect)
9860 {
9861   GtkAllocation allocation;
9862   GdkRectangle rect;
9863
9864   if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
9865     return;
9866
9867   gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
9868   rect.x = 0;
9869   rect.width = MAX (tree_view->priv->width, allocation.width);
9870
9871   rect.y = gtk_tree_view_get_row_y_offset (tree_view, tree, node);
9872   rect.height = gtk_tree_view_get_row_height (tree_view, node);
9873
9874   if (clip_rect)
9875     {
9876       GdkRectangle new_rect;
9877
9878       gdk_rectangle_intersect (clip_rect, &rect, &new_rect);
9879
9880       gdk_window_invalidate_rect (tree_view->priv->bin_window, &new_rect, TRUE);
9881     }
9882   else
9883     {
9884       gdk_window_invalidate_rect (tree_view->priv->bin_window, &rect, TRUE);
9885     }
9886 }
9887
9888 static inline gint
9889 gtk_tree_view_get_effective_header_height (GtkTreeView *tree_view)
9890 {
9891   if (tree_view->priv->headers_visible)
9892     return tree_view->priv->header_height;
9893   /* else */
9894   return 0;
9895 }
9896
9897 gint
9898 _gtk_tree_view_get_header_height (GtkTreeView *tree_view)
9899 {
9900   return tree_view->priv->header_height;
9901 }
9902
9903 void
9904 _gtk_tree_view_get_row_separator_func (GtkTreeView                 *tree_view,
9905                                        GtkTreeViewRowSeparatorFunc *func,
9906                                        gpointer                    *data)
9907 {
9908   *func = tree_view->priv->row_separator_func;
9909   *data = tree_view->priv->row_separator_data;
9910 }
9911
9912 GtkTreePath *
9913 _gtk_tree_view_get_anchor_path (GtkTreeView *tree_view)
9914 {
9915   if (tree_view->priv->anchor)
9916     return gtk_tree_row_reference_get_path (tree_view->priv->anchor);
9917
9918   return NULL;
9919 }
9920
9921 void
9922 _gtk_tree_view_set_anchor_path (GtkTreeView *tree_view,
9923                                 GtkTreePath *anchor_path)
9924 {
9925   if (tree_view->priv->anchor)
9926     {
9927       gtk_tree_row_reference_free (tree_view->priv->anchor);
9928       tree_view->priv->anchor = NULL;
9929     }
9930
9931   if (anchor_path && tree_view->priv->model)
9932     tree_view->priv->anchor =
9933       gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view),
9934                                         tree_view->priv->model, anchor_path);
9935 }
9936
9937 GtkRBTree *
9938 _gtk_tree_view_get_rbtree (GtkTreeView *tree_view)
9939 {
9940   return tree_view->priv->tree;
9941 }
9942
9943 GdkWindow *
9944 _gtk_tree_view_get_header_window (GtkTreeView *tree_view)
9945 {
9946   return tree_view->priv->header_window;
9947 }
9948
9949 void
9950 _gtk_tree_view_set_focus_column (GtkTreeView       *tree_view,
9951                                  GtkTreeViewColumn *column)
9952 {
9953   tree_view->priv->focus_column = column;
9954 }
9955
9956
9957 static void
9958 gtk_tree_view_queue_draw_path (GtkTreeView        *tree_view,
9959                                GtkTreePath        *path,
9960                                const GdkRectangle *clip_rect)
9961 {
9962   GtkRBTree *tree = NULL;
9963   GtkRBNode *node = NULL;
9964
9965   _gtk_tree_view_find_node (tree_view, path, &tree, &node);
9966
9967   if (tree)
9968     _gtk_tree_view_queue_draw_node (tree_view, tree, node, clip_rect);
9969 }
9970
9971 /* x and y are the mouse position
9972  */
9973 static void
9974 gtk_tree_view_draw_arrow (GtkTreeView *tree_view,
9975                           cairo_t     *cr,
9976                           GtkRBTree   *tree,
9977                           GtkRBNode   *node)
9978 {
9979   GdkRectangle area;
9980   GtkStateFlags state = 0;
9981   GtkStyleContext *context;
9982   GtkWidget *widget;
9983   gint x_offset = 0;
9984   gint x2;
9985   gint vertical_separator;
9986   gint expander_size;
9987   GtkCellRendererState flags;
9988
9989   widget = GTK_WIDGET (tree_view);
9990   context = gtk_widget_get_style_context (widget);
9991
9992   gtk_widget_style_get (widget,
9993                         "vertical-separator", &vertical_separator,
9994                         NULL);
9995   expander_size = tree_view->priv->expander_size - EXPANDER_EXTRA_PADDING;
9996
9997   if (! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT))
9998     return;
9999
10000   gtk_tree_view_get_arrow_xrange (tree_view, tree, &x_offset, &x2);
10001
10002   area.x = x_offset;
10003   area.y = gtk_tree_view_get_cell_area_y_offset (tree_view, tree, node,
10004                                                  vertical_separator);
10005   area.width = expander_size;
10006   area.height = gtk_tree_view_get_cell_area_height (tree_view, node,
10007                                                     vertical_separator);
10008
10009   if (!gtk_widget_get_sensitive (widget))
10010     state |= GTK_STATE_FLAG_INSENSITIVE;
10011   else
10012     {
10013       flags = 0;
10014
10015       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
10016         flags |= GTK_CELL_RENDERER_SELECTED;
10017
10018       state = gtk_cell_renderer_get_state (NULL, widget, flags);
10019
10020       if (node == tree_view->priv->prelight_node &&
10021           tree_view->priv->arrow_prelit)
10022         state |= GTK_STATE_FLAG_PRELIGHT;
10023     }
10024
10025   if (node->children != NULL)
10026     state |= GTK_STATE_FLAG_ACTIVE;
10027
10028   gtk_style_context_save (context);
10029
10030   gtk_style_context_set_state (context, state);
10031   gtk_style_context_add_class (context, GTK_STYLE_CLASS_EXPANDER);
10032
10033   gtk_style_context_push_animatable_region (context, node);
10034
10035   gtk_render_expander (context, cr,
10036                        area.x, area.y,
10037                        area.width, area.height);
10038
10039   gtk_style_context_pop_animatable_region (context);
10040   gtk_style_context_restore (context);
10041 }
10042
10043 static void
10044 gtk_tree_view_focus_to_cursor (GtkTreeView *tree_view)
10045
10046 {
10047   GtkTreePath *cursor_path;
10048
10049   if ((tree_view->priv->tree == NULL) ||
10050       (! gtk_widget_get_realized (GTK_WIDGET (tree_view))))
10051     return;
10052
10053   cursor_path = NULL;
10054   if (tree_view->priv->cursor)
10055     cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
10056
10057   if (cursor_path == NULL)
10058     {
10059       /* Consult the selection before defaulting to the
10060        * first focusable element
10061        */
10062       GList *selected_rows;
10063       GtkTreeModel *model;
10064       GtkTreeSelection *selection;
10065
10066       selection = gtk_tree_view_get_selection (tree_view);
10067       selected_rows = gtk_tree_selection_get_selected_rows (selection, &model);
10068
10069       if (selected_rows)
10070         {
10071           cursor_path = gtk_tree_path_copy((const GtkTreePath *)(selected_rows->data));
10072           g_list_foreach (selected_rows, (GFunc)gtk_tree_path_free, NULL);
10073           g_list_free (selected_rows);
10074         }
10075       else
10076         {
10077           cursor_path = gtk_tree_path_new_first ();
10078           search_first_focusable_path (tree_view, &cursor_path,
10079                                        TRUE, NULL, NULL);
10080         }
10081
10082       gtk_tree_row_reference_free (tree_view->priv->cursor);
10083       tree_view->priv->cursor = NULL;
10084
10085       if (cursor_path)
10086         {
10087           if (gtk_tree_selection_get_mode (tree_view->priv->selection) == GTK_SELECTION_MULTIPLE)
10088             gtk_tree_view_real_set_cursor (tree_view, cursor_path, FALSE, FALSE);
10089           else
10090             gtk_tree_view_real_set_cursor (tree_view, cursor_path, TRUE, FALSE);
10091         }
10092     }
10093
10094   if (cursor_path)
10095     {
10096       tree_view->priv->draw_keyfocus = TRUE;
10097
10098       gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
10099       gtk_tree_path_free (cursor_path);
10100
10101       if (tree_view->priv->focus_column == NULL)
10102         {
10103           GList *list;
10104           for (list = tree_view->priv->columns; list; list = list->next)
10105             {
10106               if (gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (list->data)))
10107                 {
10108                   GtkCellArea *cell_area;
10109
10110                   tree_view->priv->focus_column = GTK_TREE_VIEW_COLUMN (list->data);
10111
10112                   /* This happens when the treeview initially grabs focus and there
10113                    * is no column in focus, here we explicitly focus into the first cell */
10114                   cell_area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (tree_view->priv->focus_column));
10115                   if (!gtk_cell_area_get_focus_cell (cell_area))
10116                     {
10117                       gboolean rtl;
10118
10119                       rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
10120                       gtk_cell_area_focus (cell_area,
10121                                            rtl ? GTK_DIR_LEFT : GTK_DIR_RIGHT);
10122                     }
10123
10124                   break;
10125                 }
10126             }
10127         }
10128     }
10129 }
10130
10131 static void
10132 gtk_tree_view_move_cursor_up_down (GtkTreeView *tree_view,
10133                                    gint         count)
10134 {
10135   gint selection_count;
10136   GtkRBTree *cursor_tree = NULL;
10137   GtkRBNode *cursor_node = NULL;
10138   GtkRBTree *new_cursor_tree = NULL;
10139   GtkRBNode *new_cursor_node = NULL;
10140   GtkTreePath *cursor_path = NULL;
10141   gboolean grab_focus = TRUE;
10142   gboolean selectable;
10143   GtkDirectionType direction;
10144   GtkCellArea *cell_area = NULL;
10145   GtkCellRenderer *last_focus_cell = NULL;
10146   GtkTreeIter iter;
10147
10148   if (! gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10149     return;
10150
10151   cursor_path = NULL;
10152   if (!gtk_tree_row_reference_valid (tree_view->priv->cursor))
10153     /* FIXME: we lost the cursor; should we get the first? */
10154     return;
10155
10156   cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
10157   _gtk_tree_view_find_node (tree_view, cursor_path,
10158                             &cursor_tree, &cursor_node);
10159
10160   if (cursor_tree == NULL)
10161     /* FIXME: we lost the cursor; should we get the first? */
10162     return;
10163
10164   direction = count < 0 ? GTK_DIR_UP : GTK_DIR_DOWN;
10165
10166   if (tree_view->priv->focus_column)
10167     cell_area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (tree_view->priv->focus_column));
10168
10169   /* If focus stays in the area for this row, then just return for this round */
10170   if (cell_area && (count == -1 || count == 1) &&
10171       gtk_tree_model_get_iter (tree_view->priv->model, &iter, cursor_path))
10172     {
10173       gtk_tree_view_column_cell_set_cell_data (tree_view->priv->focus_column,
10174                                                tree_view->priv->model,
10175                                                &iter,
10176                                                GTK_RBNODE_FLAG_SET (cursor_node, GTK_RBNODE_IS_PARENT),
10177                                                cursor_node->children?TRUE:FALSE);
10178
10179       /* Save the last cell that had focus, if we hit the end of the view we'll give
10180        * focus back to it. */
10181       last_focus_cell = gtk_cell_area_get_focus_cell (cell_area);
10182
10183       /* If focus stays in the area, no need to change the cursor row */
10184       if (gtk_cell_area_focus (cell_area, direction))
10185         return;
10186     }
10187
10188   selection_count = gtk_tree_selection_count_selected_rows (tree_view->priv->selection);
10189   selectable = _gtk_tree_selection_row_is_selectable (tree_view->priv->selection,
10190                                                       cursor_node,
10191                                                       cursor_path);
10192
10193   if (selection_count == 0
10194       && gtk_tree_selection_get_mode (tree_view->priv->selection) != GTK_SELECTION_NONE
10195       && !tree_view->priv->modify_selection_pressed
10196       && selectable)
10197     {
10198       /* Don't move the cursor, but just select the current node */
10199       new_cursor_tree = cursor_tree;
10200       new_cursor_node = cursor_node;
10201     }
10202   else
10203     {
10204       if (count == -1)
10205         _gtk_rbtree_prev_full (cursor_tree, cursor_node,
10206                                &new_cursor_tree, &new_cursor_node);
10207       else
10208         _gtk_rbtree_next_full (cursor_tree, cursor_node,
10209                                &new_cursor_tree, &new_cursor_node);
10210     }
10211
10212   gtk_tree_path_free (cursor_path);
10213
10214   if (new_cursor_node)
10215     {
10216       cursor_path = _gtk_tree_view_find_path (tree_view,
10217                                               new_cursor_tree, new_cursor_node);
10218
10219       search_first_focusable_path (tree_view, &cursor_path,
10220                                    (count != -1),
10221                                    &new_cursor_tree,
10222                                    &new_cursor_node);
10223
10224       if (cursor_path)
10225         gtk_tree_path_free (cursor_path);
10226     }
10227
10228   /*
10229    * If the list has only one item and multi-selection is set then select
10230    * the row (if not yet selected).
10231    */
10232   if (gtk_tree_selection_get_mode (tree_view->priv->selection) == GTK_SELECTION_MULTIPLE &&
10233       new_cursor_node == NULL)
10234     {
10235       if (count == -1)
10236         _gtk_rbtree_next_full (cursor_tree, cursor_node,
10237                                &new_cursor_tree, &new_cursor_node);
10238       else
10239         _gtk_rbtree_prev_full (cursor_tree, cursor_node,
10240                                &new_cursor_tree, &new_cursor_node);
10241
10242       if (new_cursor_node == NULL
10243           && !GTK_RBNODE_FLAG_SET (cursor_node, GTK_RBNODE_IS_SELECTED))
10244         {
10245           new_cursor_node = cursor_node;
10246           new_cursor_tree = cursor_tree;
10247         }
10248       else
10249         {
10250           new_cursor_node = NULL;
10251         }
10252     }
10253
10254   if (new_cursor_node)
10255     {
10256       cursor_path = _gtk_tree_view_find_path (tree_view, new_cursor_tree, new_cursor_node);
10257       gtk_tree_view_real_set_cursor (tree_view, cursor_path, TRUE, TRUE);
10258       gtk_tree_path_free (cursor_path);
10259
10260       /* Give focus to the area in the new row */
10261       if (cell_area)
10262         gtk_cell_area_focus (cell_area, direction);
10263     }
10264   else
10265     {
10266       gtk_tree_view_clamp_node_visible (tree_view, cursor_tree, cursor_node);
10267
10268       if (!tree_view->priv->extend_selection_pressed)
10269         {
10270           if (! gtk_widget_keynav_failed (GTK_WIDGET (tree_view),
10271                                           count < 0 ?
10272                                           GTK_DIR_UP : GTK_DIR_DOWN))
10273             {
10274               GtkWidget *toplevel = gtk_widget_get_toplevel (GTK_WIDGET (tree_view));
10275
10276               if (toplevel)
10277                 gtk_widget_child_focus (toplevel,
10278                                         count < 0 ?
10279                                         GTK_DIR_TAB_BACKWARD :
10280                                         GTK_DIR_TAB_FORWARD);
10281
10282               grab_focus = FALSE;
10283             }
10284         }
10285       else
10286         {
10287           gtk_widget_error_bell (GTK_WIDGET (tree_view));
10288         }
10289
10290       if (cell_area)
10291         gtk_cell_area_set_focus_cell (cell_area, last_focus_cell);
10292     }
10293
10294   if (grab_focus)
10295     gtk_widget_grab_focus (GTK_WIDGET (tree_view));
10296 }
10297
10298 static void
10299 gtk_tree_view_move_cursor_page_up_down (GtkTreeView *tree_view,
10300                                         gint         count)
10301 {
10302   GtkRBTree *cursor_tree = NULL;
10303   GtkRBNode *cursor_node = NULL;
10304   GtkTreePath *old_cursor_path = NULL;
10305   GtkTreePath *cursor_path = NULL;
10306   GtkRBTree *start_cursor_tree = NULL;
10307   GtkRBNode *start_cursor_node = NULL;
10308   gint y;
10309   gint window_y;
10310   gint vertical_separator;
10311
10312   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10313     return;
10314
10315   if (gtk_tree_row_reference_valid (tree_view->priv->cursor))
10316     old_cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
10317   else
10318     /* This is sorta weird.  Focus in should give us a cursor */
10319     return;
10320
10321   gtk_widget_style_get (GTK_WIDGET (tree_view), "vertical-separator", &vertical_separator, NULL);
10322   _gtk_tree_view_find_node (tree_view, old_cursor_path,
10323                             &cursor_tree, &cursor_node);
10324
10325   if (cursor_tree == NULL)
10326     {
10327       /* FIXME: we lost the cursor.  Should we try to get one? */
10328       gtk_tree_path_free (old_cursor_path);
10329       return;
10330     }
10331   g_return_if_fail (cursor_node != NULL);
10332
10333   y = _gtk_rbtree_node_find_offset (cursor_tree, cursor_node);
10334   window_y = RBTREE_Y_TO_TREE_WINDOW_Y (tree_view, y);
10335   y += tree_view->priv->cursor_offset;
10336   y += count * (int)gtk_adjustment_get_page_increment (tree_view->priv->vadjustment);
10337   y = CLAMP (y, (gint)gtk_adjustment_get_lower (tree_view->priv->vadjustment),  (gint)gtk_adjustment_get_upper (tree_view->priv->vadjustment) - vertical_separator);
10338
10339   if (y >= tree_view->priv->height)
10340     y = tree_view->priv->height - 1;
10341
10342   tree_view->priv->cursor_offset =
10343     _gtk_rbtree_find_offset (tree_view->priv->tree, y,
10344                              &cursor_tree, &cursor_node);
10345
10346   if (cursor_tree == NULL)
10347     {
10348       /* FIXME: we lost the cursor.  Should we try to get one? */
10349       gtk_tree_path_free (old_cursor_path);
10350       return;
10351     }
10352
10353   if (tree_view->priv->cursor_offset
10354       > gtk_tree_view_get_row_height (tree_view, cursor_node))
10355     {
10356       _gtk_rbtree_next_full (cursor_tree, cursor_node,
10357                              &cursor_tree, &cursor_node);
10358       tree_view->priv->cursor_offset -= gtk_tree_view_get_row_height (tree_view, cursor_node);
10359     }
10360
10361   y -= tree_view->priv->cursor_offset;
10362   cursor_path = _gtk_tree_view_find_path (tree_view, cursor_tree, cursor_node);
10363
10364   start_cursor_tree = cursor_tree;
10365   start_cursor_node = cursor_node;
10366
10367   if (! search_first_focusable_path (tree_view, &cursor_path,
10368                                      (count != -1),
10369                                      &cursor_tree, &cursor_node))
10370     {
10371       /* It looks like we reached the end of the view without finding
10372        * a focusable row.  We will step backwards to find the last
10373        * focusable row.
10374        */
10375       cursor_tree = start_cursor_tree;
10376       cursor_node = start_cursor_node;
10377       cursor_path = _gtk_tree_view_find_path (tree_view, cursor_tree, cursor_node);
10378
10379       search_first_focusable_path (tree_view, &cursor_path,
10380                                    (count == -1),
10381                                    &cursor_tree, &cursor_node);
10382     }
10383
10384   if (!cursor_path)
10385     goto cleanup;
10386
10387   /* update y */
10388   y = _gtk_rbtree_node_find_offset (cursor_tree, cursor_node);
10389
10390   gtk_tree_view_real_set_cursor (tree_view, cursor_path, TRUE, FALSE);
10391
10392   y -= window_y;
10393   gtk_tree_view_scroll_to_point (tree_view, -1, y);
10394   gtk_tree_view_clamp_node_visible (tree_view, cursor_tree, cursor_node);
10395   _gtk_tree_view_queue_draw_node (tree_view, cursor_tree, cursor_node, NULL);
10396
10397   if (!gtk_tree_path_compare (old_cursor_path, cursor_path))
10398     gtk_widget_error_bell (GTK_WIDGET (tree_view));
10399
10400   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
10401
10402 cleanup:
10403   gtk_tree_path_free (old_cursor_path);
10404   gtk_tree_path_free (cursor_path);
10405 }
10406
10407 static void
10408 gtk_tree_view_move_cursor_left_right (GtkTreeView *tree_view,
10409                                       gint         count)
10410 {
10411   GtkRBTree *cursor_tree = NULL;
10412   GtkRBNode *cursor_node = NULL;
10413   GtkTreePath *cursor_path = NULL;
10414   GtkTreeViewColumn *column;
10415   GtkTreeIter iter;
10416   GList *list;
10417   gboolean found_column = FALSE;
10418   gboolean rtl;
10419   GtkDirectionType direction;
10420   GtkCellArea     *cell_area;
10421   GtkCellRenderer *last_focus_cell = NULL;
10422   GtkCellArea     *last_focus_area = NULL;
10423
10424   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
10425
10426   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10427     return;
10428
10429   if (gtk_tree_row_reference_valid (tree_view->priv->cursor))
10430     cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
10431   else
10432     return;
10433
10434   _gtk_tree_view_find_node (tree_view, cursor_path, &cursor_tree, &cursor_node);
10435   if (cursor_tree == NULL)
10436     return;
10437   if (gtk_tree_model_get_iter (tree_view->priv->model, &iter, cursor_path) == FALSE)
10438     {
10439       gtk_tree_path_free (cursor_path);
10440       return;
10441     }
10442   gtk_tree_path_free (cursor_path);
10443
10444   list = rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns);
10445   if (tree_view->priv->focus_column)
10446     {
10447       /* Save the cell/area we are moving focus from, if moving the cursor
10448        * by one step hits the end we'll set focus back here */
10449       last_focus_area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (tree_view->priv->focus_column));
10450       last_focus_cell = gtk_cell_area_get_focus_cell (last_focus_area);
10451
10452       for (; list; list = (rtl ? list->prev : list->next))
10453         {
10454           if (list->data == tree_view->priv->focus_column)
10455             break;
10456         }
10457     }
10458
10459   direction = count > 0 ? GTK_DIR_RIGHT : GTK_DIR_LEFT;
10460
10461   while (list)
10462     {
10463       column = list->data;
10464       if (gtk_tree_view_column_get_visible (column) == FALSE)
10465         goto loop_end;
10466
10467       gtk_tree_view_column_cell_set_cell_data (column,
10468                                                tree_view->priv->model,
10469                                                &iter,
10470                                                GTK_RBNODE_FLAG_SET (cursor_node, GTK_RBNODE_IS_PARENT),
10471                                                cursor_node->children?TRUE:FALSE);
10472
10473       cell_area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (column));
10474       if (gtk_cell_area_focus (cell_area, direction))
10475         {
10476           tree_view->priv->focus_column = column;
10477           found_column = TRUE;
10478           break;
10479         }
10480
10481     loop_end:
10482       if (count == 1)
10483         list = rtl ? list->prev : list->next;
10484       else
10485         list = rtl ? list->next : list->prev;
10486     }
10487
10488   if (found_column)
10489     {
10490       if (!gtk_tree_view_has_can_focus_cell (tree_view))
10491         _gtk_tree_view_queue_draw_node (tree_view,
10492                                         cursor_tree,
10493                                         cursor_node,
10494                                         NULL);
10495       g_signal_emit (tree_view, tree_view_signals[CURSOR_CHANGED], 0);
10496       gtk_widget_grab_focus (GTK_WIDGET (tree_view));
10497     }
10498   else
10499     {
10500       gtk_widget_error_bell (GTK_WIDGET (tree_view));
10501
10502       if (last_focus_area)
10503         gtk_cell_area_set_focus_cell (last_focus_area, last_focus_cell);
10504     }
10505
10506   gtk_tree_view_clamp_column_visible (tree_view,
10507                                       tree_view->priv->focus_column, TRUE);
10508 }
10509
10510 static void
10511 gtk_tree_view_move_cursor_start_end (GtkTreeView *tree_view,
10512                                      gint         count)
10513 {
10514   GtkRBTree *cursor_tree;
10515   GtkRBNode *cursor_node;
10516   GtkTreePath *path;
10517   GtkTreePath *old_path;
10518
10519   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10520     return;
10521
10522   g_return_if_fail (tree_view->priv->tree != NULL);
10523
10524   gtk_tree_view_get_cursor (tree_view, &old_path, NULL);
10525
10526   cursor_tree = tree_view->priv->tree;
10527   cursor_node = cursor_tree->root;
10528
10529   if (count == -1)
10530     {
10531       while (cursor_node && cursor_node->left != cursor_tree->nil)
10532         cursor_node = cursor_node->left;
10533
10534       /* Now go forward to find the first focusable row. */
10535       path = _gtk_tree_view_find_path (tree_view, cursor_tree, cursor_node);
10536       search_first_focusable_path (tree_view, &path,
10537                                    TRUE, &cursor_tree, &cursor_node);
10538     }
10539   else
10540     {
10541       do
10542         {
10543           while (cursor_node && cursor_node->right != cursor_tree->nil)
10544             cursor_node = cursor_node->right;
10545           if (cursor_node->children == NULL)
10546             break;
10547
10548           cursor_tree = cursor_node->children;
10549           cursor_node = cursor_tree->root;
10550         }
10551       while (1);
10552
10553       /* Now go backwards to find last focusable row. */
10554       path = _gtk_tree_view_find_path (tree_view, cursor_tree, cursor_node);
10555       search_first_focusable_path (tree_view, &path,
10556                                    FALSE, &cursor_tree, &cursor_node);
10557     }
10558
10559   if (!path)
10560     goto cleanup;
10561
10562   if (gtk_tree_path_compare (old_path, path))
10563     {
10564       gtk_tree_view_real_set_cursor (tree_view, path, TRUE, TRUE);
10565       gtk_widget_grab_focus (GTK_WIDGET (tree_view));
10566     }
10567   else
10568     {
10569       gtk_widget_error_bell (GTK_WIDGET (tree_view));
10570     }
10571
10572 cleanup:
10573   gtk_tree_path_free (old_path);
10574   gtk_tree_path_free (path);
10575 }
10576
10577 static gboolean
10578 gtk_tree_view_real_select_all (GtkTreeView *tree_view)
10579 {
10580   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10581     return FALSE;
10582
10583   if (gtk_tree_selection_get_mode (tree_view->priv->selection) != GTK_SELECTION_MULTIPLE)
10584     return FALSE;
10585
10586   gtk_tree_selection_select_all (tree_view->priv->selection);
10587
10588   return TRUE;
10589 }
10590
10591 static gboolean
10592 gtk_tree_view_real_unselect_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_unselect_all (tree_view->priv->selection);
10601
10602   return TRUE;
10603 }
10604
10605 static gboolean
10606 gtk_tree_view_real_select_cursor_row (GtkTreeView *tree_view,
10607                                       gboolean     start_editing)
10608 {
10609   GtkRBTree *new_tree = NULL;
10610   GtkRBNode *new_node = NULL;
10611   GtkRBTree *cursor_tree = NULL;
10612   GtkRBNode *cursor_node = NULL;
10613   GtkTreePath *cursor_path = NULL;
10614   GtkTreeSelectMode mode = 0;
10615
10616   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10617     return FALSE;
10618
10619   if (tree_view->priv->cursor)
10620     cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
10621
10622   if (cursor_path == NULL)
10623     return FALSE;
10624
10625   _gtk_tree_view_find_node (tree_view, cursor_path,
10626                             &cursor_tree, &cursor_node);
10627
10628   if (cursor_tree == NULL)
10629     {
10630       gtk_tree_path_free (cursor_path);
10631       return FALSE;
10632     }
10633
10634   if (!tree_view->priv->extend_selection_pressed && start_editing &&
10635       tree_view->priv->focus_column)
10636     {
10637       if (gtk_tree_view_start_editing (tree_view, cursor_path, FALSE))
10638         {
10639           gtk_tree_path_free (cursor_path);
10640           return TRUE;
10641         }
10642     }
10643
10644   if (tree_view->priv->modify_selection_pressed)
10645     mode |= GTK_TREE_SELECT_MODE_TOGGLE;
10646   if (tree_view->priv->extend_selection_pressed)
10647     mode |= GTK_TREE_SELECT_MODE_EXTEND;
10648
10649   _gtk_tree_selection_internal_select_node (tree_view->priv->selection,
10650                                             cursor_node,
10651                                             cursor_tree,
10652                                             cursor_path,
10653                                             mode,
10654                                             FALSE);
10655
10656   /* We bail out if the original (tree, node) don't exist anymore after
10657    * handling the selection-changed callback.  We do return TRUE because
10658    * the key press has been handled at this point.
10659    */
10660   _gtk_tree_view_find_node (tree_view, cursor_path, &new_tree, &new_node);
10661
10662   if (cursor_tree != new_tree || cursor_node != new_node)
10663     return FALSE;
10664
10665   gtk_tree_view_clamp_node_visible (tree_view, cursor_tree, cursor_node);
10666
10667   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
10668   _gtk_tree_view_queue_draw_node (tree_view, cursor_tree, cursor_node, NULL);
10669
10670   if (!tree_view->priv->extend_selection_pressed)
10671     gtk_tree_view_row_activated (tree_view, cursor_path,
10672                                  tree_view->priv->focus_column);
10673
10674   gtk_tree_path_free (cursor_path);
10675
10676   return TRUE;
10677 }
10678
10679 static gboolean
10680 gtk_tree_view_real_toggle_cursor_row (GtkTreeView *tree_view)
10681 {
10682   GtkRBTree *new_tree = NULL;
10683   GtkRBNode *new_node = NULL;
10684   GtkRBTree *cursor_tree = NULL;
10685   GtkRBNode *cursor_node = NULL;
10686   GtkTreePath *cursor_path = NULL;
10687
10688   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10689     return FALSE;
10690
10691   cursor_path = NULL;
10692   if (tree_view->priv->cursor)
10693     cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
10694
10695   if (cursor_path == NULL)
10696     return FALSE;
10697
10698   _gtk_tree_view_find_node (tree_view, cursor_path,
10699                             &cursor_tree, &cursor_node);
10700   if (cursor_tree == NULL)
10701     {
10702       gtk_tree_path_free (cursor_path);
10703       return FALSE;
10704     }
10705
10706   _gtk_tree_selection_internal_select_node (tree_view->priv->selection,
10707                                             cursor_node,
10708                                             cursor_tree,
10709                                             cursor_path,
10710                                             GTK_TREE_SELECT_MODE_TOGGLE,
10711                                             FALSE);
10712
10713   /* We bail out if the original (tree, node) don't exist anymore after
10714    * handling the selection-changed callback.  We do return TRUE because
10715    * the key press has been handled at this point.
10716    */
10717   _gtk_tree_view_find_node (tree_view, cursor_path, &new_tree, &new_node);
10718
10719   if (cursor_tree != new_tree || cursor_node != new_node)
10720     return FALSE;
10721
10722   gtk_tree_view_clamp_node_visible (tree_view, cursor_tree, cursor_node);
10723
10724   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
10725   gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
10726   gtk_tree_path_free (cursor_path);
10727
10728   return TRUE;
10729 }
10730
10731 static gboolean
10732 gtk_tree_view_real_expand_collapse_cursor_row (GtkTreeView *tree_view,
10733                                                gboolean     logical,
10734                                                gboolean     expand,
10735                                                gboolean     open_all)
10736 {
10737   GtkTreePath *cursor_path = NULL;
10738   GtkRBTree *tree;
10739   GtkRBNode *node;
10740
10741   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10742     return FALSE;
10743
10744   cursor_path = NULL;
10745   if (tree_view->priv->cursor)
10746     cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
10747
10748   if (cursor_path == NULL)
10749     return FALSE;
10750
10751   if (_gtk_tree_view_find_node (tree_view, cursor_path, &tree, &node))
10752     return FALSE;
10753
10754   /* Don't handle the event if we aren't an expander */
10755   if (!((node->flags & GTK_RBNODE_IS_PARENT) == GTK_RBNODE_IS_PARENT))
10756     return FALSE;
10757
10758   if (!logical
10759       && gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL)
10760     expand = !expand;
10761
10762   if (expand)
10763     gtk_tree_view_real_expand_row (tree_view, cursor_path, tree, node, open_all, TRUE);
10764   else
10765     gtk_tree_view_real_collapse_row (tree_view, cursor_path, tree, node, TRUE);
10766
10767   gtk_tree_path_free (cursor_path);
10768
10769   return TRUE;
10770 }
10771
10772 static gboolean
10773 gtk_tree_view_real_select_cursor_parent (GtkTreeView *tree_view)
10774 {
10775   GtkRBTree *cursor_tree = NULL;
10776   GtkRBNode *cursor_node = NULL;
10777   GtkTreePath *cursor_path = NULL;
10778   GdkModifierType state;
10779
10780   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10781     goto out;
10782
10783   cursor_path = NULL;
10784   if (tree_view->priv->cursor)
10785     cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
10786
10787   if (cursor_path == NULL)
10788     goto out;
10789
10790   _gtk_tree_view_find_node (tree_view, cursor_path,
10791                             &cursor_tree, &cursor_node);
10792   if (cursor_tree == NULL)
10793     {
10794       gtk_tree_path_free (cursor_path);
10795       goto out;
10796     }
10797
10798   if (cursor_tree->parent_node)
10799     {
10800       gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
10801       cursor_node = cursor_tree->parent_node;
10802       cursor_tree = cursor_tree->parent_tree;
10803
10804       gtk_tree_path_up (cursor_path);
10805
10806       if (gtk_get_current_event_state (&state))
10807         {
10808           GdkModifierType modify_mod_mask;
10809
10810           modify_mod_mask =
10811             gtk_widget_get_modifier_mask (GTK_WIDGET (tree_view),
10812                                           GDK_MODIFIER_INTENT_MODIFY_SELECTION);
10813
10814           if ((state & modify_mod_mask) == modify_mod_mask)
10815             tree_view->priv->modify_selection_pressed = TRUE;
10816         }
10817
10818       gtk_tree_view_real_set_cursor (tree_view, cursor_path, TRUE, FALSE);
10819       gtk_tree_view_clamp_node_visible (tree_view, cursor_tree, cursor_node);
10820
10821       gtk_widget_grab_focus (GTK_WIDGET (tree_view));
10822       gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
10823       gtk_tree_path_free (cursor_path);
10824
10825       tree_view->priv->modify_selection_pressed = FALSE;
10826
10827       return TRUE;
10828     }
10829
10830  out:
10831
10832   tree_view->priv->search_entry_avoid_unhandled_binding = TRUE;
10833   return FALSE;
10834 }
10835
10836 static gboolean
10837 gtk_tree_view_search_entry_flush_timeout (GtkTreeView *tree_view)
10838 {
10839   gtk_tree_view_search_dialog_hide (tree_view->priv->search_window, tree_view, NULL);
10840   tree_view->priv->typeselect_flush_timeout = 0;
10841
10842   return FALSE;
10843 }
10844
10845 /* Cut and paste from gtkwindow.c */
10846 static void
10847 send_focus_change (GtkWidget *widget,
10848                    GdkDevice *device,
10849                    gboolean   in)
10850 {
10851   GdkDeviceManager *device_manager;
10852   GList *devices, *d;
10853
10854   device_manager = gdk_display_get_device_manager (gtk_widget_get_display (widget));
10855   devices = gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_MASTER);
10856   devices = g_list_concat (devices, gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_SLAVE));
10857   devices = g_list_concat (devices, gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_FLOATING));
10858
10859   for (d = devices; d; d = d->next)
10860     {
10861       GdkDevice *dev = d->data;
10862       GdkEvent *fevent;
10863       GdkWindow *window;
10864
10865       if (gdk_device_get_source (dev) != GDK_SOURCE_KEYBOARD)
10866         continue;
10867
10868       window = gtk_widget_get_window (widget);
10869
10870       /* Skip non-master keyboards that haven't
10871        * selected for events from this window
10872        */
10873       if (gdk_device_get_device_type (dev) != GDK_DEVICE_TYPE_MASTER &&
10874           !gdk_window_get_device_events (window, dev))
10875         continue;
10876
10877       fevent = gdk_event_new (GDK_FOCUS_CHANGE);
10878
10879       fevent->focus_change.type = GDK_FOCUS_CHANGE;
10880       fevent->focus_change.window = g_object_ref (window);
10881       fevent->focus_change.in = in;
10882       gdk_event_set_device (fevent, device);
10883
10884       gtk_widget_send_focus_change (widget, fevent);
10885
10886       gdk_event_free (fevent);
10887     }
10888
10889   g_list_free (devices);
10890 }
10891
10892 static void
10893 gtk_tree_view_ensure_interactive_directory (GtkTreeView *tree_view)
10894 {
10895   GtkWidget *frame, *vbox, *toplevel;
10896   GdkScreen *screen;
10897
10898   if (tree_view->priv->search_custom_entry_set)
10899     return;
10900
10901   toplevel = gtk_widget_get_toplevel (GTK_WIDGET (tree_view));
10902   screen = gtk_widget_get_screen (GTK_WIDGET (tree_view));
10903
10904    if (tree_view->priv->search_window != NULL)
10905      {
10906        if (gtk_window_has_group (GTK_WINDOW (toplevel)))
10907          gtk_window_group_add_window (gtk_window_get_group (GTK_WINDOW (toplevel)),
10908                                       GTK_WINDOW (tree_view->priv->search_window));
10909        else if (gtk_window_has_group (GTK_WINDOW (tree_view->priv->search_window)))
10910          gtk_window_group_remove_window (gtk_window_get_group (GTK_WINDOW (tree_view->priv->search_window)),
10911                                          GTK_WINDOW (tree_view->priv->search_window));
10912
10913        gtk_window_set_screen (GTK_WINDOW (tree_view->priv->search_window), screen);
10914
10915        return;
10916      }
10917
10918   tree_view->priv->search_window = gtk_window_new (GTK_WINDOW_POPUP);
10919   gtk_window_set_screen (GTK_WINDOW (tree_view->priv->search_window), screen);
10920
10921   if (gtk_window_has_group (GTK_WINDOW (toplevel)))
10922     gtk_window_group_add_window (gtk_window_get_group (GTK_WINDOW (toplevel)),
10923                                  GTK_WINDOW (tree_view->priv->search_window));
10924
10925   gtk_window_set_type_hint (GTK_WINDOW (tree_view->priv->search_window),
10926                             GDK_WINDOW_TYPE_HINT_UTILITY);
10927   gtk_window_set_modal (GTK_WINDOW (tree_view->priv->search_window), TRUE);
10928   g_signal_connect (tree_view->priv->search_window, "delete-event",
10929                     G_CALLBACK (gtk_tree_view_search_delete_event),
10930                     tree_view);
10931   g_signal_connect (tree_view->priv->search_window, "key-press-event",
10932                     G_CALLBACK (gtk_tree_view_search_key_press_event),
10933                     tree_view);
10934   g_signal_connect (tree_view->priv->search_window, "button-press-event",
10935                     G_CALLBACK (gtk_tree_view_search_button_press_event),
10936                     tree_view);
10937   g_signal_connect (tree_view->priv->search_window, "scroll-event",
10938                     G_CALLBACK (gtk_tree_view_search_scroll_event),
10939                     tree_view);
10940
10941   frame = gtk_frame_new (NULL);
10942   gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
10943   gtk_widget_show (frame);
10944   gtk_container_add (GTK_CONTAINER (tree_view->priv->search_window), frame);
10945
10946   vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
10947   gtk_widget_show (vbox);
10948   gtk_container_add (GTK_CONTAINER (frame), vbox);
10949   gtk_container_set_border_width (GTK_CONTAINER (vbox), 3);
10950
10951   /* add entry */
10952   tree_view->priv->search_entry = gtk_entry_new ();
10953   gtk_widget_show (tree_view->priv->search_entry);
10954   g_signal_connect (tree_view->priv->search_entry, "populate-popup",
10955                     G_CALLBACK (gtk_tree_view_search_disable_popdown),
10956                     tree_view);
10957   g_signal_connect (tree_view->priv->search_entry,
10958                     "activate", G_CALLBACK (gtk_tree_view_search_activate),
10959                     tree_view);
10960
10961   g_signal_connect (_gtk_entry_get_im_context (GTK_ENTRY (tree_view->priv->search_entry)),
10962                     "preedit-changed",
10963                     G_CALLBACK (gtk_tree_view_search_preedit_changed),
10964                     tree_view);
10965
10966   gtk_container_add (GTK_CONTAINER (vbox),
10967                      tree_view->priv->search_entry);
10968
10969   gtk_widget_realize (tree_view->priv->search_entry);
10970 }
10971
10972 /* Pops up the interactive search entry.  If keybinding is TRUE then the user
10973  * started this by typing the start_interactive_search keybinding.  Otherwise, it came from
10974  */
10975 static gboolean
10976 gtk_tree_view_real_start_interactive_search (GtkTreeView *tree_view,
10977                                              GdkDevice   *device,
10978                                              gboolean     keybinding)
10979 {
10980   /* We only start interactive search if we have focus or the columns
10981    * have focus.  If one of our children have focus, we don't want to
10982    * start the search.
10983    */
10984   GList *list;
10985   gboolean found_focus = FALSE;
10986   GtkWidgetClass *entry_parent_class;
10987
10988   if (!tree_view->priv->enable_search && !keybinding)
10989     return FALSE;
10990
10991   if (tree_view->priv->search_custom_entry_set)
10992     return FALSE;
10993
10994   if (tree_view->priv->search_window != NULL &&
10995       gtk_widget_get_visible (tree_view->priv->search_window))
10996     return TRUE;
10997
10998   for (list = tree_view->priv->columns; list; list = list->next)
10999     {
11000       GtkTreeViewColumn *column;
11001       GtkWidget         *button;
11002
11003       column = list->data;
11004       if (!gtk_tree_view_column_get_visible (column))
11005         continue;
11006
11007       button = gtk_tree_view_column_get_button (column);
11008       if (gtk_widget_has_focus (button))
11009         {
11010           found_focus = TRUE;
11011           break;
11012         }
11013     }
11014
11015   if (gtk_widget_has_focus (GTK_WIDGET (tree_view)))
11016     found_focus = TRUE;
11017
11018   if (!found_focus)
11019     return FALSE;
11020
11021   if (tree_view->priv->search_column < 0)
11022     return FALSE;
11023
11024   gtk_tree_view_ensure_interactive_directory (tree_view);
11025
11026   if (keybinding)
11027     gtk_entry_set_text (GTK_ENTRY (tree_view->priv->search_entry), "");
11028
11029   /* done, show it */
11030   tree_view->priv->search_position_func (tree_view, tree_view->priv->search_window, tree_view->priv->search_position_user_data);
11031   gtk_widget_show (tree_view->priv->search_window);
11032   if (tree_view->priv->search_entry_changed_id == 0)
11033     {
11034       tree_view->priv->search_entry_changed_id =
11035         g_signal_connect (tree_view->priv->search_entry, "changed",
11036                           G_CALLBACK (gtk_tree_view_search_init),
11037                           tree_view);
11038     }
11039
11040   tree_view->priv->typeselect_flush_timeout =
11041     gdk_threads_add_timeout (GTK_TREE_VIEW_SEARCH_DIALOG_TIMEOUT,
11042                    (GSourceFunc) gtk_tree_view_search_entry_flush_timeout,
11043                    tree_view);
11044
11045   /* Grab focus will select all the text.  We don't want that to happen, so we
11046    * call the parent instance and bypass the selection change.  This is probably
11047    * really non-kosher. */
11048   entry_parent_class = g_type_class_peek_parent (GTK_ENTRY_GET_CLASS (tree_view->priv->search_entry));
11049   (entry_parent_class->grab_focus) (tree_view->priv->search_entry);
11050
11051   /* send focus-in event */
11052   send_focus_change (tree_view->priv->search_entry, device, TRUE);
11053
11054   /* search first matching iter */
11055   gtk_tree_view_search_init (tree_view->priv->search_entry, tree_view);
11056
11057   return TRUE;
11058 }
11059
11060 static gboolean
11061 gtk_tree_view_start_interactive_search (GtkTreeView *tree_view)
11062 {
11063   return gtk_tree_view_real_start_interactive_search (tree_view,
11064                                                       gtk_get_current_event_device (),
11065                                                       TRUE);
11066 }
11067
11068 /* this function returns the new width of the column being resized given
11069  * the column and x position of the cursor; the x cursor position is passed
11070  * in as a pointer and automagicly corrected if it's beyond min/max limits
11071  */
11072 static gint
11073 gtk_tree_view_new_column_width (GtkTreeView *tree_view,
11074                                 gint       i,
11075                                 gint      *x)
11076 {
11077   GtkAllocation allocation;
11078   GtkTreeViewColumn *column;
11079   GtkRequisition button_req;
11080   gint max_width, min_width;
11081   gint width;
11082   gboolean rtl;
11083
11084   /* first translate the x position from widget->window
11085    * to clist->clist_window
11086    */
11087   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
11088   column = g_list_nth (tree_view->priv->columns, i)->data;
11089   gtk_widget_get_allocation (gtk_tree_view_column_get_button (column), &allocation);
11090   width = rtl ? (allocation.x + allocation.width - *x) : (*x - allocation.x);
11091
11092   /* Clamp down the value */
11093   min_width = gtk_tree_view_column_get_min_width (column);
11094   if (min_width == -1)
11095     {
11096       gtk_widget_get_preferred_size (gtk_tree_view_column_get_button (column), &button_req, NULL);
11097       width = MAX (button_req.width, width);
11098     }
11099   else
11100     width = MAX (min_width, width);
11101
11102   max_width = gtk_tree_view_column_get_max_width (column);
11103   if (max_width != -1)
11104     width = MIN (width, max_width);
11105
11106   *x = rtl ? (allocation.x + allocation.width - width) : (allocation.x + width);
11107
11108   return width;
11109 }
11110
11111
11112 /* FIXME this adjust_allocation is a big cut-and-paste from
11113  * GtkCList, needs to be some "official" way to do this
11114  * factored out.
11115  */
11116 typedef struct
11117 {
11118   GdkWindow *window;
11119   int dx;
11120   int dy;
11121 } ScrollData;
11122
11123 /* The window to which widget->window is relative */
11124 #define ALLOCATION_WINDOW(widget)               \
11125    (!gtk_widget_get_has_window (widget) ?                   \
11126     gtk_widget_get_window (widget) :                        \
11127     gdk_window_get_parent (gtk_widget_get_window (widget)))
11128
11129 static void
11130 adjust_allocation_recurse (GtkWidget *widget,
11131                            gpointer   data)
11132 {
11133   GtkAllocation allocation;
11134   ScrollData *scroll_data = data;
11135
11136   /* Need to really size allocate instead of just poking
11137    * into widget->allocation if the widget is not realized.
11138    * FIXME someone figure out why this was.
11139    */
11140   gtk_widget_get_allocation (widget, &allocation);
11141   if (!gtk_widget_get_realized (widget))
11142     {
11143       if (gtk_widget_get_visible (widget))
11144         {
11145           GdkRectangle tmp_rectangle = allocation;
11146           tmp_rectangle.x += scroll_data->dx;
11147           tmp_rectangle.y += scroll_data->dy;
11148
11149           gtk_widget_size_allocate (widget, &tmp_rectangle);
11150         }
11151     }
11152   else
11153     {
11154       if (ALLOCATION_WINDOW (widget) == scroll_data->window)
11155         {
11156           allocation.x += scroll_data->dx;
11157           allocation.y += scroll_data->dy;
11158           gtk_widget_set_allocation (widget, &allocation);
11159
11160           if (GTK_IS_CONTAINER (widget))
11161             gtk_container_forall (GTK_CONTAINER (widget),
11162                                   adjust_allocation_recurse,
11163                                   data);
11164         }
11165     }
11166 }
11167
11168 static void
11169 adjust_allocation (GtkWidget *widget,
11170                    int        dx,
11171                    int        dy)
11172 {
11173   ScrollData scroll_data;
11174
11175   if (gtk_widget_get_realized (widget))
11176     scroll_data.window = ALLOCATION_WINDOW (widget);
11177   else
11178     scroll_data.window = NULL;
11179
11180   scroll_data.dx = dx;
11181   scroll_data.dy = dy;
11182
11183   adjust_allocation_recurse (widget, &scroll_data);
11184 }
11185
11186 /* Callbacks */
11187 static void
11188 gtk_tree_view_adjustment_changed (GtkAdjustment *adjustment,
11189                                   GtkTreeView   *tree_view)
11190 {
11191   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
11192     {
11193       GtkStyleContext *context;
11194       gint dy;
11195
11196       gdk_window_move (tree_view->priv->bin_window,
11197                        - gtk_adjustment_get_value (tree_view->priv->hadjustment),
11198                        gtk_tree_view_get_effective_header_height (tree_view));
11199       gdk_window_move (tree_view->priv->header_window,
11200                        - gtk_adjustment_get_value (tree_view->priv->hadjustment),
11201                        0);
11202       dy = tree_view->priv->dy - (int) gtk_adjustment_get_value (tree_view->priv->vadjustment);
11203       if (dy)
11204         {
11205           update_prelight (tree_view,
11206                            tree_view->priv->event_last_x,
11207                            tree_view->priv->event_last_y - dy);
11208
11209           if (tree_view->priv->edited_column)
11210             {
11211               GList *list;
11212               GtkTreeViewChild *child = NULL;
11213               GtkCellEditable *edit_widget;
11214               GtkCellArea *area;
11215
11216               area        = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (tree_view->priv->edited_column));
11217               edit_widget = gtk_cell_area_get_edit_widget (area);
11218               if (GTK_IS_WIDGET (edit_widget))
11219                 {
11220                   adjust_allocation (GTK_WIDGET (edit_widget), 0, dy);
11221
11222                   for (list = tree_view->priv->children; list; list = list->next)
11223                     {
11224                       child = (GtkTreeViewChild *)list->data;
11225                       if (child->widget == GTK_WIDGET (edit_widget))
11226                         {
11227                           child->y += dy;
11228                           break;
11229                         }
11230                     }
11231                 }
11232             }
11233         }
11234       gdk_window_scroll (tree_view->priv->bin_window, 0, dy);
11235
11236       context = gtk_widget_get_style_context (GTK_WIDGET (tree_view));
11237       gtk_style_context_scroll_animations (context, tree_view->priv->bin_window, 0, dy);
11238
11239       if (tree_view->priv->dy != (int) gtk_adjustment_get_value (tree_view->priv->vadjustment))
11240         {
11241           /* update our dy and top_row */
11242           tree_view->priv->dy = (int) gtk_adjustment_get_value (tree_view->priv->vadjustment);
11243
11244           if (!tree_view->priv->in_top_row_to_dy)
11245             gtk_tree_view_dy_to_top_row (tree_view);
11246         }
11247
11248       gdk_window_process_updates (tree_view->priv->header_window, TRUE);
11249       gtk_tree_view_bin_process_updates (tree_view);
11250     }
11251 }
11252
11253 \f
11254
11255 /* Public methods
11256  */
11257
11258 /**
11259  * gtk_tree_view_new:
11260  *
11261  * Creates a new #GtkTreeView widget.
11262  *
11263  * Return value: A newly created #GtkTreeView widget.
11264  **/
11265 GtkWidget *
11266 gtk_tree_view_new (void)
11267 {
11268   return g_object_new (GTK_TYPE_TREE_VIEW, NULL);
11269 }
11270
11271 /**
11272  * gtk_tree_view_new_with_model:
11273  * @model: the model.
11274  *
11275  * Creates a new #GtkTreeView widget with the model initialized to @model.
11276  *
11277  * Return value: A newly created #GtkTreeView widget.
11278  **/
11279 GtkWidget *
11280 gtk_tree_view_new_with_model (GtkTreeModel *model)
11281 {
11282   return g_object_new (GTK_TYPE_TREE_VIEW, "model", model, NULL);
11283 }
11284
11285 /* Public Accessors
11286  */
11287
11288 /**
11289  * gtk_tree_view_get_model:
11290  * @tree_view: a #GtkTreeView
11291  *
11292  * Returns the model the #GtkTreeView is based on.  Returns %NULL if the
11293  * model is unset.
11294  *
11295  * Return value: (transfer none): A #GtkTreeModel, or %NULL if none is currently being used.
11296  **/
11297 GtkTreeModel *
11298 gtk_tree_view_get_model (GtkTreeView *tree_view)
11299 {
11300   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
11301
11302   return tree_view->priv->model;
11303 }
11304
11305 /**
11306  * gtk_tree_view_set_model:
11307  * @tree_view: A #GtkTreeNode.
11308  * @model: (allow-none): The model.
11309  *
11310  * Sets the model for a #GtkTreeView.  If the @tree_view already has a model
11311  * set, it will remove it before setting the new model.  If @model is %NULL,
11312  * then it will unset the old model.
11313  **/
11314 void
11315 gtk_tree_view_set_model (GtkTreeView  *tree_view,
11316                          GtkTreeModel *model)
11317 {
11318   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11319   g_return_if_fail (model == NULL || GTK_IS_TREE_MODEL (model));
11320
11321   if (model == tree_view->priv->model)
11322     return;
11323
11324   if (tree_view->priv->scroll_to_path)
11325     {
11326       gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
11327       tree_view->priv->scroll_to_path = NULL;
11328     }
11329
11330   if (tree_view->priv->model)
11331     {
11332       GList *tmplist = tree_view->priv->columns;
11333       GtkStyleContext *context;
11334
11335       gtk_tree_view_unref_and_check_selection_tree (tree_view, tree_view->priv->tree);
11336       gtk_tree_view_stop_editing (tree_view, TRUE);
11337
11338       context = gtk_widget_get_style_context (GTK_WIDGET (tree_view));
11339       gtk_style_context_cancel_animations (context, NULL);
11340
11341       g_signal_handlers_disconnect_by_func (tree_view->priv->model,
11342                                             gtk_tree_view_row_changed,
11343                                             tree_view);
11344       g_signal_handlers_disconnect_by_func (tree_view->priv->model,
11345                                             gtk_tree_view_row_inserted,
11346                                             tree_view);
11347       g_signal_handlers_disconnect_by_func (tree_view->priv->model,
11348                                             gtk_tree_view_row_has_child_toggled,
11349                                             tree_view);
11350       g_signal_handlers_disconnect_by_func (tree_view->priv->model,
11351                                             gtk_tree_view_row_deleted,
11352                                             tree_view);
11353       g_signal_handlers_disconnect_by_func (tree_view->priv->model,
11354                                             gtk_tree_view_rows_reordered,
11355                                             tree_view);
11356
11357       for (; tmplist; tmplist = tmplist->next)
11358         _gtk_tree_view_column_unset_model (tmplist->data,
11359                                            tree_view->priv->model);
11360
11361       if (tree_view->priv->tree)
11362         gtk_tree_view_free_rbtree (tree_view);
11363
11364       gtk_tree_row_reference_free (tree_view->priv->drag_dest_row);
11365       tree_view->priv->drag_dest_row = NULL;
11366       gtk_tree_row_reference_free (tree_view->priv->cursor);
11367       tree_view->priv->cursor = NULL;
11368       gtk_tree_row_reference_free (tree_view->priv->anchor);
11369       tree_view->priv->anchor = NULL;
11370       gtk_tree_row_reference_free (tree_view->priv->top_row);
11371       tree_view->priv->top_row = NULL;
11372       gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
11373       tree_view->priv->scroll_to_path = NULL;
11374
11375       tree_view->priv->scroll_to_column = NULL;
11376
11377       g_object_unref (tree_view->priv->model);
11378
11379       tree_view->priv->search_column = -1;
11380       tree_view->priv->fixed_height_check = 0;
11381       tree_view->priv->fixed_height = -1;
11382       tree_view->priv->dy = tree_view->priv->top_row_dy = 0;
11383       tree_view->priv->last_button_x = -1;
11384       tree_view->priv->last_button_y = -1;
11385     }
11386
11387   tree_view->priv->model = model;
11388
11389   if (tree_view->priv->model)
11390     {
11391       gint i;
11392       GtkTreePath *path;
11393       GtkTreeIter iter;
11394       GtkTreeModelFlags flags;
11395
11396       if (tree_view->priv->search_column == -1)
11397         {
11398           for (i = 0; i < gtk_tree_model_get_n_columns (model); i++)
11399             {
11400               GType type = gtk_tree_model_get_column_type (model, i);
11401
11402               if (g_value_type_transformable (type, G_TYPE_STRING))
11403                 {
11404                   tree_view->priv->search_column = i;
11405                   break;
11406                 }
11407             }
11408         }
11409
11410       g_object_ref (tree_view->priv->model);
11411       g_signal_connect (tree_view->priv->model,
11412                         "row-changed",
11413                         G_CALLBACK (gtk_tree_view_row_changed),
11414                         tree_view);
11415       g_signal_connect (tree_view->priv->model,
11416                         "row-inserted",
11417                         G_CALLBACK (gtk_tree_view_row_inserted),
11418                         tree_view);
11419       g_signal_connect (tree_view->priv->model,
11420                         "row-has-child-toggled",
11421                         G_CALLBACK (gtk_tree_view_row_has_child_toggled),
11422                         tree_view);
11423       g_signal_connect (tree_view->priv->model,
11424                         "row-deleted",
11425                         G_CALLBACK (gtk_tree_view_row_deleted),
11426                         tree_view);
11427       g_signal_connect (tree_view->priv->model,
11428                         "rows-reordered",
11429                         G_CALLBACK (gtk_tree_view_rows_reordered),
11430                         tree_view);
11431
11432       flags = gtk_tree_model_get_flags (tree_view->priv->model);
11433       if ((flags & GTK_TREE_MODEL_LIST_ONLY) == GTK_TREE_MODEL_LIST_ONLY)
11434         tree_view->priv->is_list = TRUE;
11435       else
11436         tree_view->priv->is_list = FALSE;
11437
11438       path = gtk_tree_path_new_first ();
11439       if (gtk_tree_model_get_iter (tree_view->priv->model, &iter, path))
11440         {
11441           tree_view->priv->tree = _gtk_rbtree_new ();
11442           gtk_tree_view_build_tree (tree_view, tree_view->priv->tree, &iter, 1, FALSE);
11443         }
11444       gtk_tree_path_free (path);
11445
11446       /*  FIXME: do I need to do this? gtk_tree_view_create_buttons (tree_view); */
11447       install_presize_handler (tree_view);
11448     }
11449
11450   g_object_notify (G_OBJECT (tree_view), "model");
11451
11452   if (tree_view->priv->selection)
11453   _gtk_tree_selection_emit_changed (tree_view->priv->selection);
11454
11455   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
11456     gtk_widget_queue_resize (GTK_WIDGET (tree_view));
11457 }
11458
11459 /**
11460  * gtk_tree_view_get_selection:
11461  * @tree_view: A #GtkTreeView.
11462  *
11463  * Gets the #GtkTreeSelection associated with @tree_view.
11464  *
11465  * Return value: (transfer none): A #GtkTreeSelection object.
11466  **/
11467 GtkTreeSelection *
11468 gtk_tree_view_get_selection (GtkTreeView *tree_view)
11469 {
11470   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
11471
11472   return tree_view->priv->selection;
11473 }
11474
11475 /**
11476  * gtk_tree_view_get_hadjustment:
11477  * @tree_view: A #GtkTreeView
11478  *
11479  * Gets the #GtkAdjustment currently being used for the horizontal aspect.
11480  *
11481  * Return value: (transfer none): A #GtkAdjustment object, or %NULL
11482  *     if none is currently being used.
11483  *
11484  * Deprecated: 3.0: Use gtk_scrollable_get_hadjustment()
11485  **/
11486 GtkAdjustment *
11487 gtk_tree_view_get_hadjustment (GtkTreeView *tree_view)
11488 {
11489   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
11490
11491   return tree_view->priv->hadjustment;
11492 }
11493
11494 /**
11495  * gtk_tree_view_set_hadjustment:
11496  * @tree_view: A #GtkTreeView
11497  * @adjustment: (allow-none): The #GtkAdjustment to set, or %NULL
11498  *
11499  * Sets the #GtkAdjustment for the current horizontal aspect.
11500  *
11501  * Deprecated: 3.0: Use gtk_scrollable_set_hadjustment()
11502  **/
11503 void
11504 gtk_tree_view_set_hadjustment (GtkTreeView   *tree_view,
11505                                GtkAdjustment *adjustment)
11506 {
11507   GtkTreeViewPrivate *priv = tree_view->priv;
11508
11509   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11510   g_return_if_fail (adjustment == NULL || GTK_IS_ADJUSTMENT (adjustment));
11511
11512   if (adjustment && priv->hadjustment == adjustment)
11513     return;
11514
11515   if (priv->hadjustment != NULL)
11516     {
11517       g_signal_handlers_disconnect_by_func (priv->hadjustment,
11518                                             gtk_tree_view_adjustment_changed,
11519                                             tree_view);
11520       g_object_unref (priv->hadjustment);
11521     }
11522
11523   if (adjustment == NULL)
11524     adjustment = gtk_adjustment_new (0.0, 0.0, 0.0,
11525                                      0.0, 0.0, 0.0);
11526
11527   g_signal_connect (adjustment, "value-changed",
11528                     G_CALLBACK (gtk_tree_view_adjustment_changed), tree_view);
11529   priv->hadjustment = g_object_ref_sink (adjustment);
11530   /* FIXME: Adjustment should probably be populated here with fresh values, but
11531    * internal details are too complicated for me to decipher right now.
11532    */
11533   gtk_tree_view_adjustment_changed (NULL, tree_view);
11534
11535   g_object_notify (G_OBJECT (tree_view), "hadjustment");
11536 }
11537
11538 /**
11539  * gtk_tree_view_get_vadjustment:
11540  * @tree_view: A #GtkTreeView
11541  *
11542  * Gets the #GtkAdjustment currently being used for the vertical aspect.
11543  *
11544  * Return value: (transfer none): A #GtkAdjustment object, or %NULL
11545  *     if none is currently being used.
11546  *
11547  * Deprecated: 3.0: Use gtk_scrollable_get_vadjustment()
11548  **/
11549 GtkAdjustment *
11550 gtk_tree_view_get_vadjustment (GtkTreeView *tree_view)
11551 {
11552   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
11553
11554   return tree_view->priv->vadjustment;
11555 }
11556
11557 /**
11558  * gtk_tree_view_set_vadjustment:
11559  * @tree_view: A #GtkTreeView
11560  * @adjustment: (allow-none): The #GtkAdjustment to set, or %NULL
11561  *
11562  * Sets the #GtkAdjustment for the current vertical aspect.
11563  *
11564  * Deprecated: 3.0: Use gtk_scrollable_set_vadjustment()
11565  **/
11566 void
11567 gtk_tree_view_set_vadjustment (GtkTreeView   *tree_view,
11568                                GtkAdjustment *adjustment)
11569 {
11570   GtkTreeViewPrivate *priv = tree_view->priv;
11571
11572   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11573   g_return_if_fail (adjustment == NULL || GTK_IS_ADJUSTMENT (adjustment));
11574
11575   if (adjustment && priv->vadjustment == adjustment)
11576     return;
11577
11578   if (priv->vadjustment != NULL)
11579     {
11580       g_signal_handlers_disconnect_by_func (priv->vadjustment,
11581                                             gtk_tree_view_adjustment_changed,
11582                                             tree_view);
11583       g_object_unref (priv->vadjustment);
11584     }
11585
11586   if (adjustment == NULL)
11587     adjustment = gtk_adjustment_new (0.0, 0.0, 0.0,
11588                                      0.0, 0.0, 0.0);
11589
11590   g_signal_connect (adjustment, "value-changed",
11591                     G_CALLBACK (gtk_tree_view_adjustment_changed), tree_view);
11592   priv->vadjustment = g_object_ref_sink (adjustment);
11593   /* FIXME: Adjustment should probably be populated here with fresh values, but
11594    * internal details are too complicated for me to decipher right now.
11595    */
11596   gtk_tree_view_adjustment_changed (NULL, tree_view);
11597   g_object_notify (G_OBJECT (tree_view), "vadjustment");
11598 }
11599
11600 /* Column and header operations */
11601
11602 /**
11603  * gtk_tree_view_get_headers_visible:
11604  * @tree_view: A #GtkTreeView.
11605  *
11606  * Returns %TRUE if the headers on the @tree_view are visible.
11607  *
11608  * Return value: Whether the headers are visible or not.
11609  **/
11610 gboolean
11611 gtk_tree_view_get_headers_visible (GtkTreeView *tree_view)
11612 {
11613   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
11614
11615   return tree_view->priv->headers_visible;
11616 }
11617
11618 /**
11619  * gtk_tree_view_set_headers_visible:
11620  * @tree_view: A #GtkTreeView.
11621  * @headers_visible: %TRUE if the headers are visible
11622  *
11623  * Sets the visibility state of the headers.
11624  **/
11625 void
11626 gtk_tree_view_set_headers_visible (GtkTreeView *tree_view,
11627                                    gboolean     headers_visible)
11628 {
11629   gint x, y;
11630   GList *list;
11631   GtkTreeViewColumn *column;
11632   GtkAllocation allocation;
11633   GtkWidget *button;
11634
11635   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11636
11637   headers_visible = !! headers_visible;
11638
11639   if (tree_view->priv->headers_visible == headers_visible)
11640     return;
11641
11642   tree_view->priv->headers_visible = headers_visible == TRUE;
11643
11644   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
11645     {
11646       gdk_window_get_position (tree_view->priv->bin_window, &x, &y);
11647       if (headers_visible)
11648         {
11649           gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
11650           gdk_window_move_resize (tree_view->priv->bin_window,
11651                                   x, y  + gtk_tree_view_get_effective_header_height (tree_view),
11652                                   tree_view->priv->width, allocation.height -  + gtk_tree_view_get_effective_header_height (tree_view));
11653
11654           if (gtk_widget_get_mapped (GTK_WIDGET (tree_view)))
11655             gtk_tree_view_map_buttons (tree_view);
11656         }
11657       else
11658         {
11659           gdk_window_move_resize (tree_view->priv->bin_window, x, y, tree_view->priv->width, tree_view->priv->height);
11660
11661           for (list = tree_view->priv->columns; list; list = list->next)
11662             {
11663               column = list->data;
11664               button = gtk_tree_view_column_get_button (column);
11665
11666               gtk_widget_hide (button);
11667               gtk_widget_unmap (button);
11668             }
11669           gdk_window_hide (tree_view->priv->header_window);
11670         }
11671     }
11672
11673   gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
11674   gtk_adjustment_configure (tree_view->priv->vadjustment,
11675                             gtk_adjustment_get_value (tree_view->priv->vadjustment),
11676                             0,
11677                             tree_view->priv->height,
11678                             gtk_adjustment_get_step_increment (tree_view->priv->vadjustment),
11679                             (allocation.height - gtk_tree_view_get_effective_header_height (tree_view)) / 2,
11680                             allocation.height - gtk_tree_view_get_effective_header_height (tree_view));
11681
11682   gtk_widget_queue_resize (GTK_WIDGET (tree_view));
11683
11684   g_object_notify (G_OBJECT (tree_view), "headers-visible");
11685 }
11686
11687 /**
11688  * gtk_tree_view_columns_autosize:
11689  * @tree_view: A #GtkTreeView.
11690  *
11691  * Resizes all columns to their optimal width. Only works after the
11692  * treeview has been realized.
11693  **/
11694 void
11695 gtk_tree_view_columns_autosize (GtkTreeView *tree_view)
11696 {
11697   gboolean dirty = FALSE;
11698   GList *list;
11699   GtkTreeViewColumn *column;
11700
11701   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11702
11703   for (list = tree_view->priv->columns; list; list = list->next)
11704     {
11705       column = list->data;
11706       if (gtk_tree_view_column_get_sizing (column) == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
11707         continue;
11708       _gtk_tree_view_column_cell_set_dirty (column, TRUE);
11709       dirty = TRUE;
11710     }
11711
11712   if (dirty)
11713     gtk_widget_queue_resize (GTK_WIDGET (tree_view));
11714 }
11715
11716 /**
11717  * gtk_tree_view_set_headers_clickable:
11718  * @tree_view: A #GtkTreeView.
11719  * @setting: %TRUE if the columns are clickable.
11720  *
11721  * Allow the column title buttons to be clicked.
11722  **/
11723 void
11724 gtk_tree_view_set_headers_clickable (GtkTreeView *tree_view,
11725                                      gboolean   setting)
11726 {
11727   GList *list;
11728
11729   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11730
11731   for (list = tree_view->priv->columns; list; list = list->next)
11732     gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (list->data), setting);
11733
11734   g_object_notify (G_OBJECT (tree_view), "headers-clickable");
11735 }
11736
11737
11738 /**
11739  * gtk_tree_view_get_headers_clickable:
11740  * @tree_view: A #GtkTreeView.
11741  *
11742  * Returns whether all header columns are clickable.
11743  *
11744  * Return value: %TRUE if all header columns are clickable, otherwise %FALSE
11745  *
11746  * Since: 2.10
11747  **/
11748 gboolean
11749 gtk_tree_view_get_headers_clickable (GtkTreeView *tree_view)
11750 {
11751   GList *list;
11752
11753   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
11754
11755   for (list = tree_view->priv->columns; list; list = list->next)
11756     if (!gtk_tree_view_column_get_clickable (GTK_TREE_VIEW_COLUMN (list->data)))
11757       return FALSE;
11758
11759   return TRUE;
11760 }
11761
11762 /**
11763  * gtk_tree_view_set_rules_hint
11764  * @tree_view: a #GtkTreeView
11765  * @setting: %TRUE if the tree requires reading across rows
11766  *
11767  * This function tells GTK+ that the user interface for your
11768  * application requires users to read across tree rows and associate
11769  * cells with one another. By default, GTK+ will then render the tree
11770  * with alternating row colors. Do <emphasis>not</emphasis> use it
11771  * just because you prefer the appearance of the ruled tree; that's a
11772  * question for the theme. Some themes will draw tree rows in
11773  * alternating colors even when rules are turned off, and users who
11774  * prefer that appearance all the time can choose those themes. You
11775  * should call this function only as a <emphasis>semantic</emphasis>
11776  * hint to the theme engine that your tree makes alternating colors
11777  * useful from a functional standpoint (since it has lots of columns,
11778  * generally).
11779  *
11780  **/
11781 void
11782 gtk_tree_view_set_rules_hint (GtkTreeView  *tree_view,
11783                               gboolean      setting)
11784 {
11785   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11786
11787   setting = setting != FALSE;
11788
11789   if (tree_view->priv->has_rules != setting)
11790     {
11791       tree_view->priv->has_rules = setting;
11792       gtk_widget_queue_draw (GTK_WIDGET (tree_view));
11793     }
11794
11795   g_object_notify (G_OBJECT (tree_view), "rules-hint");
11796 }
11797
11798 /**
11799  * gtk_tree_view_get_rules_hint
11800  * @tree_view: a #GtkTreeView
11801  *
11802  * Gets the setting set by gtk_tree_view_set_rules_hint().
11803  *
11804  * Return value: %TRUE if rules are useful for the user of this tree
11805  **/
11806 gboolean
11807 gtk_tree_view_get_rules_hint (GtkTreeView  *tree_view)
11808 {
11809   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
11810
11811   return tree_view->priv->has_rules;
11812 }
11813
11814 /* Public Column functions
11815  */
11816
11817 /**
11818  * gtk_tree_view_append_column:
11819  * @tree_view: A #GtkTreeView.
11820  * @column: The #GtkTreeViewColumn to add.
11821  *
11822  * Appends @column to the list of columns. If @tree_view has "fixed_height"
11823  * mode enabled, then @column must have its "sizing" property set to be
11824  * GTK_TREE_VIEW_COLUMN_FIXED.
11825  *
11826  * Return value: The number of columns in @tree_view after appending.
11827  **/
11828 gint
11829 gtk_tree_view_append_column (GtkTreeView       *tree_view,
11830                              GtkTreeViewColumn *column)
11831 {
11832   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
11833   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (column), -1);
11834   g_return_val_if_fail (gtk_tree_view_column_get_tree_view (column) == NULL, -1);
11835
11836   return gtk_tree_view_insert_column (tree_view, column, -1);
11837 }
11838
11839 void
11840 _gtk_tree_view_reset_header_styles (GtkTreeView *tree_view)
11841 {
11842   GList *columns;
11843
11844   for (columns = tree_view->priv->columns; columns; columns = columns->next)
11845     {
11846       GtkTreeViewColumn *column = columns->data;
11847       GtkWidget *header_widget;
11848
11849       if (gtk_tree_view_column_get_visible (column))
11850         continue;
11851
11852       header_widget = gtk_tree_view_column_get_widget (column);
11853
11854       if (!header_widget)
11855         header_widget = gtk_tree_view_column_get_button (column);
11856
11857       gtk_widget_reset_style (header_widget);
11858     }
11859 }
11860
11861
11862 /**
11863  * gtk_tree_view_remove_column:
11864  * @tree_view: A #GtkTreeView.
11865  * @column: The #GtkTreeViewColumn to remove.
11866  *
11867  * Removes @column from @tree_view.
11868  *
11869  * Return value: The number of columns in @tree_view after removing.
11870  **/
11871 gint
11872 gtk_tree_view_remove_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) == GTK_WIDGET (tree_view), -1);
11878
11879   if (tree_view->priv->focus_column == column)
11880     tree_view->priv->focus_column = NULL;
11881
11882   if (tree_view->priv->edited_column == column)
11883     {
11884       gtk_tree_view_stop_editing (tree_view, TRUE);
11885
11886       /* no need to, but just to be sure ... */
11887       tree_view->priv->edited_column = NULL;
11888     }
11889
11890   if (tree_view->priv->expander_column == column)
11891     tree_view->priv->expander_column = NULL;
11892
11893   g_signal_handlers_disconnect_by_func (column,
11894                                         G_CALLBACK (column_sizing_notify),
11895                                         tree_view);
11896
11897   _gtk_tree_view_column_unset_tree_view (column);
11898
11899   tree_view->priv->columns = g_list_remove (tree_view->priv->columns, column);
11900   tree_view->priv->n_columns--;
11901
11902   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
11903     {
11904       GList *list;
11905
11906       _gtk_tree_view_column_unrealize_button (column);
11907       for (list = tree_view->priv->columns; list; list = list->next)
11908         {
11909           GtkTreeViewColumn *tmp_column;
11910
11911           tmp_column = GTK_TREE_VIEW_COLUMN (list->data);
11912           if (gtk_tree_view_column_get_visible (tmp_column))
11913             _gtk_tree_view_column_cell_set_dirty (tmp_column, TRUE);
11914         }
11915
11916       if (tree_view->priv->n_columns == 0 &&
11917           gtk_tree_view_get_headers_visible (tree_view))
11918         gdk_window_hide (tree_view->priv->header_window);
11919
11920       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
11921     }
11922
11923   _gtk_tree_view_reset_header_styles (tree_view);
11924
11925   g_object_unref (column);
11926   g_signal_emit (tree_view, tree_view_signals[COLUMNS_CHANGED], 0);
11927
11928   return tree_view->priv->n_columns;
11929 }
11930
11931 /**
11932  * gtk_tree_view_insert_column:
11933  * @tree_view: A #GtkTreeView.
11934  * @column: The #GtkTreeViewColumn to be inserted.
11935  * @position: The position to insert @column in.
11936  *
11937  * This inserts the @column into the @tree_view at @position.  If @position is
11938  * -1, then the column is inserted at the end. If @tree_view has
11939  * "fixed_height" mode enabled, then @column must have its "sizing" property
11940  * set to be GTK_TREE_VIEW_COLUMN_FIXED.
11941  *
11942  * Return value: The number of columns in @tree_view after insertion.
11943  **/
11944 gint
11945 gtk_tree_view_insert_column (GtkTreeView       *tree_view,
11946                              GtkTreeViewColumn *column,
11947                              gint               position)
11948 {
11949   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
11950   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (column), -1);
11951   g_return_val_if_fail (gtk_tree_view_column_get_tree_view (column) == NULL, -1);
11952
11953   if (tree_view->priv->fixed_height_mode)
11954     g_return_val_if_fail (gtk_tree_view_column_get_sizing (column)
11955                           == GTK_TREE_VIEW_COLUMN_FIXED, -1);
11956
11957   g_object_ref_sink (column);
11958
11959   if (tree_view->priv->n_columns == 0 &&
11960       gtk_widget_get_realized (GTK_WIDGET (tree_view)) &&
11961       gtk_tree_view_get_headers_visible (tree_view))
11962     {
11963       gdk_window_show (tree_view->priv->header_window);
11964     }
11965
11966   g_signal_connect (column, "notify::sizing",
11967                     G_CALLBACK (column_sizing_notify), tree_view);
11968
11969   tree_view->priv->columns = g_list_insert (tree_view->priv->columns,
11970                                             column, position);
11971   tree_view->priv->n_columns++;
11972
11973   _gtk_tree_view_column_set_tree_view (column, tree_view);
11974
11975   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
11976     {
11977       GList *list;
11978
11979       _gtk_tree_view_column_realize_button (column);
11980
11981       for (list = tree_view->priv->columns; list; list = list->next)
11982         {
11983           column = GTK_TREE_VIEW_COLUMN (list->data);
11984           if (gtk_tree_view_column_get_visible (column))
11985             _gtk_tree_view_column_cell_set_dirty (column, TRUE);
11986         }
11987       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
11988     }
11989
11990   _gtk_tree_view_reset_header_styles (tree_view);
11991   g_signal_emit (tree_view, tree_view_signals[COLUMNS_CHANGED], 0);
11992
11993   return tree_view->priv->n_columns;
11994 }
11995
11996 /**
11997  * gtk_tree_view_insert_column_with_attributes:
11998  * @tree_view: A #GtkTreeView
11999  * @position: The position to insert the new column in
12000  * @title: The title to set the header to
12001  * @cell: The #GtkCellRenderer
12002  * @...: A %NULL-terminated list of attributes
12003  *
12004  * Creates a new #GtkTreeViewColumn and inserts it into the @tree_view at
12005  * @position.  If @position is -1, then the newly created column is inserted at
12006  * the end.  The column is initialized with the attributes given. If @tree_view
12007  * has "fixed_height" mode enabled, then the new column will have its sizing
12008  * property set to be GTK_TREE_VIEW_COLUMN_FIXED.
12009  *
12010  * Return value: The number of columns in @tree_view after insertion.
12011  **/
12012 gint
12013 gtk_tree_view_insert_column_with_attributes (GtkTreeView     *tree_view,
12014                                              gint             position,
12015                                              const gchar     *title,
12016                                              GtkCellRenderer *cell,
12017                                              ...)
12018 {
12019   GtkTreeViewColumn *column;
12020   gchar *attribute;
12021   va_list args;
12022   gint column_id;
12023
12024   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
12025
12026   column = gtk_tree_view_column_new ();
12027   if (tree_view->priv->fixed_height_mode)
12028     gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED);
12029
12030   gtk_tree_view_column_set_title (column, title);
12031   gtk_tree_view_column_pack_start (column, cell, TRUE);
12032
12033   va_start (args, cell);
12034
12035   attribute = va_arg (args, gchar *);
12036
12037   while (attribute != NULL)
12038     {
12039       column_id = va_arg (args, gint);
12040       gtk_tree_view_column_add_attribute (column, cell, attribute, column_id);
12041       attribute = va_arg (args, gchar *);
12042     }
12043
12044   va_end (args);
12045
12046   gtk_tree_view_insert_column (tree_view, column, position);
12047
12048   return tree_view->priv->n_columns;
12049 }
12050
12051 /**
12052  * gtk_tree_view_insert_column_with_data_func:
12053  * @tree_view: a #GtkTreeView
12054  * @position: Position to insert, -1 for append
12055  * @title: column title
12056  * @cell: cell renderer for column
12057  * @func: function to set attributes of cell renderer
12058  * @data: data for @func
12059  * @dnotify: destroy notifier for @data
12060  *
12061  * Convenience function that inserts a new column into the #GtkTreeView
12062  * with the given cell renderer and a #GtkCellDataFunc to set cell renderer
12063  * attributes (normally using data from the model). See also
12064  * gtk_tree_view_column_set_cell_data_func(), gtk_tree_view_column_pack_start().
12065  * If @tree_view has "fixed_height" mode enabled, then the new column will have its
12066  * "sizing" property set to be GTK_TREE_VIEW_COLUMN_FIXED.
12067  *
12068  * Return value: number of columns in the tree view post-insert
12069  **/
12070 gint
12071 gtk_tree_view_insert_column_with_data_func  (GtkTreeView               *tree_view,
12072                                              gint                       position,
12073                                              const gchar               *title,
12074                                              GtkCellRenderer           *cell,
12075                                              GtkTreeCellDataFunc        func,
12076                                              gpointer                   data,
12077                                              GDestroyNotify             dnotify)
12078 {
12079   GtkTreeViewColumn *column;
12080
12081   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
12082
12083   column = gtk_tree_view_column_new ();
12084   if (tree_view->priv->fixed_height_mode)
12085     gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED);
12086
12087   gtk_tree_view_column_set_title (column, title);
12088   gtk_tree_view_column_pack_start (column, cell, TRUE);
12089   gtk_tree_view_column_set_cell_data_func (column, cell, func, data, dnotify);
12090
12091   gtk_tree_view_insert_column (tree_view, column, position);
12092
12093   return tree_view->priv->n_columns;
12094 }
12095
12096 /**
12097  * gtk_tree_view_get_column:
12098  * @tree_view: A #GtkTreeView.
12099  * @n: The position of the column, counting from 0.
12100  *
12101  * Gets the #GtkTreeViewColumn at the given position in the #tree_view.
12102  *
12103  * Return value: (transfer none): The #GtkTreeViewColumn, or %NULL if the
12104  *     position is outside the range of columns.
12105  **/
12106 GtkTreeViewColumn *
12107 gtk_tree_view_get_column (GtkTreeView *tree_view,
12108                           gint         n)
12109 {
12110   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
12111
12112   if (n < 0 || n >= tree_view->priv->n_columns)
12113     return NULL;
12114
12115   if (tree_view->priv->columns == NULL)
12116     return NULL;
12117
12118   return GTK_TREE_VIEW_COLUMN (g_list_nth (tree_view->priv->columns, n)->data);
12119 }
12120
12121 /**
12122  * gtk_tree_view_get_columns:
12123  * @tree_view: A #GtkTreeView
12124  *
12125  * Returns a #GList of all the #GtkTreeViewColumn s currently in @tree_view.
12126  * The returned list must be freed with g_list_free ().
12127  *
12128  * Return value: (element-type GtkTreeViewColumn) (transfer container): A list of #GtkTreeViewColumn s
12129  **/
12130 GList *
12131 gtk_tree_view_get_columns (GtkTreeView *tree_view)
12132 {
12133   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
12134
12135   return g_list_copy (tree_view->priv->columns);
12136 }
12137
12138 /**
12139  * gtk_tree_view_move_column_after:
12140  * @tree_view: A #GtkTreeView
12141  * @column: The #GtkTreeViewColumn to be moved.
12142  * @base_column: (allow-none): The #GtkTreeViewColumn to be moved relative to, or %NULL.
12143  *
12144  * Moves @column to be after to @base_column.  If @base_column is %NULL, then
12145  * @column is placed in the first position.
12146  **/
12147 void
12148 gtk_tree_view_move_column_after (GtkTreeView       *tree_view,
12149                                  GtkTreeViewColumn *column,
12150                                  GtkTreeViewColumn *base_column)
12151 {
12152   GList *column_list_el, *base_el = NULL;
12153
12154   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12155
12156   column_list_el = g_list_find (tree_view->priv->columns, column);
12157   g_return_if_fail (column_list_el != NULL);
12158
12159   if (base_column)
12160     {
12161       base_el = g_list_find (tree_view->priv->columns, base_column);
12162       g_return_if_fail (base_el != NULL);
12163     }
12164
12165   if (column_list_el->prev == base_el)
12166     return;
12167
12168   tree_view->priv->columns = g_list_remove_link (tree_view->priv->columns, column_list_el);
12169   if (base_el == NULL)
12170     {
12171       column_list_el->prev = NULL;
12172       column_list_el->next = tree_view->priv->columns;
12173       if (column_list_el->next)
12174         column_list_el->next->prev = column_list_el;
12175       tree_view->priv->columns = column_list_el;
12176     }
12177   else
12178     {
12179       column_list_el->prev = base_el;
12180       column_list_el->next = base_el->next;
12181       if (column_list_el->next)
12182         column_list_el->next->prev = column_list_el;
12183       base_el->next = column_list_el;
12184     }
12185
12186   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
12187     {
12188       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
12189       gtk_tree_view_size_allocate_columns (GTK_WIDGET (tree_view), NULL);
12190     }
12191
12192   _gtk_tree_view_reset_header_styles (tree_view);
12193   g_signal_emit (tree_view, tree_view_signals[COLUMNS_CHANGED], 0);
12194 }
12195
12196 /**
12197  * gtk_tree_view_set_expander_column:
12198  * @tree_view: A #GtkTreeView
12199  * @column: %NULL, or the column to draw the expander arrow at.
12200  *
12201  * Sets the column to draw the expander arrow at. It must be in @tree_view.
12202  * If @column is %NULL, then the expander arrow is always at the first
12203  * visible column.
12204  *
12205  * If you do not want expander arrow to appear in your tree, set the
12206  * expander column to a hidden column.
12207  **/
12208 void
12209 gtk_tree_view_set_expander_column (GtkTreeView       *tree_view,
12210                                    GtkTreeViewColumn *column)
12211 {
12212   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12213   g_return_if_fail (column == NULL || GTK_IS_TREE_VIEW_COLUMN (column));
12214
12215   if (tree_view->priv->expander_column != column)
12216     {
12217       GList *list;
12218
12219       if (column)
12220         {
12221           /* Confirm that column is in tree_view */
12222           for (list = tree_view->priv->columns; list; list = list->next)
12223             if (list->data == column)
12224               break;
12225           g_return_if_fail (list != NULL);
12226         }
12227
12228       tree_view->priv->expander_column = column;
12229       g_object_notify (G_OBJECT (tree_view), "expander-column");
12230     }
12231 }
12232
12233 /**
12234  * gtk_tree_view_get_expander_column:
12235  * @tree_view: A #GtkTreeView
12236  *
12237  * Returns the column that is the current expander column.
12238  * This column has the expander arrow drawn next to it.
12239  *
12240  * Return value: (transfer none): The expander column.
12241  **/
12242 GtkTreeViewColumn *
12243 gtk_tree_view_get_expander_column (GtkTreeView *tree_view)
12244 {
12245   GList *list;
12246
12247   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
12248
12249   for (list = tree_view->priv->columns; list; list = list->next)
12250     if (gtk_tree_view_is_expander_column (tree_view, GTK_TREE_VIEW_COLUMN (list->data)))
12251       return (GtkTreeViewColumn *) list->data;
12252   return NULL;
12253 }
12254
12255
12256 /**
12257  * gtk_tree_view_set_column_drag_function:
12258  * @tree_view: A #GtkTreeView.
12259  * @func: (allow-none): A function to determine which columns are reorderable, or %NULL.
12260  * @user_data: (allow-none): User data to be passed to @func, or %NULL
12261  * @destroy: (allow-none): Destroy notifier for @user_data, or %NULL
12262  *
12263  * Sets a user function for determining where a column may be dropped when
12264  * dragged.  This function is called on every column pair in turn at the
12265  * beginning of a column drag to determine where a drop can take place.  The
12266  * arguments passed to @func are: the @tree_view, the #GtkTreeViewColumn being
12267  * dragged, the two #GtkTreeViewColumn s determining the drop spot, and
12268  * @user_data.  If either of the #GtkTreeViewColumn arguments for the drop spot
12269  * are %NULL, then they indicate an edge.  If @func is set to be %NULL, then
12270  * @tree_view reverts to the default behavior of allowing all columns to be
12271  * dropped everywhere.
12272  **/
12273 void
12274 gtk_tree_view_set_column_drag_function (GtkTreeView               *tree_view,
12275                                         GtkTreeViewColumnDropFunc  func,
12276                                         gpointer                   user_data,
12277                                         GDestroyNotify             destroy)
12278 {
12279   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12280
12281   if (tree_view->priv->column_drop_func_data_destroy)
12282     tree_view->priv->column_drop_func_data_destroy (tree_view->priv->column_drop_func_data);
12283
12284   tree_view->priv->column_drop_func = func;
12285   tree_view->priv->column_drop_func_data = user_data;
12286   tree_view->priv->column_drop_func_data_destroy = destroy;
12287 }
12288
12289 /**
12290  * gtk_tree_view_scroll_to_point:
12291  * @tree_view: a #GtkTreeView
12292  * @tree_x: X coordinate of new top-left pixel of visible area, or -1
12293  * @tree_y: Y coordinate of new top-left pixel of visible area, or -1
12294  *
12295  * Scrolls the tree view such that the top-left corner of the visible
12296  * area is @tree_x, @tree_y, where @tree_x and @tree_y are specified
12297  * in tree coordinates.  The @tree_view must be realized before
12298  * this function is called.  If it isn't, you probably want to be
12299  * using gtk_tree_view_scroll_to_cell().
12300  *
12301  * If either @tree_x or @tree_y are -1, then that direction isn't scrolled.
12302  **/
12303 void
12304 gtk_tree_view_scroll_to_point (GtkTreeView *tree_view,
12305                                gint         tree_x,
12306                                gint         tree_y)
12307 {
12308   GtkAdjustment *hadj;
12309   GtkAdjustment *vadj;
12310
12311   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12312   g_return_if_fail (gtk_widget_get_realized (GTK_WIDGET (tree_view)));
12313
12314   hadj = tree_view->priv->hadjustment;
12315   vadj = tree_view->priv->vadjustment;
12316
12317   if (tree_x != -1)
12318     gtk_adjustment_set_value (hadj, tree_x);
12319   if (tree_y != -1)
12320     gtk_adjustment_set_value (vadj, tree_y);
12321 }
12322
12323 /**
12324  * gtk_tree_view_scroll_to_cell:
12325  * @tree_view: A #GtkTreeView.
12326  * @path: (allow-none): The path of the row to move to, or %NULL.
12327  * @column: (allow-none): The #GtkTreeViewColumn to move horizontally to, or %NULL.
12328  * @use_align: whether to use alignment arguments, or %FALSE.
12329  * @row_align: The vertical alignment of the row specified by @path.
12330  * @col_align: The horizontal alignment of the column specified by @column.
12331  *
12332  * Moves the alignments of @tree_view to the position specified by @column and
12333  * @path.  If @column is %NULL, then no horizontal scrolling occurs.  Likewise,
12334  * if @path is %NULL no vertical scrolling occurs.  At a minimum, one of @column
12335  * or @path need to be non-%NULL.  @row_align determines where the row is
12336  * placed, and @col_align determines where @column is placed.  Both are expected
12337  * to be between 0.0 and 1.0. 0.0 means left/top alignment, 1.0 means
12338  * right/bottom alignment, 0.5 means center.
12339  *
12340  * If @use_align is %FALSE, then the alignment arguments are ignored, and the
12341  * tree does the minimum amount of work to scroll the cell onto the screen.
12342  * This means that the cell will be scrolled to the edge closest to its current
12343  * position.  If the cell is currently visible on the screen, nothing is done.
12344  *
12345  * This function only works if the model is set, and @path is a valid row on the
12346  * model.  If the model changes before the @tree_view is realized, the centered
12347  * path will be modified to reflect this change.
12348  **/
12349 void
12350 gtk_tree_view_scroll_to_cell (GtkTreeView       *tree_view,
12351                               GtkTreePath       *path,
12352                               GtkTreeViewColumn *column,
12353                               gboolean           use_align,
12354                               gfloat             row_align,
12355                               gfloat             col_align)
12356 {
12357   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12358   g_return_if_fail (tree_view->priv->model != NULL);
12359   g_return_if_fail (tree_view->priv->tree != NULL);
12360   g_return_if_fail (row_align >= 0.0 && row_align <= 1.0);
12361   g_return_if_fail (col_align >= 0.0 && col_align <= 1.0);
12362   g_return_if_fail (path != NULL || column != NULL);
12363
12364 #if 0
12365   g_print ("gtk_tree_view_scroll_to_cell:\npath: %s\ncolumn: %s\nuse_align: %d\nrow_align: %f\ncol_align: %f\n",
12366            gtk_tree_path_to_string (path), column?"non-null":"null", use_align, row_align, col_align);
12367 #endif
12368   row_align = CLAMP (row_align, 0.0, 1.0);
12369   col_align = CLAMP (col_align, 0.0, 1.0);
12370
12371
12372   /* Note: Despite the benefits that come from having one code path for the
12373    * scrolling code, we short-circuit validate_visible_area's immplementation as
12374    * it is much slower than just going to the point.
12375    */
12376   if (!gtk_widget_get_visible (GTK_WIDGET (tree_view)) ||
12377       !gtk_widget_get_realized (GTK_WIDGET (tree_view)) ||
12378       _gtk_widget_get_alloc_needed (GTK_WIDGET (tree_view)) ||
12379       GTK_RBNODE_FLAG_SET (tree_view->priv->tree->root, GTK_RBNODE_DESCENDANTS_INVALID))
12380     {
12381       if (tree_view->priv->scroll_to_path)
12382         gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
12383
12384       tree_view->priv->scroll_to_path = NULL;
12385       tree_view->priv->scroll_to_column = NULL;
12386
12387       if (path)
12388         tree_view->priv->scroll_to_path = gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view), tree_view->priv->model, path);
12389       if (column)
12390         tree_view->priv->scroll_to_column = column;
12391       tree_view->priv->scroll_to_use_align = use_align;
12392       tree_view->priv->scroll_to_row_align = row_align;
12393       tree_view->priv->scroll_to_col_align = col_align;
12394
12395       install_presize_handler (tree_view);
12396     }
12397   else
12398     {
12399       GdkRectangle cell_rect;
12400       GdkRectangle vis_rect;
12401       gint dest_x, dest_y;
12402
12403       gtk_tree_view_get_background_area (tree_view, path, column, &cell_rect);
12404       gtk_tree_view_get_visible_rect (tree_view, &vis_rect);
12405
12406       cell_rect.y = TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, cell_rect.y);
12407
12408       dest_x = vis_rect.x;
12409       dest_y = vis_rect.y;
12410
12411       if (column)
12412         {
12413           if (use_align)
12414             {
12415               dest_x = cell_rect.x - ((vis_rect.width - cell_rect.width) * col_align);
12416             }
12417           else
12418             {
12419               if (cell_rect.x < vis_rect.x)
12420                 dest_x = cell_rect.x;
12421               if (cell_rect.x + cell_rect.width > vis_rect.x + vis_rect.width)
12422                 dest_x = cell_rect.x + cell_rect.width - vis_rect.width;
12423             }
12424         }
12425
12426       if (path)
12427         {
12428           if (use_align)
12429             {
12430               dest_y = cell_rect.y - ((vis_rect.height - cell_rect.height) * row_align);
12431               dest_y = MAX (dest_y, 0);
12432             }
12433           else
12434             {
12435               if (cell_rect.y < vis_rect.y)
12436                 dest_y = cell_rect.y;
12437               if (cell_rect.y + cell_rect.height > vis_rect.y + vis_rect.height)
12438                 dest_y = cell_rect.y + cell_rect.height - vis_rect.height;
12439             }
12440         }
12441
12442       gtk_tree_view_scroll_to_point (tree_view, dest_x, dest_y);
12443     }
12444 }
12445
12446 /**
12447  * gtk_tree_view_row_activated:
12448  * @tree_view: A #GtkTreeView
12449  * @path: The #GtkTreePath to be activated.
12450  * @column: The #GtkTreeViewColumn to be activated.
12451  *
12452  * Activates the cell determined by @path and @column.
12453  **/
12454 void
12455 gtk_tree_view_row_activated (GtkTreeView       *tree_view,
12456                              GtkTreePath       *path,
12457                              GtkTreeViewColumn *column)
12458 {
12459   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12460
12461   g_signal_emit (tree_view, tree_view_signals[ROW_ACTIVATED], 0, path, column);
12462 }
12463
12464
12465 static void
12466 gtk_tree_view_expand_all_emission_helper (GtkRBTree *tree,
12467                                           GtkRBNode *node,
12468                                           gpointer   data)
12469 {
12470   GtkTreeView *tree_view = data;
12471
12472   if ((node->flags & GTK_RBNODE_IS_PARENT) == GTK_RBNODE_IS_PARENT &&
12473       node->children)
12474     {
12475       GtkTreePath *path;
12476       GtkTreeIter iter;
12477
12478       path = _gtk_tree_view_find_path (tree_view, tree, node);
12479       gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
12480
12481       g_signal_emit (tree_view, tree_view_signals[ROW_EXPANDED], 0, &iter, path);
12482
12483       gtk_tree_path_free (path);
12484     }
12485
12486   if (node->children)
12487     _gtk_rbtree_traverse (node->children,
12488                           node->children->root,
12489                           G_PRE_ORDER,
12490                           gtk_tree_view_expand_all_emission_helper,
12491                           tree_view);
12492 }
12493
12494 /**
12495  * gtk_tree_view_expand_all:
12496  * @tree_view: A #GtkTreeView.
12497  *
12498  * Recursively expands all nodes in the @tree_view.
12499  **/
12500 void
12501 gtk_tree_view_expand_all (GtkTreeView *tree_view)
12502 {
12503   GtkTreePath *path;
12504   GtkRBTree *tree;
12505   GtkRBNode *node;
12506
12507   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12508
12509   if (tree_view->priv->tree == NULL)
12510     return;
12511
12512   path = gtk_tree_path_new_first ();
12513   _gtk_tree_view_find_node (tree_view, path, &tree, &node);
12514
12515   while (node)
12516     {
12517       gtk_tree_view_real_expand_row (tree_view, path, tree, node, TRUE, FALSE);
12518       node = _gtk_rbtree_next (tree, node);
12519       gtk_tree_path_next (path);
12520   }
12521
12522   gtk_tree_path_free (path);
12523 }
12524
12525 /**
12526  * gtk_tree_view_collapse_all:
12527  * @tree_view: A #GtkTreeView.
12528  *
12529  * Recursively collapses all visible, expanded nodes in @tree_view.
12530  **/
12531 void
12532 gtk_tree_view_collapse_all (GtkTreeView *tree_view)
12533 {
12534   GtkRBTree *tree;
12535   GtkRBNode *node;
12536   GtkTreePath *path;
12537   gint *indices;
12538
12539   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12540
12541   if (tree_view->priv->tree == NULL)
12542     return;
12543
12544   path = gtk_tree_path_new ();
12545   gtk_tree_path_down (path);
12546   indices = gtk_tree_path_get_indices (path);
12547
12548   tree = tree_view->priv->tree;
12549   node = tree->root;
12550   while (node && node->left != tree->nil)
12551     node = node->left;
12552
12553   while (node)
12554     {
12555       if (node->children)
12556         gtk_tree_view_real_collapse_row (tree_view, path, tree, node, FALSE);
12557       indices[0]++;
12558       node = _gtk_rbtree_next (tree, node);
12559     }
12560
12561   gtk_tree_path_free (path);
12562 }
12563
12564 /**
12565  * gtk_tree_view_expand_to_path:
12566  * @tree_view: A #GtkTreeView.
12567  * @path: path to a row.
12568  *
12569  * Expands the row at @path. This will also expand all parent rows of
12570  * @path as necessary.
12571  *
12572  * Since: 2.2
12573  **/
12574 void
12575 gtk_tree_view_expand_to_path (GtkTreeView *tree_view,
12576                               GtkTreePath *path)
12577 {
12578   gint i, depth;
12579   gint *indices;
12580   GtkTreePath *tmp;
12581
12582   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12583   g_return_if_fail (path != NULL);
12584
12585   depth = gtk_tree_path_get_depth (path);
12586   indices = gtk_tree_path_get_indices (path);
12587
12588   tmp = gtk_tree_path_new ();
12589   g_return_if_fail (tmp != NULL);
12590
12591   for (i = 0; i < depth; i++)
12592     {
12593       gtk_tree_path_append_index (tmp, indices[i]);
12594       gtk_tree_view_expand_row (tree_view, tmp, FALSE);
12595     }
12596
12597   gtk_tree_path_free (tmp);
12598 }
12599
12600 /* FIXME the bool return values for expand_row and collapse_row are
12601  * not analagous; they should be TRUE if the row had children and
12602  * was not already in the requested state.
12603  */
12604
12605
12606 static gboolean
12607 gtk_tree_view_real_expand_row (GtkTreeView *tree_view,
12608                                GtkTreePath *path,
12609                                GtkRBTree   *tree,
12610                                GtkRBNode   *node,
12611                                gboolean     open_all,
12612                                gboolean     animate)
12613 {
12614   GtkTreeIter iter;
12615   GtkTreeIter temp;
12616   gboolean expand;
12617
12618   if (animate)
12619     g_object_get (gtk_widget_get_settings (GTK_WIDGET (tree_view)),
12620                   "gtk-enable-animations", &animate,
12621                   NULL);
12622
12623   remove_auto_expand_timeout (tree_view);
12624
12625   if (node->children && !open_all)
12626     return FALSE;
12627
12628   if (! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT))
12629     return FALSE;
12630
12631   gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
12632   if (! gtk_tree_model_iter_has_child (tree_view->priv->model, &iter))
12633     return FALSE;
12634
12635
12636    if (node->children && open_all)
12637     {
12638       gboolean retval = FALSE;
12639       GtkTreePath *tmp_path = gtk_tree_path_copy (path);
12640
12641       gtk_tree_path_append_index (tmp_path, 0);
12642       tree = node->children;
12643       node = tree->root;
12644       while (node->left != tree->nil)
12645         node = node->left;
12646       /* try to expand the children */
12647       do
12648         {
12649          gboolean t;
12650          t = gtk_tree_view_real_expand_row (tree_view, tmp_path, tree, node,
12651                                             TRUE, animate);
12652          if (t)
12653            retval = TRUE;
12654
12655          gtk_tree_path_next (tmp_path);
12656          node = _gtk_rbtree_next (tree, node);
12657        }
12658       while (node != NULL);
12659
12660       gtk_tree_path_free (tmp_path);
12661
12662       return retval;
12663     }
12664
12665   g_signal_emit (tree_view, tree_view_signals[TEST_EXPAND_ROW], 0, &iter, path, &expand);
12666
12667   if (!gtk_tree_model_iter_has_child (tree_view->priv->model, &iter))
12668     return FALSE;
12669
12670   if (expand)
12671     return FALSE;
12672
12673   node->children = _gtk_rbtree_new ();
12674   node->children->parent_tree = tree;
12675   node->children->parent_node = node;
12676
12677   gtk_tree_model_iter_children (tree_view->priv->model, &temp, &iter);
12678
12679   gtk_tree_view_build_tree (tree_view,
12680                             node->children,
12681                             &temp,
12682                             gtk_tree_path_get_depth (path) + 1,
12683                             open_all);
12684
12685   if (animate)
12686     {
12687       GtkStyleContext *context;
12688
12689       context = gtk_widget_get_style_context (GTK_WIDGET (tree_view));
12690
12691       gtk_style_context_save (context);
12692       gtk_style_context_add_class (context, GTK_STYLE_CLASS_EXPANDER);
12693
12694       gtk_style_context_notify_state_change (context, tree_view->priv->bin_window,
12695                                              node, GTK_STATE_ACTIVE, TRUE);
12696
12697       _gtk_style_context_invalidate_animation_areas (context);
12698       gtk_style_context_restore (context);
12699     }
12700
12701   install_presize_handler (tree_view);
12702
12703   g_signal_emit (tree_view, tree_view_signals[ROW_EXPANDED], 0, &iter, path);
12704   if (open_all && node->children)
12705     {
12706       _gtk_rbtree_traverse (node->children,
12707                             node->children->root,
12708                             G_PRE_ORDER,
12709                             gtk_tree_view_expand_all_emission_helper,
12710                             tree_view);
12711     }
12712   return TRUE;
12713 }
12714
12715
12716 /**
12717  * gtk_tree_view_expand_row:
12718  * @tree_view: a #GtkTreeView
12719  * @path: path to a row
12720  * @open_all: whether to recursively expand, or just expand immediate children
12721  *
12722  * Opens the row so its children are visible.
12723  *
12724  * Return value: %TRUE if the row existed and had children
12725  **/
12726 gboolean
12727 gtk_tree_view_expand_row (GtkTreeView *tree_view,
12728                           GtkTreePath *path,
12729                           gboolean     open_all)
12730 {
12731   GtkRBTree *tree;
12732   GtkRBNode *node;
12733
12734   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
12735   g_return_val_if_fail (tree_view->priv->model != NULL, FALSE);
12736   g_return_val_if_fail (path != NULL, FALSE);
12737
12738   if (_gtk_tree_view_find_node (tree_view,
12739                                 path,
12740                                 &tree,
12741                                 &node))
12742     return FALSE;
12743
12744   if (tree != NULL)
12745     return gtk_tree_view_real_expand_row (tree_view, path, tree, node, open_all, FALSE);
12746   else
12747     return FALSE;
12748 }
12749
12750 static gboolean
12751 gtk_tree_view_real_collapse_row (GtkTreeView *tree_view,
12752                                  GtkTreePath *path,
12753                                  GtkRBTree   *tree,
12754                                  GtkRBNode   *node,
12755                                  gboolean     animate)
12756 {
12757   GtkTreeIter iter;
12758   GtkTreeIter children;
12759   gboolean collapse;
12760   gint x, y;
12761   GList *list;
12762   GdkWindow *child, *parent;
12763
12764   if (animate)
12765     g_object_get (gtk_widget_get_settings (GTK_WIDGET (tree_view)),
12766                   "gtk-enable-animations", &animate,
12767                   NULL);
12768
12769   remove_auto_expand_timeout (tree_view);
12770
12771   if (node->children == NULL)
12772     return FALSE;
12773   gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
12774
12775   g_signal_emit (tree_view, tree_view_signals[TEST_COLLAPSE_ROW], 0, &iter, path, &collapse);
12776
12777   if (collapse)
12778     return FALSE;
12779
12780   /* if the prelighted node is a child of us, we want to unprelight it.  We have
12781    * a chance to prelight the correct node below */
12782
12783   if (tree_view->priv->prelight_tree)
12784     {
12785       GtkRBTree *parent_tree;
12786       GtkRBNode *parent_node;
12787
12788       parent_tree = tree_view->priv->prelight_tree->parent_tree;
12789       parent_node = tree_view->priv->prelight_tree->parent_node;
12790       while (parent_tree)
12791         {
12792           if (parent_tree == tree && parent_node == node)
12793             {
12794               ensure_unprelighted (tree_view);
12795               break;
12796             }
12797           parent_node = parent_tree->parent_node;
12798           parent_tree = parent_tree->parent_tree;
12799         }
12800     }
12801
12802   TREE_VIEW_INTERNAL_ASSERT (gtk_tree_model_iter_children (tree_view->priv->model, &children, &iter), FALSE);
12803
12804   for (list = tree_view->priv->columns; list; list = list->next)
12805     {
12806       GtkTreeViewColumn *column = list->data;
12807
12808       if (gtk_tree_view_column_get_visible (column) == FALSE)
12809         continue;
12810       if (gtk_tree_view_column_get_sizing (column) == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
12811         _gtk_tree_view_column_cell_set_dirty (column, TRUE);
12812     }
12813
12814   if (tree_view->priv->destroy_count_func)
12815     {
12816       GtkTreePath *child_path;
12817       gint child_count = 0;
12818       child_path = gtk_tree_path_copy (path);
12819       gtk_tree_path_down (child_path);
12820       if (node->children)
12821         _gtk_rbtree_traverse (node->children, node->children->root, G_POST_ORDER, count_children_helper, &child_count);
12822       tree_view->priv->destroy_count_func (tree_view, child_path, child_count, tree_view->priv->destroy_count_data);
12823       gtk_tree_path_free (child_path);
12824     }
12825
12826   if (gtk_tree_row_reference_valid (tree_view->priv->cursor))
12827     {
12828       GtkTreePath *cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
12829
12830       if (gtk_tree_path_is_ancestor (path, cursor_path))
12831         {
12832           gtk_tree_row_reference_free (tree_view->priv->cursor);
12833           tree_view->priv->cursor = gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view),
12834                                                                       tree_view->priv->model,
12835                                                                       path);
12836         }
12837       gtk_tree_path_free (cursor_path);
12838     }
12839
12840   if (gtk_tree_row_reference_valid (tree_view->priv->anchor))
12841     {
12842       GtkTreePath *anchor_path = gtk_tree_row_reference_get_path (tree_view->priv->anchor);
12843       if (gtk_tree_path_is_ancestor (path, anchor_path))
12844         {
12845           gtk_tree_row_reference_free (tree_view->priv->anchor);
12846           tree_view->priv->anchor = NULL;
12847         }
12848       gtk_tree_path_free (anchor_path);
12849     }
12850
12851   /* Stop a pending double click */
12852   tree_view->priv->last_button_x = -1;
12853   tree_view->priv->last_button_y = -1;
12854
12855   if (gtk_tree_view_unref_and_check_selection_tree (tree_view, node->children))
12856     {
12857       _gtk_rbtree_remove (node->children);
12858       g_signal_emit_by_name (tree_view->priv->selection, "changed");
12859     }
12860   else
12861     _gtk_rbtree_remove (node->children);
12862
12863   if (animate)
12864     {
12865       GtkStyleContext *context;
12866
12867       context = gtk_widget_get_style_context (GTK_WIDGET (tree_view));
12868
12869       gtk_style_context_save (context);
12870       gtk_style_context_add_class (context, GTK_STYLE_CLASS_EXPANDER);
12871
12872       gtk_style_context_notify_state_change (context, tree_view->priv->bin_window,
12873                                              node, GTK_STATE_ACTIVE, FALSE);
12874
12875       _gtk_style_context_invalidate_animation_areas (context);
12876       gtk_style_context_restore (context);
12877     }
12878
12879   if (gtk_widget_get_mapped (GTK_WIDGET (tree_view)))
12880     {
12881       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
12882     }
12883
12884   g_signal_emit (tree_view, tree_view_signals[ROW_COLLAPSED], 0, &iter, path);
12885
12886   if (gtk_widget_get_mapped (GTK_WIDGET (tree_view)))
12887     {
12888       /* now that we've collapsed all rows, we want to try to set the prelight
12889        * again. To do this, we fake a motion event and send it to ourselves. */
12890
12891       child = tree_view->priv->bin_window;
12892       parent = gdk_window_get_parent (child);
12893
12894       if (gdk_window_get_pointer (parent, &x, &y, NULL) == child)
12895         {
12896           GdkEventMotion event;
12897           gint child_x, child_y;
12898
12899           gdk_window_get_position (child, &child_x, &child_y);
12900
12901           event.window = tree_view->priv->bin_window;
12902           event.x = x - child_x;
12903           event.y = y - child_y;
12904
12905           /* despite the fact this isn't a real event, I'm almost positive it will
12906            * never trigger a drag event.  maybe_drag is the only function that uses
12907            * more than just event.x and event.y. */
12908           gtk_tree_view_motion_bin_window (GTK_WIDGET (tree_view), &event);
12909         }
12910     }
12911
12912   return TRUE;
12913 }
12914
12915 /**
12916  * gtk_tree_view_collapse_row:
12917  * @tree_view: a #GtkTreeView
12918  * @path: path to a row in the @tree_view
12919  *
12920  * Collapses a row (hides its child rows, if they exist).
12921  *
12922  * Return value: %TRUE if the row was collapsed.
12923  **/
12924 gboolean
12925 gtk_tree_view_collapse_row (GtkTreeView *tree_view,
12926                             GtkTreePath *path)
12927 {
12928   GtkRBTree *tree;
12929   GtkRBNode *node;
12930
12931   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
12932   g_return_val_if_fail (tree_view->priv->tree != NULL, FALSE);
12933   g_return_val_if_fail (path != NULL, FALSE);
12934
12935   if (_gtk_tree_view_find_node (tree_view,
12936                                 path,
12937                                 &tree,
12938                                 &node))
12939     return FALSE;
12940
12941   if (tree == NULL || node->children == NULL)
12942     return FALSE;
12943
12944   return gtk_tree_view_real_collapse_row (tree_view, path, tree, node, FALSE);
12945 }
12946
12947 static void
12948 gtk_tree_view_map_expanded_rows_helper (GtkTreeView            *tree_view,
12949                                         GtkRBTree              *tree,
12950                                         GtkTreePath            *path,
12951                                         GtkTreeViewMappingFunc  func,
12952                                         gpointer                user_data)
12953 {
12954   GtkRBNode *node;
12955
12956   if (tree == NULL || tree->root == NULL)
12957     return;
12958
12959   node = tree->root;
12960
12961   while (node && node->left != tree->nil)
12962     node = node->left;
12963
12964   while (node)
12965     {
12966       if (node->children)
12967         {
12968           (* func) (tree_view, path, user_data);
12969           gtk_tree_path_down (path);
12970           gtk_tree_view_map_expanded_rows_helper (tree_view, node->children, path, func, user_data);
12971           gtk_tree_path_up (path);
12972         }
12973       gtk_tree_path_next (path);
12974       node = _gtk_rbtree_next (tree, node);
12975     }
12976 }
12977
12978 /**
12979  * gtk_tree_view_map_expanded_rows:
12980  * @tree_view: A #GtkTreeView
12981  * @func: (scope call): A function to be called
12982  * @data: User data to be passed to the function.
12983  *
12984  * Calls @func on all expanded rows.
12985  **/
12986 void
12987 gtk_tree_view_map_expanded_rows (GtkTreeView            *tree_view,
12988                                  GtkTreeViewMappingFunc  func,
12989                                  gpointer                user_data)
12990 {
12991   GtkTreePath *path;
12992
12993   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12994   g_return_if_fail (func != NULL);
12995
12996   path = gtk_tree_path_new_first ();
12997
12998   gtk_tree_view_map_expanded_rows_helper (tree_view,
12999                                           tree_view->priv->tree,
13000                                           path, func, user_data);
13001
13002   gtk_tree_path_free (path);
13003 }
13004
13005 /**
13006  * gtk_tree_view_row_expanded:
13007  * @tree_view: A #GtkTreeView.
13008  * @path: A #GtkTreePath to test expansion state.
13009  *
13010  * Returns %TRUE if the node pointed to by @path is expanded in @tree_view.
13011  *
13012  * Return value: %TRUE if #path is expanded.
13013  **/
13014 gboolean
13015 gtk_tree_view_row_expanded (GtkTreeView *tree_view,
13016                             GtkTreePath *path)
13017 {
13018   GtkRBTree *tree;
13019   GtkRBNode *node;
13020
13021   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
13022   g_return_val_if_fail (path != NULL, FALSE);
13023
13024   _gtk_tree_view_find_node (tree_view, path, &tree, &node);
13025
13026   if (node == NULL)
13027     return FALSE;
13028
13029   return (node->children != NULL);
13030 }
13031
13032 /**
13033  * gtk_tree_view_get_reorderable:
13034  * @tree_view: a #GtkTreeView
13035  *
13036  * Retrieves whether the user can reorder the tree via drag-and-drop. See
13037  * gtk_tree_view_set_reorderable().
13038  *
13039  * Return value: %TRUE if the tree can be reordered.
13040  **/
13041 gboolean
13042 gtk_tree_view_get_reorderable (GtkTreeView *tree_view)
13043 {
13044   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
13045
13046   return tree_view->priv->reorderable;
13047 }
13048
13049 /**
13050  * gtk_tree_view_set_reorderable:
13051  * @tree_view: A #GtkTreeView.
13052  * @reorderable: %TRUE, if the tree can be reordered.
13053  *
13054  * This function is a convenience function to allow you to reorder
13055  * models that support the #GtkTreeDragSourceIface and the
13056  * #GtkTreeDragDestIface.  Both #GtkTreeStore and #GtkListStore support
13057  * these.  If @reorderable is %TRUE, then the user can reorder the
13058  * model by dragging and dropping rows. The developer can listen to
13059  * these changes by connecting to the model's row_inserted and
13060  * row_deleted signals. The reordering is implemented by setting up
13061  * the tree view as a drag source and destination. Therefore, drag and
13062  * drop can not be used in a reorderable view for any other purpose.
13063  *
13064  * This function does not give you any degree of control over the order -- any
13065  * reordering is allowed.  If more control is needed, you should probably
13066  * handle drag and drop manually.
13067  **/
13068 void
13069 gtk_tree_view_set_reorderable (GtkTreeView *tree_view,
13070                                gboolean     reorderable)
13071 {
13072   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13073
13074   reorderable = reorderable != FALSE;
13075
13076   if (tree_view->priv->reorderable == reorderable)
13077     return;
13078
13079   if (reorderable)
13080     {
13081       const GtkTargetEntry row_targets[] = {
13082         { "GTK_TREE_MODEL_ROW", GTK_TARGET_SAME_WIDGET, 0 }
13083       };
13084
13085       gtk_tree_view_enable_model_drag_source (tree_view,
13086                                               GDK_BUTTON1_MASK,
13087                                               row_targets,
13088                                               G_N_ELEMENTS (row_targets),
13089                                               GDK_ACTION_MOVE);
13090       gtk_tree_view_enable_model_drag_dest (tree_view,
13091                                             row_targets,
13092                                             G_N_ELEMENTS (row_targets),
13093                                             GDK_ACTION_MOVE);
13094     }
13095   else
13096     {
13097       gtk_tree_view_unset_rows_drag_source (tree_view);
13098       gtk_tree_view_unset_rows_drag_dest (tree_view);
13099     }
13100
13101   tree_view->priv->reorderable = reorderable;
13102
13103   g_object_notify (G_OBJECT (tree_view), "reorderable");
13104 }
13105
13106 static void
13107 gtk_tree_view_real_set_cursor (GtkTreeView     *tree_view,
13108                                GtkTreePath     *path,
13109                                gboolean         clear_and_select,
13110                                gboolean         clamp_node)
13111 {
13112   GtkRBTree *tree = NULL;
13113   GtkRBNode *node = NULL;
13114
13115   if (gtk_tree_row_reference_valid (tree_view->priv->cursor))
13116     {
13117       GtkTreePath *cursor_path;
13118       cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
13119       gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
13120       gtk_tree_path_free (cursor_path);
13121     }
13122
13123   gtk_tree_row_reference_free (tree_view->priv->cursor);
13124   tree_view->priv->cursor = NULL;
13125
13126   /* One cannot set the cursor on a separator.   Also, if
13127    * _gtk_tree_view_find_node returns TRUE, it ran out of tree
13128    * before finding the tree and node belonging to path.  The
13129    * path maps to a non-existing path and we will silently bail out.
13130    * We unset tree and node to avoid further processing.
13131    */
13132   if (!row_is_separator (tree_view, NULL, path)
13133       && _gtk_tree_view_find_node (tree_view, path, &tree, &node) == FALSE)
13134     {
13135       tree_view->priv->cursor =
13136           gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view),
13137                                             tree_view->priv->model,
13138                                             path);
13139     }
13140   else
13141     {
13142       tree = NULL;
13143       node = NULL;
13144     }
13145
13146   if (tree != NULL)
13147     {
13148       GtkRBTree *new_tree = NULL;
13149       GtkRBNode *new_node = NULL;
13150
13151       if (clear_and_select && !tree_view->priv->modify_selection_pressed)
13152         {
13153           GtkTreeSelectMode mode = 0;
13154
13155           if (tree_view->priv->extend_selection_pressed)
13156             mode |= GTK_TREE_SELECT_MODE_EXTEND;
13157
13158           _gtk_tree_selection_internal_select_node (tree_view->priv->selection,
13159                                                     node, tree, path, mode,
13160                                                     FALSE);
13161         }
13162
13163       /* We have to re-find tree and node here again, somebody might have
13164        * cleared the node or the whole tree in the GtkTreeSelection::changed
13165        * callback. If the nodes differ we bail out here.
13166        */
13167       _gtk_tree_view_find_node (tree_view, path, &new_tree, &new_node);
13168
13169       if (tree != new_tree || node != new_node)
13170         return;
13171
13172       if (clamp_node)
13173         {
13174           gtk_tree_view_clamp_node_visible (tree_view, tree, node);
13175           _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
13176         }
13177     }
13178
13179   g_signal_emit (tree_view, tree_view_signals[CURSOR_CHANGED], 0);
13180 }
13181
13182 /**
13183  * gtk_tree_view_get_cursor:
13184  * @tree_view: A #GtkTreeView
13185  * @path: (out) (transfer full) (allow-none): A pointer to be filled with the current cursor path, or %NULL
13186  * @focus_column: (out) (transfer none) (allow-none): A pointer to be filled with the current focus column, or %NULL
13187  *
13188  * Fills in @path and @focus_column with the current path and focus column.  If
13189  * the cursor isn't currently set, then *@path will be %NULL.  If no column
13190  * currently has focus, then *@focus_column will be %NULL.
13191  *
13192  * The returned #GtkTreePath must be freed with gtk_tree_path_free() when
13193  * you are done with it.
13194  **/
13195 void
13196 gtk_tree_view_get_cursor (GtkTreeView        *tree_view,
13197                           GtkTreePath       **path,
13198                           GtkTreeViewColumn **focus_column)
13199 {
13200   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13201
13202   if (path)
13203     {
13204       if (gtk_tree_row_reference_valid (tree_view->priv->cursor))
13205         *path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
13206       else
13207         *path = NULL;
13208     }
13209
13210   if (focus_column)
13211     {
13212       *focus_column = tree_view->priv->focus_column;
13213     }
13214 }
13215
13216 /**
13217  * gtk_tree_view_set_cursor:
13218  * @tree_view: A #GtkTreeView
13219  * @path: A #GtkTreePath
13220  * @focus_column: (allow-none): A #GtkTreeViewColumn, or %NULL
13221  * @start_editing: %TRUE if the specified cell should start being edited.
13222  *
13223  * Sets the current keyboard focus to be at @path, and selects it.  This is
13224  * useful when you want to focus the user's attention on a particular row.  If
13225  * @focus_column is not %NULL, then focus is given to the column specified by
13226  * it. Additionally, if @focus_column is specified, and @start_editing is
13227  * %TRUE, then editing should be started in the specified cell.
13228  * This function is often followed by @gtk_widget_grab_focus (@tree_view)
13229  * in order to give keyboard focus to the widget.  Please note that editing
13230  * can only happen when the widget is realized.
13231  *
13232  * If @path is invalid for @model, the current cursor (if any) will be unset
13233  * and the function will return without failing.
13234  **/
13235 void
13236 gtk_tree_view_set_cursor (GtkTreeView       *tree_view,
13237                           GtkTreePath       *path,
13238                           GtkTreeViewColumn *focus_column,
13239                           gboolean           start_editing)
13240 {
13241   gtk_tree_view_set_cursor_on_cell (tree_view, path, focus_column,
13242                                     NULL, start_editing);
13243 }
13244
13245 /**
13246  * gtk_tree_view_set_cursor_on_cell:
13247  * @tree_view: A #GtkTreeView
13248  * @path: A #GtkTreePath
13249  * @focus_column: (allow-none): A #GtkTreeViewColumn, or %NULL
13250  * @focus_cell: (allow-none): A #GtkCellRenderer, or %NULL
13251  * @start_editing: %TRUE if the specified cell should start being edited.
13252  *
13253  * Sets the current keyboard focus to be at @path, and selects it.  This is
13254  * useful when you want to focus the user's attention on a particular row.  If
13255  * @focus_column is not %NULL, then focus is given to the column specified by
13256  * it. If @focus_column and @focus_cell are not %NULL, and @focus_column
13257  * contains 2 or more editable or activatable cells, then focus is given to
13258  * the cell specified by @focus_cell. Additionally, if @focus_column is
13259  * specified, and @start_editing is %TRUE, then editing should be started in
13260  * the specified cell.  This function is often followed by
13261  * @gtk_widget_grab_focus (@tree_view) in order to give keyboard focus to the
13262  * widget.  Please note that editing can only happen when the widget is
13263  * realized.
13264  *
13265  * If @path is invalid for @model, the current cursor (if any) will be unset
13266  * and the function will return without failing.
13267  *
13268  * Since: 2.2
13269  **/
13270 void
13271 gtk_tree_view_set_cursor_on_cell (GtkTreeView       *tree_view,
13272                                   GtkTreePath       *path,
13273                                   GtkTreeViewColumn *focus_column,
13274                                   GtkCellRenderer   *focus_cell,
13275                                   gboolean           start_editing)
13276 {
13277   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13278   g_return_if_fail (path != NULL);
13279   g_return_if_fail (focus_column == NULL || GTK_IS_TREE_VIEW_COLUMN (focus_column));
13280
13281   if (!tree_view->priv->model)
13282     return;
13283
13284   if (focus_cell)
13285     {
13286       g_return_if_fail (focus_column);
13287       g_return_if_fail (GTK_IS_CELL_RENDERER (focus_cell));
13288     }
13289
13290   /* cancel the current editing, if it exists */
13291   if (tree_view->priv->edited_column &&
13292       gtk_cell_area_get_edit_widget
13293       (gtk_cell_layout_get_area (GTK_CELL_LAYOUT (tree_view->priv->edited_column))))
13294     gtk_tree_view_stop_editing (tree_view, TRUE);
13295
13296   gtk_tree_view_real_set_cursor (tree_view, path, TRUE, TRUE);
13297
13298   if (focus_column &&
13299       gtk_tree_view_column_get_visible (focus_column))
13300     {
13301       GList *list;
13302       gboolean column_in_tree = FALSE;
13303
13304       for (list = tree_view->priv->columns; list; list = list->next)
13305         if (list->data == focus_column)
13306           {
13307             column_in_tree = TRUE;
13308             break;
13309           }
13310       g_return_if_fail (column_in_tree);
13311       tree_view->priv->focus_column = focus_column;
13312       if (focus_cell)
13313         gtk_tree_view_column_focus_cell (focus_column, focus_cell);
13314       if (start_editing)
13315         gtk_tree_view_start_editing (tree_view, path, TRUE);
13316     }
13317 }
13318
13319 /**
13320  * gtk_tree_view_get_bin_window:
13321  * @tree_view: A #GtkTreeView
13322  *
13323  * Returns the window that @tree_view renders to.
13324  * This is used primarily to compare to <literal>event->window</literal>
13325  * to confirm that the event on @tree_view is on the right window.
13326  *
13327  * Return value: (transfer none): A #GdkWindow, or %NULL when @tree_view
13328  *     hasn't been realized yet
13329  **/
13330 GdkWindow *
13331 gtk_tree_view_get_bin_window (GtkTreeView *tree_view)
13332 {
13333   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
13334
13335   return tree_view->priv->bin_window;
13336 }
13337
13338 /**
13339  * gtk_tree_view_get_path_at_pos:
13340  * @tree_view: A #GtkTreeView.
13341  * @x: The x position to be identified (relative to bin_window).
13342  * @y: The y position to be identified (relative to bin_window).
13343  * @path: (out) (allow-none): A pointer to a #GtkTreePath pointer to be filled in, or %NULL
13344  * @column: (out) (transfer none) (allow-none): A pointer to a #GtkTreeViewColumn pointer to be filled in, or %NULL
13345  * @cell_x: (out) (allow-none): A pointer where the X coordinate relative to the cell can be placed, or %NULL
13346  * @cell_y: (out) (allow-none): A pointer where the Y coordinate relative to the cell can be placed, or %NULL
13347  *
13348  * Finds the path at the point (@x, @y), relative to bin_window coordinates
13349  * (please see gtk_tree_view_get_bin_window()).
13350  * That is, @x and @y are relative to an events coordinates. @x and @y must
13351  * come from an event on the @tree_view only where <literal>event->window ==
13352  * gtk_tree_view_get_bin_window (<!-- -->)</literal>. It is primarily for
13353  * things like popup menus. If @path is non-%NULL, then it will be filled
13354  * with the #GtkTreePath at that point.  This path should be freed with
13355  * gtk_tree_path_free().  If @column is non-%NULL, then it will be filled
13356  * with the column at that point.  @cell_x and @cell_y return the coordinates
13357  * relative to the cell background (i.e. the @background_area passed to
13358  * gtk_cell_renderer_render()).  This function is only meaningful if
13359  * @tree_view is realized.  Therefore this function will always return %FALSE
13360  * if @tree_view is not realized or does not have a model.
13361  *
13362  * For converting widget coordinates (eg. the ones you get from
13363  * GtkWidget::query-tooltip), please see
13364  * gtk_tree_view_convert_widget_to_bin_window_coords().
13365  *
13366  * Return value: %TRUE if a row exists at that coordinate.
13367  **/
13368 gboolean
13369 gtk_tree_view_get_path_at_pos (GtkTreeView        *tree_view,
13370                                gint                x,
13371                                gint                y,
13372                                GtkTreePath       **path,
13373                                GtkTreeViewColumn **column,
13374                                gint               *cell_x,
13375                                gint               *cell_y)
13376 {
13377   GtkRBTree *tree;
13378   GtkRBNode *node;
13379   gint y_offset;
13380
13381   g_return_val_if_fail (tree_view != NULL, FALSE);
13382
13383   if (path)
13384     *path = NULL;
13385   if (column)
13386     *column = NULL;
13387
13388   if (tree_view->priv->bin_window == NULL)
13389     return FALSE;
13390
13391   if (tree_view->priv->tree == NULL)
13392     return FALSE;
13393
13394   if (x > gtk_adjustment_get_upper (tree_view->priv->hadjustment))
13395     return FALSE;
13396
13397   if (x < 0 || y < 0)
13398     return FALSE;
13399
13400   if (column || cell_x)
13401     {
13402       GtkTreeViewColumn *tmp_column;
13403       GtkTreeViewColumn *last_column = NULL;
13404       GList *list;
13405       gint remaining_x = x;
13406       gboolean found = FALSE;
13407       gboolean rtl;
13408       gint width;
13409
13410       rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
13411       for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
13412            list;
13413            list = (rtl ? list->prev : list->next))
13414         {
13415           tmp_column = list->data;
13416
13417           if (gtk_tree_view_column_get_visible (tmp_column) == FALSE)
13418             continue;
13419
13420           last_column = tmp_column;
13421           width = gtk_tree_view_column_get_width (tmp_column);
13422           if (remaining_x <= width)
13423             {
13424               found = TRUE;
13425
13426               if (column)
13427                 *column = tmp_column;
13428
13429               if (cell_x)
13430                 *cell_x = remaining_x;
13431
13432               break;
13433             }
13434           remaining_x -= width;
13435         }
13436
13437       /* If found is FALSE and there is a last_column, then it the remainder
13438        * space is in that area
13439        */
13440       if (!found)
13441         {
13442           if (last_column)
13443             {
13444               if (column)
13445                 *column = last_column;
13446
13447               if (cell_x)
13448                 *cell_x = gtk_tree_view_column_get_width (last_column) + remaining_x;
13449             }
13450           else
13451             {
13452               return FALSE;
13453             }
13454         }
13455     }
13456
13457   y_offset = _gtk_rbtree_find_offset (tree_view->priv->tree,
13458                                       TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, y),
13459                                       &tree, &node);
13460
13461   if (tree == NULL)
13462     return FALSE;
13463
13464   if (cell_y)
13465     *cell_y = y_offset;
13466
13467   if (path)
13468     *path = _gtk_tree_view_find_path (tree_view, tree, node);
13469
13470   return TRUE;
13471 }
13472
13473
13474 static inline gint
13475 gtk_tree_view_get_cell_area_height (GtkTreeView *tree_view,
13476                                     GtkRBNode   *node,
13477                                     gint         vertical_separator)
13478 {
13479   int height;
13480
13481   /* The "cell" areas are the cell_area passed in to gtk_cell_renderer_render(),
13482    * i.e. just the cells, no spacing.
13483    *
13484    * The cell area height is at least expander_size - vertical_separator.
13485    * For regular nodes, the height is then at least expander_size. We should
13486    * be able to enforce the expander_size minimum here, because this
13487    * function will not be called for irregular (e.g. separator) rows.
13488    */
13489   height = gtk_tree_view_get_row_height (tree_view, node);
13490   if (height < tree_view->priv->expander_size)
13491     height = tree_view->priv->expander_size;
13492
13493   return height - vertical_separator;
13494 }
13495
13496 static inline gint
13497 gtk_tree_view_get_cell_area_y_offset (GtkTreeView *tree_view,
13498                                       GtkRBTree   *tree,
13499                                       GtkRBNode   *node,
13500                                       gint         vertical_separator)
13501 {
13502   int offset;
13503
13504   offset = gtk_tree_view_get_row_y_offset (tree_view, tree, node);
13505   offset += vertical_separator / 2;
13506
13507   return offset;
13508 }
13509
13510 /**
13511  * gtk_tree_view_get_cell_area:
13512  * @tree_view: a #GtkTreeView
13513  * @path: (allow-none): a #GtkTreePath for the row, or %NULL to get only horizontal coordinates
13514  * @column: (allow-none): a #GtkTreeViewColumn for the column, or %NULL to get only vertical coordinates
13515  * @rect: (out): rectangle to fill with cell rect
13516  *
13517  * Fills the bounding rectangle in bin_window coordinates for the cell at the
13518  * row specified by @path and the column specified by @column.  If @path is
13519  * %NULL, or points to a path not currently displayed, the @y and @height fields
13520  * of the rectangle will be filled with 0. If @column is %NULL, the @x and @width
13521  * fields will be filled with 0.  The sum of all cell rects does not cover the
13522  * entire tree; there are extra pixels in between rows, for example. The
13523  * returned rectangle is equivalent to the @cell_area passed to
13524  * gtk_cell_renderer_render().  This function is only valid if @tree_view is
13525  * realized.
13526  **/
13527 void
13528 gtk_tree_view_get_cell_area (GtkTreeView        *tree_view,
13529                              GtkTreePath        *path,
13530                              GtkTreeViewColumn  *column,
13531                              GdkRectangle       *rect)
13532 {
13533   GtkRBTree *tree = NULL;
13534   GtkRBNode *node = NULL;
13535   gint vertical_separator;
13536   gint horizontal_separator;
13537
13538   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13539   g_return_if_fail (column == NULL || GTK_IS_TREE_VIEW_COLUMN (column));
13540   g_return_if_fail (rect != NULL);
13541   g_return_if_fail (!column || gtk_tree_view_column_get_tree_view (column) == (GtkWidget *) tree_view);
13542   g_return_if_fail (gtk_widget_get_realized (GTK_WIDGET (tree_view)));
13543
13544   gtk_widget_style_get (GTK_WIDGET (tree_view),
13545                         "vertical-separator", &vertical_separator,
13546                         "horizontal-separator", &horizontal_separator,
13547                         NULL);
13548
13549   rect->x = 0;
13550   rect->y = 0;
13551   rect->width = 0;
13552   rect->height = 0;
13553
13554   if (column)
13555     {
13556       rect->x = gtk_tree_view_column_get_x_offset (column) + horizontal_separator/2;
13557       rect->width = gtk_tree_view_column_get_width (column) - horizontal_separator;
13558     }
13559
13560   if (path)
13561     {
13562       gboolean ret = _gtk_tree_view_find_node (tree_view, path, &tree, &node);
13563
13564       /* Get vertical coords */
13565       if ((!ret && tree == NULL) || ret)
13566         return;
13567
13568       if (row_is_separator (tree_view, NULL, path))
13569         {
13570           /* There isn't really a "cell area" for separator, so we
13571            * return the y, height values for background area instead.
13572            */
13573           rect->y = gtk_tree_view_get_row_y_offset (tree_view, tree, node);
13574           rect->height = gtk_tree_view_get_row_height (tree_view, node);
13575         }
13576       else
13577         {
13578           rect->y = gtk_tree_view_get_cell_area_y_offset (tree_view, tree, node,
13579                                                           vertical_separator);
13580           rect->height = gtk_tree_view_get_cell_area_height (tree_view, node,
13581                                                              vertical_separator);
13582         }
13583
13584       if (column &&
13585           gtk_tree_view_is_expander_column (tree_view, column))
13586         {
13587           gint depth = gtk_tree_path_get_depth (path);
13588           gboolean rtl;
13589
13590           rtl = gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL;
13591
13592           if (!rtl)
13593             rect->x += (depth - 1) * tree_view->priv->level_indentation;
13594           rect->width -= (depth - 1) * tree_view->priv->level_indentation;
13595
13596           if (gtk_tree_view_draw_expanders (tree_view))
13597             {
13598               if (!rtl)
13599                 rect->x += depth * tree_view->priv->expander_size;
13600               rect->width -= depth * tree_view->priv->expander_size;
13601             }
13602
13603           rect->width = MAX (rect->width, 0);
13604         }
13605     }
13606 }
13607
13608 static inline gint
13609 gtk_tree_view_get_row_height (GtkTreeView *tree_view,
13610                               GtkRBNode   *node)
13611 {
13612   int height;
13613
13614   /* The "background" areas of all rows/cells add up to cover the entire tree.
13615    * The background includes all inter-row and inter-cell spacing.
13616    *
13617    * If the row pointed at by node does not have a height set, we default
13618    * to expander_size, which is the minimum height for regular nodes.
13619    * Non-regular nodes (e.g. separators) can have a height set smaller
13620    * than expander_size and should not be overruled here.
13621    */
13622   height = GTK_RBNODE_GET_HEIGHT (node);
13623   if (height <= 0)
13624     height = tree_view->priv->expander_size;
13625
13626   return height;
13627 }
13628
13629 static inline gint
13630 gtk_tree_view_get_row_y_offset (GtkTreeView *tree_view,
13631                                 GtkRBTree   *tree,
13632                                 GtkRBNode   *node)
13633 {
13634   int offset;
13635
13636   offset = _gtk_rbtree_node_find_offset (tree, node);
13637
13638   return RBTREE_Y_TO_TREE_WINDOW_Y (tree_view, offset);
13639 }
13640
13641 /**
13642  * gtk_tree_view_get_background_area:
13643  * @tree_view: a #GtkTreeView
13644  * @path: (allow-none): a #GtkTreePath for the row, or %NULL to get only horizontal coordinates
13645  * @column: (allow-none): a #GtkTreeViewColumn for the column, or %NULL to get only vertical coordiantes
13646  * @rect: (out): rectangle to fill with cell background rect
13647  *
13648  * Fills the bounding rectangle in bin_window coordinates for the cell at the
13649  * row specified by @path and the column specified by @column.  If @path is
13650  * %NULL, or points to a node not found in the tree, the @y and @height fields of
13651  * the rectangle will be filled with 0. If @column is %NULL, the @x and @width
13652  * fields will be filled with 0.  The returned rectangle is equivalent to the
13653  * @background_area passed to gtk_cell_renderer_render().  These background
13654  * areas tile to cover the entire bin window.  Contrast with the @cell_area,
13655  * returned by gtk_tree_view_get_cell_area(), which returns only the cell
13656  * itself, excluding surrounding borders and the tree expander area.
13657  *
13658  **/
13659 void
13660 gtk_tree_view_get_background_area (GtkTreeView        *tree_view,
13661                                    GtkTreePath        *path,
13662                                    GtkTreeViewColumn  *column,
13663                                    GdkRectangle       *rect)
13664 {
13665   GtkRBTree *tree = NULL;
13666   GtkRBNode *node = NULL;
13667
13668   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13669   g_return_if_fail (column == NULL || GTK_IS_TREE_VIEW_COLUMN (column));
13670   g_return_if_fail (rect != NULL);
13671
13672   rect->x = 0;
13673   rect->y = 0;
13674   rect->width = 0;
13675   rect->height = 0;
13676
13677   if (path)
13678     {
13679       /* Get vertical coords */
13680
13681       if (!_gtk_tree_view_find_node (tree_view, path, &tree, &node) &&
13682           tree == NULL)
13683         return;
13684
13685       rect->y = gtk_tree_view_get_row_y_offset (tree_view, tree, node);
13686       rect->height = gtk_tree_view_get_row_height (tree_view, node);
13687     }
13688
13689   if (column)
13690     {
13691       gint x2 = 0;
13692
13693       gtk_tree_view_get_background_xrange (tree_view, tree, column, &rect->x, &x2);
13694       rect->width = x2 - rect->x;
13695     }
13696 }
13697
13698 /**
13699  * gtk_tree_view_get_visible_rect:
13700  * @tree_view: a #GtkTreeView
13701  * @visible_rect: (out): rectangle to fill
13702  *
13703  * Fills @visible_rect with the currently-visible region of the
13704  * buffer, in tree coordinates. Convert to bin_window coordinates with
13705  * gtk_tree_view_convert_tree_to_bin_window_coords().
13706  * Tree coordinates start at 0,0 for row 0 of the tree, and cover the entire
13707  * scrollable area of the tree.
13708  **/
13709 void
13710 gtk_tree_view_get_visible_rect (GtkTreeView  *tree_view,
13711                                 GdkRectangle *visible_rect)
13712 {
13713   GtkAllocation allocation;
13714   GtkWidget *widget;
13715
13716   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13717
13718   widget = GTK_WIDGET (tree_view);
13719
13720   if (visible_rect)
13721     {
13722       gtk_widget_get_allocation (widget, &allocation);
13723       visible_rect->x = gtk_adjustment_get_value (tree_view->priv->hadjustment);
13724       visible_rect->y = gtk_adjustment_get_value (tree_view->priv->vadjustment);
13725       visible_rect->width = allocation.width;
13726       visible_rect->height = allocation.height - gtk_tree_view_get_effective_header_height (tree_view);
13727     }
13728 }
13729
13730 /**
13731  * gtk_tree_view_convert_widget_to_tree_coords:
13732  * @tree_view: a #GtkTreeView
13733  * @wx: X coordinate relative to the widget
13734  * @wy: Y coordinate relative to the widget
13735  * @tx: (out): return location for tree X coordinate
13736  * @ty: (out): return location for tree Y coordinate
13737  *
13738  * Converts widget coordinates to coordinates for the
13739  * tree (the full scrollable area of the tree).
13740  *
13741  * Since: 2.12
13742  **/
13743 void
13744 gtk_tree_view_convert_widget_to_tree_coords (GtkTreeView *tree_view,
13745                                              gint         wx,
13746                                              gint         wy,
13747                                              gint        *tx,
13748                                              gint        *ty)
13749 {
13750   gint x, y;
13751
13752   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13753
13754   gtk_tree_view_convert_widget_to_bin_window_coords (tree_view,
13755                                                      wx, wy,
13756                                                      &x, &y);
13757   gtk_tree_view_convert_bin_window_to_tree_coords (tree_view,
13758                                                    x, y,
13759                                                    tx, ty);
13760 }
13761
13762 /**
13763  * gtk_tree_view_convert_tree_to_widget_coords:
13764  * @tree_view: a #GtkTreeView
13765  * @tx: X coordinate relative to the tree
13766  * @ty: Y coordinate relative to the tree
13767  * @wx: (out): return location for widget X coordinate
13768  * @wy: (out): return location for widget Y coordinate
13769  *
13770  * Converts tree coordinates (coordinates in full scrollable area of the tree)
13771  * to widget coordinates.
13772  *
13773  * Since: 2.12
13774  **/
13775 void
13776 gtk_tree_view_convert_tree_to_widget_coords (GtkTreeView *tree_view,
13777                                              gint         tx,
13778                                              gint         ty,
13779                                              gint        *wx,
13780                                              gint        *wy)
13781 {
13782   gint x, y;
13783
13784   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13785
13786   gtk_tree_view_convert_tree_to_bin_window_coords (tree_view,
13787                                                    tx, ty,
13788                                                    &x, &y);
13789   gtk_tree_view_convert_bin_window_to_widget_coords (tree_view,
13790                                                      x, y,
13791                                                      wx, wy);
13792 }
13793
13794 /**
13795  * gtk_tree_view_convert_widget_to_bin_window_coords:
13796  * @tree_view: a #GtkTreeView
13797  * @wx: X coordinate relative to the widget
13798  * @wy: Y coordinate relative to the widget
13799  * @bx: (out): return location for bin_window X coordinate
13800  * @by: (out): return location for bin_window Y coordinate
13801  *
13802  * Converts widget coordinates to coordinates for the bin_window
13803  * (see gtk_tree_view_get_bin_window()).
13804  *
13805  * Since: 2.12
13806  **/
13807 void
13808 gtk_tree_view_convert_widget_to_bin_window_coords (GtkTreeView *tree_view,
13809                                                    gint         wx,
13810                                                    gint         wy,
13811                                                    gint        *bx,
13812                                                    gint        *by)
13813 {
13814   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13815
13816   if (bx)
13817     *bx = wx + gtk_adjustment_get_value (tree_view->priv->hadjustment);
13818   if (by)
13819     *by = wy - gtk_tree_view_get_effective_header_height (tree_view);
13820 }
13821
13822 /**
13823  * gtk_tree_view_convert_bin_window_to_widget_coords:
13824  * @tree_view: a #GtkTreeView
13825  * @bx: bin_window X coordinate
13826  * @by: bin_window Y coordinate
13827  * @wx: (out): return location for widget X coordinate
13828  * @wy: (out): return location for widget Y coordinate
13829  *
13830  * Converts bin_window coordinates (see gtk_tree_view_get_bin_window())
13831  * to widget relative coordinates.
13832  *
13833  * Since: 2.12
13834  **/
13835 void
13836 gtk_tree_view_convert_bin_window_to_widget_coords (GtkTreeView *tree_view,
13837                                                    gint         bx,
13838                                                    gint         by,
13839                                                    gint        *wx,
13840                                                    gint        *wy)
13841 {
13842   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13843
13844   if (wx)
13845     *wx = bx - gtk_adjustment_get_value (tree_view->priv->hadjustment);
13846   if (wy)
13847     *wy = by + gtk_tree_view_get_effective_header_height (tree_view);
13848 }
13849
13850 /**
13851  * gtk_tree_view_convert_tree_to_bin_window_coords:
13852  * @tree_view: a #GtkTreeView
13853  * @tx: tree X coordinate
13854  * @ty: tree Y coordinate
13855  * @bx: (out): return location for X coordinate relative to bin_window
13856  * @by: (out): return location for Y coordinate relative to bin_window
13857  *
13858  * Converts tree coordinates (coordinates in full scrollable area of the tree)
13859  * to bin_window coordinates.
13860  *
13861  * Since: 2.12
13862  **/
13863 void
13864 gtk_tree_view_convert_tree_to_bin_window_coords (GtkTreeView *tree_view,
13865                                                  gint         tx,
13866                                                  gint         ty,
13867                                                  gint        *bx,
13868                                                  gint        *by)
13869 {
13870   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13871
13872   if (bx)
13873     *bx = tx;
13874   if (by)
13875     *by = ty - tree_view->priv->dy;
13876 }
13877
13878 /**
13879  * gtk_tree_view_convert_bin_window_to_tree_coords:
13880  * @tree_view: a #GtkTreeView
13881  * @bx: X coordinate relative to bin_window
13882  * @by: Y coordinate relative to bin_window
13883  * @tx: (out): return location for tree X coordinate
13884  * @ty: (out): return location for tree Y coordinate
13885  *
13886  * Converts bin_window coordinates to coordinates for the
13887  * tree (the full scrollable area of the tree).
13888  *
13889  * Since: 2.12
13890  **/
13891 void
13892 gtk_tree_view_convert_bin_window_to_tree_coords (GtkTreeView *tree_view,
13893                                                  gint         bx,
13894                                                  gint         by,
13895                                                  gint        *tx,
13896                                                  gint        *ty)
13897 {
13898   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13899
13900   if (tx)
13901     *tx = bx;
13902   if (ty)
13903     *ty = by + tree_view->priv->dy;
13904 }
13905
13906
13907
13908 /**
13909  * gtk_tree_view_get_visible_range:
13910  * @tree_view: A #GtkTreeView
13911  * @start_path: (out) (allow-none): Return location for start of region,
13912  *              or %NULL.
13913  * @end_path: (out) (allow-none): Return location for end of region, or %NULL.
13914  *
13915  * Sets @start_path and @end_path to be the first and last visible path.
13916  * Note that there may be invisible paths in between.
13917  *
13918  * The paths should be freed with gtk_tree_path_free() after use.
13919  *
13920  * Returns: %TRUE, if valid paths were placed in @start_path and @end_path.
13921  *
13922  * Since: 2.8
13923  **/
13924 gboolean
13925 gtk_tree_view_get_visible_range (GtkTreeView  *tree_view,
13926                                  GtkTreePath **start_path,
13927                                  GtkTreePath **end_path)
13928 {
13929   GtkRBTree *tree;
13930   GtkRBNode *node;
13931   gboolean retval;
13932
13933   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
13934
13935   if (!tree_view->priv->tree)
13936     return FALSE;
13937
13938   retval = TRUE;
13939
13940   if (start_path)
13941     {
13942       _gtk_rbtree_find_offset (tree_view->priv->tree,
13943                                TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, 0),
13944                                &tree, &node);
13945       if (node)
13946         *start_path = _gtk_tree_view_find_path (tree_view, tree, node);
13947       else
13948         retval = FALSE;
13949     }
13950
13951   if (end_path)
13952     {
13953       gint y;
13954
13955       if (tree_view->priv->height < gtk_adjustment_get_page_size (tree_view->priv->vadjustment))
13956         y = tree_view->priv->height - 1;
13957       else
13958         y = TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, gtk_adjustment_get_page_size (tree_view->priv->vadjustment)) - 1;
13959
13960       _gtk_rbtree_find_offset (tree_view->priv->tree, y, &tree, &node);
13961       if (node)
13962         *end_path = _gtk_tree_view_find_path (tree_view, tree, node);
13963       else
13964         retval = FALSE;
13965     }
13966
13967   return retval;
13968 }
13969
13970 /**
13971  * gtk_tree_view_is_blank_at_pos:
13972  * @tree_view: A #GtkTreeView
13973  * @x: The x position to be identified (relative to bin_window)
13974  * @y: The y position to be identified (relative to bin_window)
13975  * @path: (out) (allow-none): A pointer to a #GtkTreePath pointer to be filled in, or %NULL
13976  * @column: (out) (allow-none): A pointer to a #GtkTreeViewColumn pointer to be filled in, or %NULL
13977  * @cell_x: (out) (allow-none): A pointer where the X coordinate relative to the cell can be placed, or %NULL
13978  * @cell_y: (out) (allow-none): A pointer where the Y coordinate relative to the cell can be placed, or %NULL
13979  *
13980  * Determine whether the point (@x, @y) in @tree_view is blank, that is no
13981  * cell content nor an expander arrow is drawn at the location. If so, the
13982  * location can be considered as the background. You might wish to take
13983  * special action on clicks on the background, such as clearing a current
13984  * selection, having a custom context menu or starting rubber banding.
13985  *
13986  * The @x and @y coordinate that are provided must be relative to bin_window
13987  * coordinates.  That is, @x and @y must come from an event on @tree_view
13988  * where <literal>event->window == gtk_tree_view_get_bin_window (<!-- -->)</literal>.
13989  *
13990  * For converting widget coordinates (eg. the ones you get from
13991  * GtkWidget::query-tooltip), please see
13992  * gtk_tree_view_convert_widget_to_bin_window_coords().
13993  *
13994  * The @path, @column, @cell_x and @cell_y arguments will be filled in
13995  * likewise as for gtk_tree_view_get_path_at_pos().  Please see
13996  * gtk_tree_view_get_path_at_pos() for more information.
13997  *
13998  * Return value: %TRUE if the area at the given coordinates is blank,
13999  * %FALSE otherwise.
14000  *
14001  * Since: 3.0
14002  */
14003 gboolean
14004 gtk_tree_view_is_blank_at_pos (GtkTreeView       *tree_view,
14005                                gint                x,
14006                                gint                y,
14007                                GtkTreePath       **path,
14008                                GtkTreeViewColumn **column,
14009                                gint               *cell_x,
14010                                gint               *cell_y)
14011 {
14012   GtkRBTree *tree;
14013   GtkRBNode *node;
14014   GtkTreeIter iter;
14015   GtkTreePath *real_path;
14016   GtkTreeViewColumn *real_column;
14017   GdkRectangle cell_area, background_area;
14018
14019   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
14020
14021   if (!gtk_tree_view_get_path_at_pos (tree_view, x, y,
14022                                       &real_path, &real_column,
14023                                       cell_x, cell_y))
14024     /* If there's no path here, it is blank */
14025     return TRUE;
14026
14027   if (path)
14028     *path = real_path;
14029
14030   if (column)
14031     *column = real_column;
14032
14033   gtk_tree_model_get_iter (tree_view->priv->model, &iter, real_path);
14034   _gtk_tree_view_find_node (tree_view, real_path, &tree, &node);
14035
14036   /* Check if there's an expander arrow at (x, y) */
14037   if (real_column == tree_view->priv->expander_column
14038       && gtk_tree_view_draw_expanders (tree_view))
14039     {
14040       gboolean over_arrow;
14041
14042       over_arrow = coords_are_over_arrow (tree_view, tree, node, x, y);
14043
14044       if (over_arrow)
14045         {
14046           if (!path)
14047             gtk_tree_path_free (real_path);
14048           return FALSE;
14049         }
14050     }
14051
14052   /* Otherwise, have the column see if there's a cell at (x, y) */
14053   gtk_tree_view_column_cell_set_cell_data (real_column,
14054                                            tree_view->priv->model,
14055                                            &iter,
14056                                            GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT),
14057                                            node->children ? TRUE : FALSE);
14058
14059   gtk_tree_view_get_background_area (tree_view, real_path, real_column,
14060                                      &background_area);
14061   gtk_tree_view_get_cell_area (tree_view, real_path, real_column,
14062                                &cell_area);
14063
14064   if (!path)
14065     gtk_tree_path_free (real_path);
14066
14067   return _gtk_tree_view_column_is_blank_at_pos (real_column,
14068                                                 &cell_area,
14069                                                 &background_area,
14070                                                 x, y);
14071 }
14072
14073 static void
14074 unset_reorderable (GtkTreeView *tree_view)
14075 {
14076   if (tree_view->priv->reorderable)
14077     {
14078       tree_view->priv->reorderable = FALSE;
14079       g_object_notify (G_OBJECT (tree_view), "reorderable");
14080     }
14081 }
14082
14083 /**
14084  * gtk_tree_view_enable_model_drag_source:
14085  * @tree_view: a #GtkTreeView
14086  * @start_button_mask: Mask of allowed buttons to start drag
14087  * @targets: (array length=n_targets): the table of targets that the drag will support
14088  * @n_targets: the number of items in @targets
14089  * @actions: the bitmask of possible actions for a drag from this
14090  *    widget
14091  *
14092  * Turns @tree_view into a drag source for automatic DND. Calling this
14093  * method sets #GtkTreeView:reorderable to %FALSE.
14094  **/
14095 void
14096 gtk_tree_view_enable_model_drag_source (GtkTreeView              *tree_view,
14097                                         GdkModifierType           start_button_mask,
14098                                         const GtkTargetEntry     *targets,
14099                                         gint                      n_targets,
14100                                         GdkDragAction             actions)
14101 {
14102   TreeViewDragInfo *di;
14103
14104   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14105
14106   gtk_drag_source_set (GTK_WIDGET (tree_view),
14107                        0,
14108                        targets,
14109                        n_targets,
14110                        actions);
14111
14112   di = ensure_info (tree_view);
14113
14114   di->start_button_mask = start_button_mask;
14115   di->source_actions = actions;
14116   di->source_set = TRUE;
14117
14118   unset_reorderable (tree_view);
14119 }
14120
14121 /**
14122  * gtk_tree_view_enable_model_drag_dest:
14123  * @tree_view: a #GtkTreeView
14124  * @targets: (array length=n_targets): the table of targets that
14125  *           the drag will support
14126  * @n_targets: the number of items in @targets
14127  * @actions: the bitmask of possible actions for a drag from this
14128  *    widget
14129  *
14130  * Turns @tree_view into a drop destination for automatic DND. Calling
14131  * this method sets #GtkTreeView:reorderable to %FALSE.
14132  **/
14133 void
14134 gtk_tree_view_enable_model_drag_dest (GtkTreeView              *tree_view,
14135                                       const GtkTargetEntry     *targets,
14136                                       gint                      n_targets,
14137                                       GdkDragAction             actions)
14138 {
14139   TreeViewDragInfo *di;
14140
14141   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14142
14143   gtk_drag_dest_set (GTK_WIDGET (tree_view),
14144                      0,
14145                      targets,
14146                      n_targets,
14147                      actions);
14148
14149   di = ensure_info (tree_view);
14150   di->dest_set = TRUE;
14151
14152   unset_reorderable (tree_view);
14153 }
14154
14155 /**
14156  * gtk_tree_view_unset_rows_drag_source:
14157  * @tree_view: a #GtkTreeView
14158  *
14159  * Undoes the effect of
14160  * gtk_tree_view_enable_model_drag_source(). Calling this method sets
14161  * #GtkTreeView:reorderable to %FALSE.
14162  **/
14163 void
14164 gtk_tree_view_unset_rows_drag_source (GtkTreeView *tree_view)
14165 {
14166   TreeViewDragInfo *di;
14167
14168   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14169
14170   di = get_info (tree_view);
14171
14172   if (di)
14173     {
14174       if (di->source_set)
14175         {
14176           gtk_drag_source_unset (GTK_WIDGET (tree_view));
14177           di->source_set = FALSE;
14178         }
14179
14180       if (!di->dest_set && !di->source_set)
14181         remove_info (tree_view);
14182     }
14183
14184   unset_reorderable (tree_view);
14185 }
14186
14187 /**
14188  * gtk_tree_view_unset_rows_drag_dest:
14189  * @tree_view: a #GtkTreeView
14190  *
14191  * Undoes the effect of
14192  * gtk_tree_view_enable_model_drag_dest(). Calling this method sets
14193  * #GtkTreeView:reorderable to %FALSE.
14194  **/
14195 void
14196 gtk_tree_view_unset_rows_drag_dest (GtkTreeView *tree_view)
14197 {
14198   TreeViewDragInfo *di;
14199
14200   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14201
14202   di = get_info (tree_view);
14203
14204   if (di)
14205     {
14206       if (di->dest_set)
14207         {
14208           gtk_drag_dest_unset (GTK_WIDGET (tree_view));
14209           di->dest_set = FALSE;
14210         }
14211
14212       if (!di->dest_set && !di->source_set)
14213         remove_info (tree_view);
14214     }
14215
14216   unset_reorderable (tree_view);
14217 }
14218
14219 /**
14220  * gtk_tree_view_set_drag_dest_row:
14221  * @tree_view: a #GtkTreeView
14222  * @path: (allow-none): The path of the row to highlight, or %NULL
14223  * @pos: Specifies whether to drop before, after or into the row
14224  *
14225  * Sets the row that is highlighted for feedback.
14226  * If @path is %NULL, an existing highlight is removed.
14227  */
14228 void
14229 gtk_tree_view_set_drag_dest_row (GtkTreeView            *tree_view,
14230                                  GtkTreePath            *path,
14231                                  GtkTreeViewDropPosition pos)
14232 {
14233   GtkTreePath *current_dest;
14234
14235   /* Note; this function is exported to allow a custom DND
14236    * implementation, so it can't touch TreeViewDragInfo
14237    */
14238
14239   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14240
14241   current_dest = NULL;
14242
14243   if (tree_view->priv->drag_dest_row)
14244     {
14245       current_dest = gtk_tree_row_reference_get_path (tree_view->priv->drag_dest_row);
14246       gtk_tree_row_reference_free (tree_view->priv->drag_dest_row);
14247     }
14248
14249   /* special case a drop on an empty model */
14250   tree_view->priv->empty_view_drop = 0;
14251
14252   if (pos == GTK_TREE_VIEW_DROP_BEFORE && path
14253       && gtk_tree_path_get_depth (path) == 1
14254       && gtk_tree_path_get_indices (path)[0] == 0)
14255     {
14256       gint n_children;
14257
14258       n_children = gtk_tree_model_iter_n_children (tree_view->priv->model,
14259                                                    NULL);
14260
14261       if (!n_children)
14262         tree_view->priv->empty_view_drop = 1;
14263     }
14264
14265   tree_view->priv->drag_dest_pos = pos;
14266
14267   if (path)
14268     {
14269       tree_view->priv->drag_dest_row =
14270         gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view), tree_view->priv->model, path);
14271       gtk_tree_view_queue_draw_path (tree_view, path, NULL);
14272     }
14273   else
14274     tree_view->priv->drag_dest_row = NULL;
14275
14276   if (current_dest)
14277     {
14278       GtkRBTree *tree, *new_tree;
14279       GtkRBNode *node, *new_node;
14280
14281       _gtk_tree_view_find_node (tree_view, current_dest, &tree, &node);
14282       _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
14283
14284       if (tree && node)
14285         {
14286           _gtk_rbtree_next_full (tree, node, &new_tree, &new_node);
14287           if (new_tree && new_node)
14288             _gtk_tree_view_queue_draw_node (tree_view, new_tree, new_node, NULL);
14289
14290           _gtk_rbtree_prev_full (tree, node, &new_tree, &new_node);
14291           if (new_tree && new_node)
14292             _gtk_tree_view_queue_draw_node (tree_view, new_tree, new_node, NULL);
14293         }
14294       gtk_tree_path_free (current_dest);
14295     }
14296 }
14297
14298 /**
14299  * gtk_tree_view_get_drag_dest_row:
14300  * @tree_view: a #GtkTreeView
14301  * @path: (out) (allow-none): Return location for the path of the highlighted row, or %NULL.
14302  * @pos: (out) (allow-none): Return location for the drop position, or %NULL
14303  *
14304  * Gets information about the row that is highlighted for feedback.
14305  **/
14306 void
14307 gtk_tree_view_get_drag_dest_row (GtkTreeView              *tree_view,
14308                                  GtkTreePath             **path,
14309                                  GtkTreeViewDropPosition  *pos)
14310 {
14311   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14312
14313   if (path)
14314     {
14315       if (tree_view->priv->drag_dest_row)
14316         *path = gtk_tree_row_reference_get_path (tree_view->priv->drag_dest_row);
14317       else
14318         {
14319           if (tree_view->priv->empty_view_drop)
14320             *path = gtk_tree_path_new_from_indices (0, -1);
14321           else
14322             *path = NULL;
14323         }
14324     }
14325
14326   if (pos)
14327     *pos = tree_view->priv->drag_dest_pos;
14328 }
14329
14330 /**
14331  * gtk_tree_view_get_dest_row_at_pos:
14332  * @tree_view: a #GtkTreeView
14333  * @drag_x: the position to determine the destination row for
14334  * @drag_y: the position to determine the destination row for
14335  * @path: (out) (allow-none): Return location for the path of the highlighted row, or %NULL.
14336  * @pos: (out) (allow-none): Return location for the drop position, or %NULL
14337  *
14338  * Determines the destination row for a given position.  @drag_x and
14339  * @drag_y are expected to be in widget coordinates.  This function is only
14340  * meaningful if @tree_view is realized.  Therefore this function will always
14341  * return %FALSE if @tree_view is not realized or does not have a model.
14342  *
14343  * Return value: whether there is a row at the given position, %TRUE if this
14344  * is indeed the case.
14345  **/
14346 gboolean
14347 gtk_tree_view_get_dest_row_at_pos (GtkTreeView             *tree_view,
14348                                    gint                     drag_x,
14349                                    gint                     drag_y,
14350                                    GtkTreePath            **path,
14351                                    GtkTreeViewDropPosition *pos)
14352 {
14353   gint cell_y;
14354   gint bin_x, bin_y;
14355   gdouble offset_into_row;
14356   gdouble third;
14357   GdkRectangle cell;
14358   GtkTreeViewColumn *column = NULL;
14359   GtkTreePath *tmp_path = NULL;
14360
14361   /* Note; this function is exported to allow a custom DND
14362    * implementation, so it can't touch TreeViewDragInfo
14363    */
14364
14365   g_return_val_if_fail (tree_view != NULL, FALSE);
14366   g_return_val_if_fail (drag_x >= 0, FALSE);
14367   g_return_val_if_fail (drag_y >= 0, FALSE);
14368
14369   if (path)
14370     *path = NULL;
14371
14372   if (tree_view->priv->bin_window == NULL)
14373     return FALSE;
14374
14375   if (tree_view->priv->tree == NULL)
14376     return FALSE;
14377
14378   /* If in the top third of a row, we drop before that row; if
14379    * in the bottom third, drop after that row; if in the middle,
14380    * and the row has children, drop into the row.
14381    */
14382   gtk_tree_view_convert_widget_to_bin_window_coords (tree_view, drag_x, drag_y,
14383                                                      &bin_x, &bin_y);
14384
14385   if (!gtk_tree_view_get_path_at_pos (tree_view,
14386                                       bin_x,
14387                                       bin_y,
14388                                       &tmp_path,
14389                                       &column,
14390                                       NULL,
14391                                       &cell_y))
14392     return FALSE;
14393
14394   gtk_tree_view_get_background_area (tree_view, tmp_path, column,
14395                                      &cell);
14396
14397   offset_into_row = cell_y;
14398
14399   if (path)
14400     *path = tmp_path;
14401   else
14402     gtk_tree_path_free (tmp_path);
14403
14404   tmp_path = NULL;
14405
14406   third = cell.height / 3.0;
14407
14408   if (pos)
14409     {
14410       if (offset_into_row < third)
14411         {
14412           *pos = GTK_TREE_VIEW_DROP_BEFORE;
14413         }
14414       else if (offset_into_row < (cell.height / 2.0))
14415         {
14416           *pos = GTK_TREE_VIEW_DROP_INTO_OR_BEFORE;
14417         }
14418       else if (offset_into_row < third * 2.0)
14419         {
14420           *pos = GTK_TREE_VIEW_DROP_INTO_OR_AFTER;
14421         }
14422       else
14423         {
14424           *pos = GTK_TREE_VIEW_DROP_AFTER;
14425         }
14426     }
14427
14428   return TRUE;
14429 }
14430
14431
14432
14433 /* KEEP IN SYNC WITH GTK_TREE_VIEW_BIN_EXPOSE */
14434 /**
14435  * gtk_tree_view_create_row_drag_icon:
14436  * @tree_view: a #GtkTreeView
14437  * @path: a #GtkTreePath in @tree_view
14438  *
14439  * Creates a #cairo_surface_t representation of the row at @path.
14440  * This image is used for a drag icon.
14441  *
14442  * Return value: (transfer full): a newly-allocated surface of the drag icon.
14443  **/
14444 cairo_surface_t *
14445 gtk_tree_view_create_row_drag_icon (GtkTreeView  *tree_view,
14446                                     GtkTreePath  *path)
14447 {
14448   GtkTreeIter   iter;
14449   GtkRBTree    *tree;
14450   GtkRBNode    *node;
14451   GtkStyleContext *context;
14452   GtkStateFlags state;
14453   gint cell_offset;
14454   GList *list;
14455   GdkRectangle background_area;
14456   GtkWidget *widget;
14457   gint depth;
14458   /* start drawing inside the black outline */
14459   gint x = 1, y = 1;
14460   cairo_surface_t *surface;
14461   gint bin_window_width;
14462   gboolean is_separator = FALSE;
14463   gboolean rtl, allow_rules;
14464   cairo_t *cr;
14465
14466   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
14467   g_return_val_if_fail (path != NULL, NULL);
14468
14469   widget = GTK_WIDGET (tree_view);
14470
14471   if (!gtk_widget_get_realized (widget))
14472     return NULL;
14473
14474   depth = gtk_tree_path_get_depth (path);
14475
14476   _gtk_tree_view_find_node (tree_view,
14477                             path,
14478                             &tree,
14479                             &node);
14480
14481   if (tree == NULL)
14482     return NULL;
14483
14484   if (!gtk_tree_model_get_iter (tree_view->priv->model,
14485                                 &iter,
14486                                 path))
14487     return NULL;
14488
14489   context = gtk_widget_get_style_context (widget);
14490
14491   gtk_style_context_save (context);
14492
14493   state = gtk_widget_get_state_flags (widget);
14494   gtk_style_context_set_state (context, state);
14495
14496   gtk_style_context_add_class (context, GTK_STYLE_CLASS_VIEW);
14497   gtk_style_context_add_region (context, GTK_STYLE_REGION_COLUMN, 0);
14498
14499   gtk_widget_style_get (widget,
14500                         "allow-rules", &allow_rules,
14501                         NULL);
14502
14503   if (allow_rules && tree_view->priv->has_rules)
14504     {
14505       GtkRegionFlags row_flags;
14506
14507       if (_gtk_rbtree_node_find_parity (tree, node))
14508         row_flags = GTK_REGION_ODD;
14509       else
14510         row_flags = GTK_REGION_EVEN;
14511
14512       gtk_style_context_add_region (context, GTK_STYLE_REGION_ROW, row_flags);
14513     }
14514
14515   is_separator = row_is_separator (tree_view, &iter, NULL);
14516
14517   cell_offset = x;
14518
14519   background_area.y = y;
14520   background_area.height = gtk_tree_view_get_row_height (tree_view, node);
14521
14522   bin_window_width = gdk_window_get_width (tree_view->priv->bin_window);
14523
14524   surface = gdk_window_create_similar_surface (tree_view->priv->bin_window,
14525                                                CAIRO_CONTENT_COLOR,
14526                                                bin_window_width + 2,
14527                                                background_area.height + 2);
14528
14529   cr = cairo_create (surface);
14530
14531   gtk_render_background (context, cr, 0, 0,
14532                          bin_window_width + 2,
14533                          background_area.height + 2);
14534
14535   rtl = gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL;
14536
14537   for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
14538       list;
14539       list = (rtl ? list->prev : list->next))
14540     {
14541       GtkTreeViewColumn *column = list->data;
14542       GdkRectangle cell_area;
14543       gint vertical_separator;
14544
14545       if (!gtk_tree_view_column_get_visible (column))
14546         continue;
14547
14548       gtk_tree_view_column_cell_set_cell_data (column, tree_view->priv->model, &iter,
14549                                                GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT),
14550                                                node->children?TRUE:FALSE);
14551
14552       background_area.x = cell_offset;
14553       background_area.width = gtk_tree_view_column_get_width (column);
14554
14555       gtk_widget_style_get (widget,
14556                             "vertical-separator", &vertical_separator,
14557                             NULL);
14558
14559       cell_area = background_area;
14560
14561       cell_area.y += vertical_separator / 2;
14562       cell_area.height -= vertical_separator;
14563
14564       if (gtk_tree_view_is_expander_column (tree_view, column))
14565         {
14566           if (!rtl)
14567             cell_area.x += (depth - 1) * tree_view->priv->level_indentation;
14568           cell_area.width -= (depth - 1) * tree_view->priv->level_indentation;
14569
14570           if (gtk_tree_view_draw_expanders (tree_view))
14571             {
14572               if (!rtl)
14573                 cell_area.x += depth * tree_view->priv->expander_size;
14574               cell_area.width -= depth * tree_view->priv->expander_size;
14575             }
14576         }
14577
14578       if (gtk_tree_view_column_cell_is_visible (column))
14579         {
14580           if (is_separator)
14581             {
14582               gtk_style_context_save (context);
14583               gtk_style_context_add_class (context, GTK_STYLE_CLASS_SEPARATOR);
14584
14585               gtk_render_line (context, cr,
14586                                cell_area.x,
14587                                cell_area.y + cell_area.height / 2,
14588                                cell_area.x + cell_area.width,
14589                                cell_area.y + cell_area.height / 2);
14590
14591               gtk_style_context_restore (context);
14592             }
14593           else
14594             {
14595               _gtk_tree_view_column_cell_render (column,
14596                                                  cr,
14597                                                  &background_area,
14598                                                  &cell_area,
14599                                                  0, FALSE);
14600             }
14601         }
14602       cell_offset += gtk_tree_view_column_get_width (column);
14603     }
14604
14605   cairo_set_source_rgb (cr, 0, 0, 0);
14606   cairo_rectangle (cr,
14607                    0.5, 0.5,
14608                    bin_window_width + 1,
14609                    background_area.height + 1);
14610   cairo_set_line_width (cr, 1.0);
14611   cairo_stroke (cr);
14612
14613   cairo_destroy (cr);
14614
14615   cairo_surface_set_device_offset (surface, 2, 2);
14616
14617   gtk_style_context_restore (context);
14618
14619   return surface;
14620 }
14621
14622
14623 /**
14624  * gtk_tree_view_set_destroy_count_func:
14625  * @tree_view: A #GtkTreeView
14626  * @func: (allow-none): Function to be called when a view row is destroyed, or %NULL
14627  * @data: (allow-none): User data to be passed to @func, or %NULL
14628  * @destroy: (allow-none): Destroy notifier for @data, or %NULL
14629  *
14630  * This function should almost never be used.  It is meant for private use by
14631  * ATK for determining the number of visible children that are removed when the
14632  * user collapses a row, or a row is deleted.
14633  **/
14634 void
14635 gtk_tree_view_set_destroy_count_func (GtkTreeView             *tree_view,
14636                                       GtkTreeDestroyCountFunc  func,
14637                                       gpointer                 data,
14638                                       GDestroyNotify           destroy)
14639 {
14640   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14641
14642   if (tree_view->priv->destroy_count_destroy)
14643     tree_view->priv->destroy_count_destroy (tree_view->priv->destroy_count_data);
14644
14645   tree_view->priv->destroy_count_func = func;
14646   tree_view->priv->destroy_count_data = data;
14647   tree_view->priv->destroy_count_destroy = destroy;
14648 }
14649
14650
14651 /*
14652  * Interactive search
14653  */
14654
14655 /**
14656  * gtk_tree_view_set_enable_search:
14657  * @tree_view: A #GtkTreeView
14658  * @enable_search: %TRUE, if the user can search interactively
14659  *
14660  * If @enable_search is set, then the user can type in text to search through
14661  * the tree interactively (this is sometimes called "typeahead find").
14662  *
14663  * Note that even if this is %FALSE, the user can still initiate a search
14664  * using the "start-interactive-search" key binding.
14665  */
14666 void
14667 gtk_tree_view_set_enable_search (GtkTreeView *tree_view,
14668                                  gboolean     enable_search)
14669 {
14670   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14671
14672   enable_search = !!enable_search;
14673
14674   if (tree_view->priv->enable_search != enable_search)
14675     {
14676        tree_view->priv->enable_search = enable_search;
14677        g_object_notify (G_OBJECT (tree_view), "enable-search");
14678     }
14679 }
14680
14681 /**
14682  * gtk_tree_view_get_enable_search:
14683  * @tree_view: A #GtkTreeView
14684  *
14685  * Returns whether or not the tree allows to start interactive searching
14686  * by typing in text.
14687  *
14688  * Return value: whether or not to let the user search interactively
14689  */
14690 gboolean
14691 gtk_tree_view_get_enable_search (GtkTreeView *tree_view)
14692 {
14693   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
14694
14695   return tree_view->priv->enable_search;
14696 }
14697
14698
14699 /**
14700  * gtk_tree_view_get_search_column:
14701  * @tree_view: A #GtkTreeView
14702  *
14703  * Gets the column searched on by the interactive search code.
14704  *
14705  * Return value: the column the interactive search code searches in.
14706  */
14707 gint
14708 gtk_tree_view_get_search_column (GtkTreeView *tree_view)
14709 {
14710   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
14711
14712   return (tree_view->priv->search_column);
14713 }
14714
14715 /**
14716  * gtk_tree_view_set_search_column:
14717  * @tree_view: A #GtkTreeView
14718  * @column: the column of the model to search in, or -1 to disable searching
14719  *
14720  * Sets @column as the column where the interactive search code should
14721  * search in for the current model.
14722  *
14723  * If the search column is set, users can use the "start-interactive-search"
14724  * key binding to bring up search popup. The enable-search property controls
14725  * whether simply typing text will also start an interactive search.
14726  *
14727  * Note that @column refers to a column of the current model. The search
14728  * column is reset to -1 when the model is changed.
14729  */
14730 void
14731 gtk_tree_view_set_search_column (GtkTreeView *tree_view,
14732                                  gint         column)
14733 {
14734   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14735   g_return_if_fail (column >= -1);
14736
14737   if (tree_view->priv->search_column == column)
14738     return;
14739
14740   tree_view->priv->search_column = column;
14741   g_object_notify (G_OBJECT (tree_view), "search-column");
14742 }
14743
14744 /**
14745  * gtk_tree_view_get_search_equal_func: (skip)
14746  * @tree_view: A #GtkTreeView
14747  *
14748  * Returns the compare function currently in use.
14749  *
14750  * Return value: the currently used compare function for the search code.
14751  */
14752
14753 GtkTreeViewSearchEqualFunc
14754 gtk_tree_view_get_search_equal_func (GtkTreeView *tree_view)
14755 {
14756   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
14757
14758   return tree_view->priv->search_equal_func;
14759 }
14760
14761 /**
14762  * gtk_tree_view_set_search_equal_func:
14763  * @tree_view: A #GtkTreeView
14764  * @search_equal_func: the compare function to use during the search
14765  * @search_user_data: (allow-none): user data to pass to @search_equal_func, or %NULL
14766  * @search_destroy: (allow-none): Destroy notifier for @search_user_data, or %NULL
14767  *
14768  * Sets the compare function for the interactive search capabilities; note
14769  * that somewhat like strcmp() returning 0 for equality
14770  * #GtkTreeViewSearchEqualFunc returns %FALSE on matches.
14771  **/
14772 void
14773 gtk_tree_view_set_search_equal_func (GtkTreeView                *tree_view,
14774                                      GtkTreeViewSearchEqualFunc  search_equal_func,
14775                                      gpointer                    search_user_data,
14776                                      GDestroyNotify              search_destroy)
14777 {
14778   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14779   g_return_if_fail (search_equal_func != NULL);
14780
14781   if (tree_view->priv->search_destroy)
14782     tree_view->priv->search_destroy (tree_view->priv->search_user_data);
14783
14784   tree_view->priv->search_equal_func = search_equal_func;
14785   tree_view->priv->search_user_data = search_user_data;
14786   tree_view->priv->search_destroy = search_destroy;
14787   if (tree_view->priv->search_equal_func == NULL)
14788     tree_view->priv->search_equal_func = gtk_tree_view_search_equal_func;
14789 }
14790
14791 /**
14792  * gtk_tree_view_get_search_entry:
14793  * @tree_view: A #GtkTreeView
14794  *
14795  * Returns the #GtkEntry which is currently in use as interactive search
14796  * entry for @tree_view.  In case the built-in entry is being used, %NULL
14797  * will be returned.
14798  *
14799  * Return value: (transfer none): the entry currently in use as search entry.
14800  *
14801  * Since: 2.10
14802  */
14803 GtkEntry *
14804 gtk_tree_view_get_search_entry (GtkTreeView *tree_view)
14805 {
14806   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
14807
14808   if (tree_view->priv->search_custom_entry_set)
14809     return GTK_ENTRY (tree_view->priv->search_entry);
14810
14811   return NULL;
14812 }
14813
14814 /**
14815  * gtk_tree_view_set_search_entry:
14816  * @tree_view: A #GtkTreeView
14817  * @entry: (allow-none): the entry the interactive search code of @tree_view should use or %NULL
14818  *
14819  * Sets the entry which the interactive search code will use for this
14820  * @tree_view.  This is useful when you want to provide a search entry
14821  * in our interface at all time at a fixed position.  Passing %NULL for
14822  * @entry will make the interactive search code use the built-in popup
14823  * entry again.
14824  *
14825  * Since: 2.10
14826  */
14827 void
14828 gtk_tree_view_set_search_entry (GtkTreeView *tree_view,
14829                                 GtkEntry    *entry)
14830 {
14831   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14832   g_return_if_fail (entry == NULL || GTK_IS_ENTRY (entry));
14833
14834   if (tree_view->priv->search_custom_entry_set)
14835     {
14836       if (tree_view->priv->search_entry_changed_id)
14837         {
14838           g_signal_handler_disconnect (tree_view->priv->search_entry,
14839                                        tree_view->priv->search_entry_changed_id);
14840           tree_view->priv->search_entry_changed_id = 0;
14841         }
14842       g_signal_handlers_disconnect_by_func (tree_view->priv->search_entry,
14843                                             G_CALLBACK (gtk_tree_view_search_key_press_event),
14844                                             tree_view);
14845
14846       g_object_unref (tree_view->priv->search_entry);
14847     }
14848   else if (tree_view->priv->search_window)
14849     {
14850       gtk_widget_destroy (tree_view->priv->search_window);
14851
14852       tree_view->priv->search_window = NULL;
14853     }
14854
14855   if (entry)
14856     {
14857       tree_view->priv->search_entry = g_object_ref (entry);
14858       tree_view->priv->search_custom_entry_set = TRUE;
14859
14860       if (tree_view->priv->search_entry_changed_id == 0)
14861         {
14862           tree_view->priv->search_entry_changed_id =
14863             g_signal_connect (tree_view->priv->search_entry, "changed",
14864                               G_CALLBACK (gtk_tree_view_search_init),
14865                               tree_view);
14866         }
14867
14868         g_signal_connect (tree_view->priv->search_entry, "key-press-event",
14869                           G_CALLBACK (gtk_tree_view_search_key_press_event),
14870                           tree_view);
14871
14872         gtk_tree_view_search_init (tree_view->priv->search_entry, tree_view);
14873     }
14874   else
14875     {
14876       tree_view->priv->search_entry = NULL;
14877       tree_view->priv->search_custom_entry_set = FALSE;
14878     }
14879 }
14880
14881 /**
14882  * gtk_tree_view_set_search_position_func:
14883  * @tree_view: A #GtkTreeView
14884  * @func: (allow-none): the function to use to position the search dialog, or %NULL
14885  *    to use the default search position function
14886  * @data: (allow-none): user data to pass to @func, or %NULL
14887  * @destroy: (allow-none): Destroy notifier for @data, or %NULL
14888  *
14889  * Sets the function to use when positioning the search dialog.
14890  *
14891  * Since: 2.10
14892  **/
14893 void
14894 gtk_tree_view_set_search_position_func (GtkTreeView                   *tree_view,
14895                                         GtkTreeViewSearchPositionFunc  func,
14896                                         gpointer                       user_data,
14897                                         GDestroyNotify                 destroy)
14898 {
14899   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14900
14901   if (tree_view->priv->search_position_destroy)
14902     tree_view->priv->search_position_destroy (tree_view->priv->search_position_user_data);
14903
14904   tree_view->priv->search_position_func = func;
14905   tree_view->priv->search_position_user_data = user_data;
14906   tree_view->priv->search_position_destroy = destroy;
14907   if (tree_view->priv->search_position_func == NULL)
14908     tree_view->priv->search_position_func = gtk_tree_view_search_position_func;
14909 }
14910
14911 /**
14912  * gtk_tree_view_get_search_position_func: (skip)
14913  * @tree_view: A #GtkTreeView
14914  *
14915  * Returns the positioning function currently in use.
14916  *
14917  * Return value: the currently used function for positioning the search dialog.
14918  *
14919  * Since: 2.10
14920  */
14921 GtkTreeViewSearchPositionFunc
14922 gtk_tree_view_get_search_position_func (GtkTreeView *tree_view)
14923 {
14924   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
14925
14926   return tree_view->priv->search_position_func;
14927 }
14928
14929
14930 static void
14931 gtk_tree_view_search_dialog_hide (GtkWidget   *search_dialog,
14932                                   GtkTreeView *tree_view,
14933                                   GdkDevice   *device)
14934 {
14935   if (tree_view->priv->disable_popdown)
14936     return;
14937
14938   if (tree_view->priv->search_entry_changed_id)
14939     {
14940       g_signal_handler_disconnect (tree_view->priv->search_entry,
14941                                    tree_view->priv->search_entry_changed_id);
14942       tree_view->priv->search_entry_changed_id = 0;
14943     }
14944   if (tree_view->priv->typeselect_flush_timeout)
14945     {
14946       g_source_remove (tree_view->priv->typeselect_flush_timeout);
14947       tree_view->priv->typeselect_flush_timeout = 0;
14948     }
14949
14950   if (gtk_widget_get_visible (search_dialog))
14951     {
14952       /* send focus-in event */
14953       send_focus_change (GTK_WIDGET (tree_view->priv->search_entry), device, FALSE);
14954       gtk_widget_hide (search_dialog);
14955       gtk_entry_set_text (GTK_ENTRY (tree_view->priv->search_entry), "");
14956       send_focus_change (GTK_WIDGET (tree_view), device, TRUE);
14957     }
14958 }
14959
14960 static void
14961 gtk_tree_view_search_position_func (GtkTreeView *tree_view,
14962                                     GtkWidget   *search_dialog,
14963                                     gpointer     user_data)
14964 {
14965   gint x, y;
14966   gint tree_x, tree_y;
14967   gint tree_width, tree_height;
14968   GdkWindow *tree_window = gtk_widget_get_window (GTK_WIDGET (tree_view));
14969   GdkScreen *screen = gdk_window_get_screen (tree_window);
14970   GtkRequisition requisition;
14971   gint monitor_num;
14972   GdkRectangle monitor;
14973
14974   monitor_num = gdk_screen_get_monitor_at_window (screen, tree_window);
14975   gdk_screen_get_monitor_geometry (screen, monitor_num, &monitor);
14976
14977   gtk_widget_realize (search_dialog);
14978
14979   gdk_window_get_origin (tree_window, &tree_x, &tree_y);
14980   tree_width = gdk_window_get_width (tree_window);
14981   tree_height = gdk_window_get_height (tree_window);
14982   gtk_widget_get_preferred_size (search_dialog, &requisition, NULL);
14983
14984   if (tree_x + tree_width > gdk_screen_get_width (screen))
14985     x = gdk_screen_get_width (screen) - requisition.width;
14986   else if (tree_x + tree_width - requisition.width < 0)
14987     x = 0;
14988   else
14989     x = tree_x + tree_width - requisition.width;
14990
14991   if (tree_y + tree_height + requisition.height > gdk_screen_get_height (screen))
14992     y = gdk_screen_get_height (screen) - requisition.height;
14993   else if (tree_y + tree_height < 0) /* isn't really possible ... */
14994     y = 0;
14995   else
14996     y = tree_y + tree_height;
14997
14998   gtk_window_move (GTK_WINDOW (search_dialog), x, y);
14999 }
15000
15001 static void
15002 gtk_tree_view_search_disable_popdown (GtkEntry *entry,
15003                                       GtkMenu  *menu,
15004                                       gpointer  data)
15005 {
15006   GtkTreeView *tree_view = (GtkTreeView *)data;
15007
15008   tree_view->priv->disable_popdown = 1;
15009   g_signal_connect (menu, "hide",
15010                     G_CALLBACK (gtk_tree_view_search_enable_popdown), data);
15011 }
15012
15013 /* Because we're visible but offscreen, we just set a flag in the preedit
15014  * callback.
15015  */
15016 static void
15017 gtk_tree_view_search_preedit_changed (GtkIMContext *im_context,
15018                                       GtkTreeView  *tree_view)
15019 {
15020   tree_view->priv->imcontext_changed = 1;
15021   if (tree_view->priv->typeselect_flush_timeout)
15022     {
15023       g_source_remove (tree_view->priv->typeselect_flush_timeout);
15024       tree_view->priv->typeselect_flush_timeout =
15025         gdk_threads_add_timeout (GTK_TREE_VIEW_SEARCH_DIALOG_TIMEOUT,
15026                        (GSourceFunc) gtk_tree_view_search_entry_flush_timeout,
15027                        tree_view);
15028     }
15029
15030 }
15031
15032 static void
15033 gtk_tree_view_search_activate (GtkEntry    *entry,
15034                                GtkTreeView *tree_view)
15035 {
15036   GtkTreePath *path;
15037   GtkRBNode *node;
15038   GtkRBTree *tree;
15039
15040   gtk_tree_view_search_dialog_hide (tree_view->priv->search_window,
15041                                     tree_view,
15042                                     gtk_get_current_event_device ());
15043
15044   /* If we have a row selected and it's the cursor row, we activate
15045    * the row XXX */
15046   if (gtk_tree_row_reference_valid (tree_view->priv->cursor))
15047     {
15048       path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
15049
15050       _gtk_tree_view_find_node (tree_view, path, &tree, &node);
15051
15052       if (node && GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
15053         gtk_tree_view_row_activated (tree_view, path, tree_view->priv->focus_column);
15054
15055       gtk_tree_path_free (path);
15056     }
15057 }
15058
15059 static gboolean
15060 gtk_tree_view_real_search_enable_popdown (gpointer data)
15061 {
15062   GtkTreeView *tree_view = (GtkTreeView *)data;
15063
15064   tree_view->priv->disable_popdown = 0;
15065
15066   return FALSE;
15067 }
15068
15069 static void
15070 gtk_tree_view_search_enable_popdown (GtkWidget *widget,
15071                                      gpointer   data)
15072 {
15073   gdk_threads_add_timeout_full (G_PRIORITY_HIGH, 200, gtk_tree_view_real_search_enable_popdown, g_object_ref (data), g_object_unref);
15074 }
15075
15076 static gboolean
15077 gtk_tree_view_search_delete_event (GtkWidget *widget,
15078                                    GdkEventAny *event,
15079                                    GtkTreeView *tree_view)
15080 {
15081   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
15082
15083   gtk_tree_view_search_dialog_hide (widget, tree_view, NULL);
15084
15085   return TRUE;
15086 }
15087
15088 static gboolean
15089 gtk_tree_view_search_button_press_event (GtkWidget *widget,
15090                                          GdkEventButton *event,
15091                                          GtkTreeView *tree_view)
15092 {
15093   GdkDevice *keyb_device;
15094
15095   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
15096
15097   keyb_device = gdk_device_get_associated_device (event->device);
15098   gtk_tree_view_search_dialog_hide (widget, tree_view, keyb_device);
15099
15100   if (event->window == tree_view->priv->bin_window)
15101     gtk_tree_view_button_press (GTK_WIDGET (tree_view), event);
15102
15103   return TRUE;
15104 }
15105
15106 static gboolean
15107 gtk_tree_view_search_scroll_event (GtkWidget *widget,
15108                                    GdkEventScroll *event,
15109                                    GtkTreeView *tree_view)
15110 {
15111   gboolean retval = FALSE;
15112
15113   if (event->direction == GDK_SCROLL_UP)
15114     {
15115       gtk_tree_view_search_move (widget, tree_view, TRUE);
15116       retval = TRUE;
15117     }
15118   else if (event->direction == GDK_SCROLL_DOWN)
15119     {
15120       gtk_tree_view_search_move (widget, tree_view, FALSE);
15121       retval = TRUE;
15122     }
15123
15124   /* renew the flush timeout */
15125   if (retval && tree_view->priv->typeselect_flush_timeout
15126       && !tree_view->priv->search_custom_entry_set)
15127     {
15128       g_source_remove (tree_view->priv->typeselect_flush_timeout);
15129       tree_view->priv->typeselect_flush_timeout =
15130         gdk_threads_add_timeout (GTK_TREE_VIEW_SEARCH_DIALOG_TIMEOUT,
15131                        (GSourceFunc) gtk_tree_view_search_entry_flush_timeout,
15132                        tree_view);
15133     }
15134
15135   return retval;
15136 }
15137
15138 static gboolean
15139 gtk_tree_view_search_key_press_event (GtkWidget *widget,
15140                                       GdkEventKey *event,
15141                                       GtkTreeView *tree_view)
15142 {
15143   GdkModifierType default_accel;
15144   gboolean        retval = FALSE;
15145
15146   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
15147   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
15148
15149   /* close window and cancel the search */
15150   if (!tree_view->priv->search_custom_entry_set
15151       && (event->keyval == GDK_KEY_Escape ||
15152           event->keyval == GDK_KEY_Tab ||
15153             event->keyval == GDK_KEY_KP_Tab ||
15154             event->keyval == GDK_KEY_ISO_Left_Tab))
15155     {
15156       gtk_tree_view_search_dialog_hide (widget, tree_view,
15157                                         gdk_event_get_device ((GdkEvent *) event));
15158       return TRUE;
15159     }
15160
15161   default_accel = gtk_widget_get_modifier_mask (widget,
15162                                                 GDK_MODIFIER_INTENT_PRIMARY_ACCELERATOR);
15163
15164   /* select previous matching iter */
15165   if (event->keyval == GDK_KEY_Up || event->keyval == GDK_KEY_KP_Up)
15166     {
15167       if (!gtk_tree_view_search_move (widget, tree_view, TRUE))
15168         gtk_widget_error_bell (widget);
15169
15170       retval = TRUE;
15171     }
15172
15173   if (((event->state & (default_accel | GDK_SHIFT_MASK)) == (default_accel | GDK_SHIFT_MASK))
15174       && (event->keyval == GDK_KEY_g || event->keyval == GDK_KEY_G))
15175     {
15176       if (!gtk_tree_view_search_move (widget, tree_view, TRUE))
15177         gtk_widget_error_bell (widget);
15178
15179       retval = TRUE;
15180     }
15181
15182   /* select next matching iter */
15183   if (event->keyval == GDK_KEY_Down || event->keyval == GDK_KEY_KP_Down)
15184     {
15185       if (!gtk_tree_view_search_move (widget, tree_view, FALSE))
15186         gtk_widget_error_bell (widget);
15187
15188       retval = TRUE;
15189     }
15190
15191   if (((event->state & (default_accel | GDK_SHIFT_MASK)) == default_accel)
15192       && (event->keyval == GDK_KEY_g || event->keyval == GDK_KEY_G))
15193     {
15194       if (!gtk_tree_view_search_move (widget, tree_view, FALSE))
15195         gtk_widget_error_bell (widget);
15196
15197       retval = TRUE;
15198     }
15199
15200   /* renew the flush timeout */
15201   if (retval && tree_view->priv->typeselect_flush_timeout
15202       && !tree_view->priv->search_custom_entry_set)
15203     {
15204       g_source_remove (tree_view->priv->typeselect_flush_timeout);
15205       tree_view->priv->typeselect_flush_timeout =
15206         gdk_threads_add_timeout (GTK_TREE_VIEW_SEARCH_DIALOG_TIMEOUT,
15207                        (GSourceFunc) gtk_tree_view_search_entry_flush_timeout,
15208                        tree_view);
15209     }
15210
15211   return retval;
15212 }
15213
15214 /*  this function returns FALSE if there is a search string but
15215  *  nothing was found, and TRUE otherwise.
15216  */
15217 static gboolean
15218 gtk_tree_view_search_move (GtkWidget   *window,
15219                            GtkTreeView *tree_view,
15220                            gboolean     up)
15221 {
15222   gboolean ret;
15223   gint len;
15224   gint count = 0;
15225   const gchar *text;
15226   GtkTreeIter iter;
15227   GtkTreeModel *model;
15228   GtkTreeSelection *selection;
15229
15230   text = gtk_entry_get_text (GTK_ENTRY (tree_view->priv->search_entry));
15231
15232   g_return_val_if_fail (text != NULL, FALSE);
15233
15234   len = strlen (text);
15235
15236   if (up && tree_view->priv->selected_iter == 1)
15237     return strlen (text) < 1;
15238
15239   len = strlen (text);
15240
15241   if (len < 1)
15242     return TRUE;
15243
15244   model = gtk_tree_view_get_model (tree_view);
15245   selection = gtk_tree_view_get_selection (tree_view);
15246
15247   /* search */
15248   gtk_tree_selection_unselect_all (selection);
15249   if (!gtk_tree_model_get_iter_first (model, &iter))
15250     return TRUE;
15251
15252   ret = gtk_tree_view_search_iter (model, selection, &iter, text,
15253                                    &count, up?((tree_view->priv->selected_iter) - 1):((tree_view->priv->selected_iter + 1)));
15254
15255   if (ret)
15256     {
15257       /* found */
15258       tree_view->priv->selected_iter += up?(-1):(1);
15259       return TRUE;
15260     }
15261   else
15262     {
15263       /* return to old iter */
15264       count = 0;
15265       gtk_tree_model_get_iter_first (model, &iter);
15266       gtk_tree_view_search_iter (model, selection,
15267                                  &iter, text,
15268                                  &count, tree_view->priv->selected_iter);
15269       return FALSE;
15270     }
15271 }
15272
15273 static gboolean
15274 gtk_tree_view_search_equal_func (GtkTreeModel *model,
15275                                  gint          column,
15276                                  const gchar  *key,
15277                                  GtkTreeIter  *iter,
15278                                  gpointer      search_data)
15279 {
15280   gboolean retval = TRUE;
15281   const gchar *str;
15282   gchar *normalized_string;
15283   gchar *normalized_key;
15284   gchar *case_normalized_string = NULL;
15285   gchar *case_normalized_key = NULL;
15286   GValue value = G_VALUE_INIT;
15287   GValue transformed = G_VALUE_INIT;
15288
15289   gtk_tree_model_get_value (model, iter, column, &value);
15290
15291   g_value_init (&transformed, G_TYPE_STRING);
15292
15293   if (!g_value_transform (&value, &transformed))
15294     {
15295       g_value_unset (&value);
15296       return TRUE;
15297     }
15298
15299   g_value_unset (&value);
15300
15301   str = g_value_get_string (&transformed);
15302   if (!str)
15303     {
15304       g_value_unset (&transformed);
15305       return TRUE;
15306     }
15307
15308   normalized_string = g_utf8_normalize (str, -1, G_NORMALIZE_ALL);
15309   normalized_key = g_utf8_normalize (key, -1, G_NORMALIZE_ALL);
15310
15311   if (normalized_string && normalized_key)
15312     {
15313       case_normalized_string = g_utf8_casefold (normalized_string, -1);
15314       case_normalized_key = g_utf8_casefold (normalized_key, -1);
15315
15316       if (strncmp (case_normalized_key, case_normalized_string, strlen (case_normalized_key)) == 0)
15317         retval = FALSE;
15318     }
15319
15320   g_value_unset (&transformed);
15321   g_free (normalized_key);
15322   g_free (normalized_string);
15323   g_free (case_normalized_key);
15324   g_free (case_normalized_string);
15325
15326   return retval;
15327 }
15328
15329 static gboolean
15330 gtk_tree_view_search_iter (GtkTreeModel     *model,
15331                            GtkTreeSelection *selection,
15332                            GtkTreeIter      *iter,
15333                            const gchar      *text,
15334                            gint             *count,
15335                            gint              n)
15336 {
15337   GtkRBTree *tree = NULL;
15338   GtkRBNode *node = NULL;
15339   GtkTreePath *path;
15340
15341   GtkTreeView *tree_view = gtk_tree_selection_get_tree_view (selection);
15342
15343   path = gtk_tree_model_get_path (model, iter);
15344   _gtk_tree_view_find_node (tree_view, path, &tree, &node);
15345
15346   do
15347     {
15348       if (! tree_view->priv->search_equal_func (model, tree_view->priv->search_column, text, iter, tree_view->priv->search_user_data))
15349         {
15350           (*count)++;
15351           if (*count == n)
15352             {
15353               gtk_tree_view_scroll_to_cell (tree_view, path, NULL,
15354                                             TRUE, 0.5, 0.0);
15355               gtk_tree_selection_select_iter (selection, iter);
15356               gtk_tree_view_real_set_cursor (tree_view, path, FALSE, TRUE);
15357
15358               if (path)
15359                 gtk_tree_path_free (path);
15360
15361               return TRUE;
15362             }
15363         }
15364
15365       if (node->children)
15366         {
15367           gboolean has_child;
15368           GtkTreeIter tmp;
15369
15370           tree = node->children;
15371           node = tree->root;
15372
15373           while (node->left != tree->nil)
15374             node = node->left;
15375
15376           tmp = *iter;
15377           has_child = gtk_tree_model_iter_children (model, iter, &tmp);
15378           gtk_tree_path_down (path);
15379
15380           /* sanity check */
15381           TREE_VIEW_INTERNAL_ASSERT (has_child, FALSE);
15382         }
15383       else
15384         {
15385           gboolean done = FALSE;
15386
15387           do
15388             {
15389               node = _gtk_rbtree_next (tree, node);
15390
15391               if (node)
15392                 {
15393                   gboolean has_next;
15394
15395                   has_next = gtk_tree_model_iter_next (model, iter);
15396
15397                   done = TRUE;
15398                   gtk_tree_path_next (path);
15399
15400                   /* sanity check */
15401                   TREE_VIEW_INTERNAL_ASSERT (has_next, FALSE);
15402                 }
15403               else
15404                 {
15405                   gboolean has_parent;
15406                   GtkTreeIter tmp_iter = *iter;
15407
15408                   node = tree->parent_node;
15409                   tree = tree->parent_tree;
15410
15411                   if (!tree)
15412                     {
15413                       if (path)
15414                         gtk_tree_path_free (path);
15415
15416                       /* we've run out of tree, done with this func */
15417                       return FALSE;
15418                     }
15419
15420                   has_parent = gtk_tree_model_iter_parent (model,
15421                                                            iter,
15422                                                            &tmp_iter);
15423                   gtk_tree_path_up (path);
15424
15425                   /* sanity check */
15426                   TREE_VIEW_INTERNAL_ASSERT (has_parent, FALSE);
15427                 }
15428             }
15429           while (!done);
15430         }
15431     }
15432   while (1);
15433
15434   return FALSE;
15435 }
15436
15437 static void
15438 gtk_tree_view_search_init (GtkWidget   *entry,
15439                            GtkTreeView *tree_view)
15440 {
15441   gint ret;
15442   gint count = 0;
15443   const gchar *text;
15444   GtkTreeIter iter;
15445   GtkTreeModel *model;
15446   GtkTreeSelection *selection;
15447
15448   g_return_if_fail (GTK_IS_ENTRY (entry));
15449   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
15450
15451   text = gtk_entry_get_text (GTK_ENTRY (entry));
15452
15453   model = gtk_tree_view_get_model (tree_view);
15454   selection = gtk_tree_view_get_selection (tree_view);
15455
15456   /* search */
15457   gtk_tree_selection_unselect_all (selection);
15458   if (tree_view->priv->typeselect_flush_timeout
15459       && !tree_view->priv->search_custom_entry_set)
15460     {
15461       g_source_remove (tree_view->priv->typeselect_flush_timeout);
15462       tree_view->priv->typeselect_flush_timeout =
15463         gdk_threads_add_timeout (GTK_TREE_VIEW_SEARCH_DIALOG_TIMEOUT,
15464                        (GSourceFunc) gtk_tree_view_search_entry_flush_timeout,
15465                        tree_view);
15466     }
15467
15468   if (*text == '\0')
15469     return;
15470
15471   if (!gtk_tree_model_get_iter_first (model, &iter))
15472     return;
15473
15474   ret = gtk_tree_view_search_iter (model, selection,
15475                                    &iter, text,
15476                                    &count, 1);
15477
15478   if (ret)
15479     tree_view->priv->selected_iter = 1;
15480 }
15481
15482 void
15483 _gtk_tree_view_remove_editable (GtkTreeView       *tree_view,
15484                                 GtkTreeViewColumn *column,
15485                                 GtkCellEditable   *cell_editable)
15486 {
15487   if (tree_view->priv->edited_column == NULL)
15488     return;
15489
15490   g_return_if_fail (column == tree_view->priv->edited_column);
15491
15492   tree_view->priv->edited_column = NULL;
15493
15494   if (gtk_widget_has_focus (GTK_WIDGET (cell_editable)))
15495     gtk_widget_grab_focus (GTK_WIDGET (tree_view));
15496
15497   gtk_container_remove (GTK_CONTAINER (tree_view),
15498                         GTK_WIDGET (cell_editable));
15499
15500   /* FIXME should only redraw a single node */
15501   gtk_widget_queue_draw (GTK_WIDGET (tree_view));
15502 }
15503
15504 static gboolean
15505 gtk_tree_view_start_editing (GtkTreeView *tree_view,
15506                              GtkTreePath *cursor_path,
15507                              gboolean     edit_only)
15508 {
15509   GtkTreeIter iter;
15510   GdkRectangle cell_area;
15511   GtkTreeViewColumn *focus_column;
15512   guint flags = 0; /* can be 0, as the flags are primarily for rendering */
15513   gint retval = FALSE;
15514   GtkRBTree *cursor_tree;
15515   GtkRBNode *cursor_node;
15516
15517   g_assert (tree_view->priv->focus_column);
15518   focus_column = tree_view->priv->focus_column;
15519
15520   if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
15521     return FALSE;
15522
15523   if (_gtk_tree_view_find_node (tree_view, cursor_path, &cursor_tree, &cursor_node) ||
15524       cursor_node == NULL)
15525     return FALSE;
15526
15527   gtk_tree_model_get_iter (tree_view->priv->model, &iter, cursor_path);
15528
15529   validate_row (tree_view, cursor_tree, cursor_node, &iter, cursor_path);
15530
15531   gtk_tree_view_column_cell_set_cell_data (focus_column,
15532                                            tree_view->priv->model,
15533                                            &iter,
15534                                            GTK_RBNODE_FLAG_SET (cursor_node, GTK_RBNODE_IS_PARENT),
15535                                            cursor_node->children ? TRUE : FALSE);
15536   gtk_tree_view_get_cell_area (tree_view,
15537                                cursor_path,
15538                                focus_column,
15539                                &cell_area);
15540
15541   if (gtk_cell_area_activate (gtk_cell_layout_get_area (GTK_CELL_LAYOUT (focus_column)),
15542                               _gtk_tree_view_column_get_context (focus_column),
15543                               GTK_WIDGET (tree_view),
15544                               &cell_area,
15545                               flags, edit_only))
15546     retval = TRUE;
15547
15548   return retval;
15549 }
15550
15551 void
15552 _gtk_tree_view_add_editable (GtkTreeView       *tree_view,
15553                              GtkTreeViewColumn *column,
15554                              GtkTreePath       *path,
15555                              GtkCellEditable   *cell_editable,
15556                              GdkRectangle      *cell_area)
15557 {
15558   gint pre_val = gtk_adjustment_get_value (tree_view->priv->vadjustment);
15559   GtkRequisition requisition;
15560
15561   tree_view->priv->edited_column = column;
15562
15563   gtk_tree_view_real_set_cursor (tree_view, path, FALSE, TRUE);
15564   cell_area->y += pre_val - (int)gtk_adjustment_get_value (tree_view->priv->vadjustment);
15565
15566   gtk_widget_get_preferred_size (GTK_WIDGET (cell_editable),
15567                                  &requisition, NULL);
15568
15569   tree_view->priv->draw_keyfocus = TRUE;
15570
15571   if (requisition.height < cell_area->height)
15572     {
15573       gint diff = cell_area->height - requisition.height;
15574       gtk_tree_view_put (tree_view,
15575                          GTK_WIDGET (cell_editable),
15576                          cell_area->x, cell_area->y + diff/2,
15577                          cell_area->width, requisition.height);
15578     }
15579   else
15580     {
15581       gtk_tree_view_put (tree_view,
15582                          GTK_WIDGET (cell_editable),
15583                          cell_area->x, cell_area->y,
15584                          cell_area->width, cell_area->height);
15585     }
15586 }
15587
15588 static void
15589 gtk_tree_view_stop_editing (GtkTreeView *tree_view,
15590                             gboolean     cancel_editing)
15591 {
15592   GtkTreeViewColumn *column;
15593
15594   if (tree_view->priv->edited_column == NULL)
15595     return;
15596
15597   /*
15598    * This is very evil. We need to do this, because
15599    * gtk_cell_editable_editing_done may trigger gtk_tree_view_row_changed
15600    * later on. If gtk_tree_view_row_changed notices
15601    * tree_view->priv->edited_column != NULL, it'll call
15602    * gtk_tree_view_stop_editing again. Bad things will happen then.
15603    *
15604    * Please read that again if you intend to modify anything here.
15605    */
15606
15607   column = tree_view->priv->edited_column;
15608   gtk_cell_area_stop_editing (gtk_cell_layout_get_area (GTK_CELL_LAYOUT (column)), cancel_editing);
15609   tree_view->priv->edited_column = NULL;
15610 }
15611
15612
15613 /**
15614  * gtk_tree_view_set_hover_selection:
15615  * @tree_view: a #GtkTreeView
15616  * @hover: %TRUE to enable hover selection mode
15617  *
15618  * Enables or disables the hover selection mode of @tree_view.
15619  * Hover selection makes the selected row follow the pointer.
15620  * Currently, this works only for the selection modes
15621  * %GTK_SELECTION_SINGLE and %GTK_SELECTION_BROWSE.
15622  *
15623  * Since: 2.6
15624  **/
15625 void
15626 gtk_tree_view_set_hover_selection (GtkTreeView *tree_view,
15627                                    gboolean     hover)
15628 {
15629   hover = hover != FALSE;
15630
15631   if (hover != tree_view->priv->hover_selection)
15632     {
15633       tree_view->priv->hover_selection = hover;
15634
15635       g_object_notify (G_OBJECT (tree_view), "hover-selection");
15636     }
15637 }
15638
15639 /**
15640  * gtk_tree_view_get_hover_selection:
15641  * @tree_view: a #GtkTreeView
15642  *
15643  * Returns whether hover selection mode is turned on for @tree_view.
15644  *
15645  * Return value: %TRUE if @tree_view is in hover selection mode
15646  *
15647  * Since: 2.6
15648  **/
15649 gboolean
15650 gtk_tree_view_get_hover_selection (GtkTreeView *tree_view)
15651 {
15652   return tree_view->priv->hover_selection;
15653 }
15654
15655 /**
15656  * gtk_tree_view_set_hover_expand:
15657  * @tree_view: a #GtkTreeView
15658  * @expand: %TRUE to enable hover selection mode
15659  *
15660  * Enables of disables the hover expansion mode of @tree_view.
15661  * Hover expansion makes rows expand or collapse if the pointer
15662  * moves over them.
15663  *
15664  * Since: 2.6
15665  **/
15666 void
15667 gtk_tree_view_set_hover_expand (GtkTreeView *tree_view,
15668                                 gboolean     expand)
15669 {
15670   expand = expand != FALSE;
15671
15672   if (expand != tree_view->priv->hover_expand)
15673     {
15674       tree_view->priv->hover_expand = expand;
15675
15676       g_object_notify (G_OBJECT (tree_view), "hover-expand");
15677     }
15678 }
15679
15680 /**
15681  * gtk_tree_view_get_hover_expand:
15682  * @tree_view: a #GtkTreeView
15683  *
15684  * Returns whether hover expansion mode is turned on for @tree_view.
15685  *
15686  * Return value: %TRUE if @tree_view is in hover expansion mode
15687  *
15688  * Since: 2.6
15689  **/
15690 gboolean
15691 gtk_tree_view_get_hover_expand (GtkTreeView *tree_view)
15692 {
15693   return tree_view->priv->hover_expand;
15694 }
15695
15696 /**
15697  * gtk_tree_view_set_rubber_banding:
15698  * @tree_view: a #GtkTreeView
15699  * @enable: %TRUE to enable rubber banding
15700  *
15701  * Enables or disables rubber banding in @tree_view.  If the selection mode
15702  * is #GTK_SELECTION_MULTIPLE, rubber banding will allow the user to select
15703  * multiple rows by dragging the mouse.
15704  *
15705  * Since: 2.10
15706  **/
15707 void
15708 gtk_tree_view_set_rubber_banding (GtkTreeView *tree_view,
15709                                   gboolean     enable)
15710 {
15711   enable = enable != FALSE;
15712
15713   if (enable != tree_view->priv->rubber_banding_enable)
15714     {
15715       tree_view->priv->rubber_banding_enable = enable;
15716
15717       g_object_notify (G_OBJECT (tree_view), "rubber-banding");
15718     }
15719 }
15720
15721 /**
15722  * gtk_tree_view_get_rubber_banding:
15723  * @tree_view: a #GtkTreeView
15724  *
15725  * Returns whether rubber banding is turned on for @tree_view.  If the
15726  * selection mode is #GTK_SELECTION_MULTIPLE, rubber banding will allow the
15727  * user to select multiple rows by dragging the mouse.
15728  *
15729  * Return value: %TRUE if rubber banding in @tree_view is enabled.
15730  *
15731  * Since: 2.10
15732  **/
15733 gboolean
15734 gtk_tree_view_get_rubber_banding (GtkTreeView *tree_view)
15735 {
15736   return tree_view->priv->rubber_banding_enable;
15737 }
15738
15739 /**
15740  * gtk_tree_view_is_rubber_banding_active:
15741  * @tree_view: a #GtkTreeView
15742  *
15743  * Returns whether a rubber banding operation is currently being done
15744  * in @tree_view.
15745  *
15746  * Return value: %TRUE if a rubber banding operation is currently being
15747  * done in @tree_view.
15748  *
15749  * Since: 2.12
15750  **/
15751 gboolean
15752 gtk_tree_view_is_rubber_banding_active (GtkTreeView *tree_view)
15753 {
15754   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
15755
15756   if (tree_view->priv->rubber_banding_enable
15757       && tree_view->priv->rubber_band_status == RUBBER_BAND_ACTIVE)
15758     return TRUE;
15759
15760   return FALSE;
15761 }
15762
15763 /**
15764  * gtk_tree_view_get_row_separator_func: (skip)
15765  * @tree_view: a #GtkTreeView
15766  *
15767  * Returns the current row separator function.
15768  *
15769  * Return value: the current row separator function.
15770  *
15771  * Since: 2.6
15772  **/
15773 GtkTreeViewRowSeparatorFunc
15774 gtk_tree_view_get_row_separator_func (GtkTreeView *tree_view)
15775 {
15776   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
15777
15778   return tree_view->priv->row_separator_func;
15779 }
15780
15781 /**
15782  * gtk_tree_view_set_row_separator_func:
15783  * @tree_view: a #GtkTreeView
15784  * @func: (allow-none): a #GtkTreeViewRowSeparatorFunc
15785  * @data: (allow-none): user data to pass to @func, or %NULL
15786  * @destroy: (allow-none): destroy notifier for @data, or %NULL
15787  *
15788  * Sets the row separator function, which is used to determine
15789  * whether a row should be drawn as a separator. If the row separator
15790  * function is %NULL, no separators are drawn. This is the default value.
15791  *
15792  * Since: 2.6
15793  **/
15794 void
15795 gtk_tree_view_set_row_separator_func (GtkTreeView                 *tree_view,
15796                                       GtkTreeViewRowSeparatorFunc  func,
15797                                       gpointer                     data,
15798                                       GDestroyNotify               destroy)
15799 {
15800   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
15801
15802   if (tree_view->priv->row_separator_destroy)
15803     tree_view->priv->row_separator_destroy (tree_view->priv->row_separator_data);
15804
15805   tree_view->priv->row_separator_func = func;
15806   tree_view->priv->row_separator_data = data;
15807   tree_view->priv->row_separator_destroy = destroy;
15808
15809   /* Have the tree recalculate heights */
15810   _gtk_rbtree_mark_invalid (tree_view->priv->tree);
15811   gtk_widget_queue_resize (GTK_WIDGET (tree_view));
15812 }
15813
15814
15815 static void
15816 gtk_tree_view_grab_notify (GtkWidget *widget,
15817                            gboolean   was_grabbed)
15818 {
15819   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
15820
15821   tree_view->priv->in_grab = !was_grabbed;
15822
15823   if (!was_grabbed)
15824     {
15825       tree_view->priv->pressed_button = -1;
15826
15827       if (tree_view->priv->rubber_band_status)
15828         gtk_tree_view_stop_rubber_band (tree_view);
15829     }
15830 }
15831
15832 static void
15833 gtk_tree_view_state_flags_changed (GtkWidget     *widget,
15834                                    GtkStateFlags  previous_state)
15835 {
15836   if (gtk_widget_get_realized (widget))
15837     {
15838       GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
15839       GtkStyleContext *context;
15840
15841       context = gtk_widget_get_style_context (widget);
15842       gtk_style_context_set_background (context, tree_view->priv->bin_window);
15843     }
15844
15845   gtk_widget_queue_draw (widget);
15846 }
15847
15848 /**
15849  * gtk_tree_view_get_grid_lines:
15850  * @tree_view: a #GtkTreeView
15851  *
15852  * Returns which grid lines are enabled in @tree_view.
15853  *
15854  * Return value: a #GtkTreeViewGridLines value indicating which grid lines
15855  * are enabled.
15856  *
15857  * Since: 2.10
15858  */
15859 GtkTreeViewGridLines
15860 gtk_tree_view_get_grid_lines (GtkTreeView *tree_view)
15861 {
15862   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), 0);
15863
15864   return tree_view->priv->grid_lines;
15865 }
15866
15867 /**
15868  * gtk_tree_view_set_grid_lines:
15869  * @tree_view: a #GtkTreeView
15870  * @grid_lines: a #GtkTreeViewGridLines value indicating which grid lines to
15871  * enable.
15872  *
15873  * Sets which grid lines to draw in @tree_view.
15874  *
15875  * Since: 2.10
15876  */
15877 void
15878 gtk_tree_view_set_grid_lines (GtkTreeView           *tree_view,
15879                               GtkTreeViewGridLines   grid_lines)
15880 {
15881   GtkTreeViewPrivate *priv;
15882   GtkWidget *widget;
15883   GtkTreeViewGridLines old_grid_lines;
15884
15885   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
15886
15887   priv = tree_view->priv;
15888   widget = GTK_WIDGET (tree_view);
15889
15890   old_grid_lines = priv->grid_lines;
15891   priv->grid_lines = grid_lines;
15892
15893   if (gtk_widget_get_realized (widget))
15894     {
15895       if (grid_lines == GTK_TREE_VIEW_GRID_LINES_NONE &&
15896           priv->grid_line_width)
15897         {
15898           priv->grid_line_width = 0;
15899         }
15900
15901       if (grid_lines != GTK_TREE_VIEW_GRID_LINES_NONE &&
15902           !priv->grid_line_width)
15903         {
15904           gint8 *dash_list;
15905
15906           gtk_widget_style_get (widget,
15907                                 "grid-line-width", &priv->grid_line_width,
15908                                 "grid-line-pattern", (gchar *)&dash_list,
15909                                 NULL);
15910
15911           if (dash_list)
15912             {
15913               priv->grid_line_dashes[0] = dash_list[0];
15914               if (dash_list[0])
15915                 priv->grid_line_dashes[1] = dash_list[1];
15916
15917               g_free (dash_list);
15918             }
15919           else
15920             {
15921               priv->grid_line_dashes[0] = 1;
15922               priv->grid_line_dashes[1] = 1;
15923             }
15924         }
15925     }
15926
15927   if (old_grid_lines != grid_lines)
15928     {
15929       gtk_widget_queue_draw (GTK_WIDGET (tree_view));
15930
15931       g_object_notify (G_OBJECT (tree_view), "enable-grid-lines");
15932     }
15933 }
15934
15935 /**
15936  * gtk_tree_view_get_enable_tree_lines:
15937  * @tree_view: a #GtkTreeView.
15938  *
15939  * Returns whether or not tree lines are drawn in @tree_view.
15940  *
15941  * Return value: %TRUE if tree lines are drawn in @tree_view, %FALSE
15942  * otherwise.
15943  *
15944  * Since: 2.10
15945  */
15946 gboolean
15947 gtk_tree_view_get_enable_tree_lines (GtkTreeView *tree_view)
15948 {
15949   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
15950
15951   return tree_view->priv->tree_lines_enabled;
15952 }
15953
15954 /**
15955  * gtk_tree_view_set_enable_tree_lines:
15956  * @tree_view: a #GtkTreeView
15957  * @enabled: %TRUE to enable tree line drawing, %FALSE otherwise.
15958  *
15959  * Sets whether to draw lines interconnecting the expanders in @tree_view.
15960  * This does not have any visible effects for lists.
15961  *
15962  * Since: 2.10
15963  */
15964 void
15965 gtk_tree_view_set_enable_tree_lines (GtkTreeView *tree_view,
15966                                      gboolean     enabled)
15967 {
15968   GtkTreeViewPrivate *priv;
15969   GtkWidget *widget;
15970   gboolean was_enabled;
15971
15972   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
15973
15974   enabled = enabled != FALSE;
15975
15976   priv = tree_view->priv;
15977   widget = GTK_WIDGET (tree_view);
15978
15979   was_enabled = priv->tree_lines_enabled;
15980
15981   priv->tree_lines_enabled = enabled;
15982
15983   if (gtk_widget_get_realized (widget))
15984     {
15985       if (!enabled && priv->tree_line_width)
15986         {
15987           priv->tree_line_width = 0;
15988         }
15989
15990       if (enabled && !priv->tree_line_width)
15991         {
15992           gint8 *dash_list;
15993           gtk_widget_style_get (widget,
15994                                 "tree-line-width", &priv->tree_line_width,
15995                                 "tree-line-pattern", (gchar *)&dash_list,
15996                                 NULL);
15997
15998           if (dash_list)
15999             {
16000               priv->tree_line_dashes[0] = dash_list[0];
16001               if (dash_list[0])
16002                 priv->tree_line_dashes[1] = dash_list[1];
16003
16004               g_free (dash_list);
16005             }
16006           else
16007             {
16008               priv->tree_line_dashes[0] = 1;
16009               priv->tree_line_dashes[1] = 1;
16010             }
16011         }
16012     }
16013
16014   if (was_enabled != enabled)
16015     {
16016       gtk_widget_queue_draw (GTK_WIDGET (tree_view));
16017
16018       g_object_notify (G_OBJECT (tree_view), "enable-tree-lines");
16019     }
16020 }
16021
16022
16023 /**
16024  * gtk_tree_view_set_show_expanders:
16025  * @tree_view: a #GtkTreeView
16026  * @enabled: %TRUE to enable expander drawing, %FALSE otherwise.
16027  *
16028  * Sets whether to draw and enable expanders and indent child rows in
16029  * @tree_view.  When disabled there will be no expanders visible in trees
16030  * and there will be no way to expand and collapse rows by default.  Also
16031  * note that hiding the expanders will disable the default indentation.  You
16032  * can set a custom indentation in this case using
16033  * gtk_tree_view_set_level_indentation().
16034  * This does not have any visible effects for lists.
16035  *
16036  * Since: 2.12
16037  */
16038 void
16039 gtk_tree_view_set_show_expanders (GtkTreeView *tree_view,
16040                                   gboolean     enabled)
16041 {
16042   gboolean was_enabled;
16043
16044   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
16045
16046   enabled = enabled != FALSE;
16047   was_enabled = tree_view->priv->show_expanders;
16048
16049   tree_view->priv->show_expanders = enabled == TRUE;
16050
16051   if (enabled != was_enabled)
16052     gtk_widget_queue_draw (GTK_WIDGET (tree_view));
16053 }
16054
16055 /**
16056  * gtk_tree_view_get_show_expanders:
16057  * @tree_view: a #GtkTreeView.
16058  *
16059  * Returns whether or not expanders are drawn in @tree_view.
16060  *
16061  * Return value: %TRUE if expanders are drawn in @tree_view, %FALSE
16062  * otherwise.
16063  *
16064  * Since: 2.12
16065  */
16066 gboolean
16067 gtk_tree_view_get_show_expanders (GtkTreeView *tree_view)
16068 {
16069   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
16070
16071   return tree_view->priv->show_expanders;
16072 }
16073
16074 /**
16075  * gtk_tree_view_set_level_indentation:
16076  * @tree_view: a #GtkTreeView
16077  * @indentation: the amount, in pixels, of extra indentation in @tree_view.
16078  *
16079  * Sets the amount of extra indentation for child levels to use in @tree_view
16080  * in addition to the default indentation.  The value should be specified in
16081  * pixels, a value of 0 disables this feature and in this case only the default
16082  * indentation will be used.
16083  * This does not have any visible effects for lists.
16084  *
16085  * Since: 2.12
16086  */
16087 void
16088 gtk_tree_view_set_level_indentation (GtkTreeView *tree_view,
16089                                      gint         indentation)
16090 {
16091   tree_view->priv->level_indentation = indentation;
16092
16093   gtk_widget_queue_draw (GTK_WIDGET (tree_view));
16094 }
16095
16096 /**
16097  * gtk_tree_view_get_level_indentation:
16098  * @tree_view: a #GtkTreeView.
16099  *
16100  * Returns the amount, in pixels, of extra indentation for child levels
16101  * in @tree_view.
16102  *
16103  * Return value: the amount of extra indentation for child levels in
16104  * @tree_view.  A return value of 0 means that this feature is disabled.
16105  *
16106  * Since: 2.12
16107  */
16108 gint
16109 gtk_tree_view_get_level_indentation (GtkTreeView *tree_view)
16110 {
16111   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), 0);
16112
16113   return tree_view->priv->level_indentation;
16114 }
16115
16116 /**
16117  * gtk_tree_view_set_tooltip_row:
16118  * @tree_view: a #GtkTreeView
16119  * @tooltip: a #GtkTooltip
16120  * @path: a #GtkTreePath
16121  *
16122  * Sets the tip area of @tooltip to be the area covered by the row at @path.
16123  * See also gtk_tree_view_set_tooltip_column() for a simpler alternative.
16124  * See also gtk_tooltip_set_tip_area().
16125  *
16126  * Since: 2.12
16127  */
16128 void
16129 gtk_tree_view_set_tooltip_row (GtkTreeView *tree_view,
16130                                GtkTooltip  *tooltip,
16131                                GtkTreePath *path)
16132 {
16133   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
16134   g_return_if_fail (GTK_IS_TOOLTIP (tooltip));
16135
16136   gtk_tree_view_set_tooltip_cell (tree_view, tooltip, path, NULL, NULL);
16137 }
16138
16139 /**
16140  * gtk_tree_view_set_tooltip_cell:
16141  * @tree_view: a #GtkTreeView
16142  * @tooltip: a #GtkTooltip
16143  * @path: (allow-none): a #GtkTreePath or %NULL
16144  * @column: (allow-none): a #GtkTreeViewColumn or %NULL
16145  * @cell: (allow-none): a #GtkCellRenderer or %NULL
16146  *
16147  * Sets the tip area of @tooltip to the area @path, @column and @cell have
16148  * in common.  For example if @path is %NULL and @column is set, the tip
16149  * area will be set to the full area covered by @column.  See also
16150  * gtk_tooltip_set_tip_area().
16151  *
16152  * Note that if @path is not specified and @cell is set and part of a column
16153  * containing the expander, the tooltip might not show and hide at the correct
16154  * position.  In such cases @path must be set to the current node under the
16155  * mouse cursor for this function to operate correctly.
16156  *
16157  * See also gtk_tree_view_set_tooltip_column() for a simpler alternative.
16158  *
16159  * Since: 2.12
16160  */
16161 void
16162 gtk_tree_view_set_tooltip_cell (GtkTreeView       *tree_view,
16163                                 GtkTooltip        *tooltip,
16164                                 GtkTreePath       *path,
16165                                 GtkTreeViewColumn *column,
16166                                 GtkCellRenderer   *cell)
16167 {
16168   GtkAllocation allocation;
16169   GdkRectangle rect;
16170
16171   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
16172   g_return_if_fail (GTK_IS_TOOLTIP (tooltip));
16173   g_return_if_fail (column == NULL || GTK_IS_TREE_VIEW_COLUMN (column));
16174   g_return_if_fail (cell == NULL || GTK_IS_CELL_RENDERER (cell));
16175
16176   /* Determine x values. */
16177   if (column && cell)
16178     {
16179       GdkRectangle tmp;
16180       gint start, width;
16181
16182       /* We always pass in path here, whether it is NULL or not.
16183        * For cells in expander columns path must be specified so that
16184        * we can correctly account for the indentation.  This also means
16185        * that the tooltip is constrained vertically by the "Determine y
16186        * values" code below; this is not a real problem since cells actually
16187        * don't stretch vertically in constrast to columns.
16188        */
16189       gtk_tree_view_get_cell_area (tree_view, path, column, &tmp);
16190       gtk_tree_view_column_cell_get_position (column, cell, &start, &width);
16191
16192       gtk_tree_view_convert_bin_window_to_widget_coords (tree_view,
16193                                                          tmp.x + start, 0,
16194                                                          &rect.x, NULL);
16195       rect.width = width;
16196     }
16197   else if (column)
16198     {
16199       GdkRectangle tmp;
16200
16201       gtk_tree_view_get_background_area (tree_view, NULL, column, &tmp);
16202       gtk_tree_view_convert_bin_window_to_widget_coords (tree_view,
16203                                                          tmp.x, 0,
16204                                                          &rect.x, NULL);
16205       rect.width = tmp.width;
16206     }
16207   else
16208     {
16209       gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
16210       rect.x = 0;
16211       rect.width = allocation.width;
16212     }
16213
16214   /* Determine y values. */
16215   if (path)
16216     {
16217       GdkRectangle tmp;
16218
16219       gtk_tree_view_get_background_area (tree_view, path, NULL, &tmp);
16220       gtk_tree_view_convert_bin_window_to_widget_coords (tree_view,
16221                                                          0, tmp.y,
16222                                                          NULL, &rect.y);
16223       rect.height = tmp.height;
16224     }
16225   else
16226     {
16227       rect.y = 0;
16228       rect.height = gtk_adjustment_get_page_size (tree_view->priv->vadjustment);
16229     }
16230
16231   gtk_tooltip_set_tip_area (tooltip, &rect);
16232 }
16233
16234 /**
16235  * gtk_tree_view_get_tooltip_context:
16236  * @tree_view: a #GtkTreeView
16237  * @x: (inout): the x coordinate (relative to widget coordinates)
16238  * @y: (inout): the y coordinate (relative to widget coordinates)
16239  * @keyboard_tip: whether this is a keyboard tooltip or not
16240  * @model: (out) (allow-none): a pointer to receive a #GtkTreeModel or %NULL
16241  * @path: (out) (allow-none): a pointer to receive a #GtkTreePath or %NULL
16242  * @iter: (out) (allow-none): a pointer to receive a #GtkTreeIter or %NULL
16243  *
16244  * This function is supposed to be used in a #GtkWidget::query-tooltip
16245  * signal handler for #GtkTreeView.  The @x, @y and @keyboard_tip values
16246  * which are received in the signal handler, should be passed to this
16247  * function without modification.
16248  *
16249  * The return value indicates whether there is a tree view row at the given
16250  * coordinates (%TRUE) or not (%FALSE) for mouse tooltips.  For keyboard
16251  * tooltips the row returned will be the cursor row.  When %TRUE, then any of
16252  * @model, @path and @iter which have been provided will be set to point to
16253  * that row and the corresponding model.  @x and @y will always be converted
16254  * to be relative to @tree_view's bin_window if @keyboard_tooltip is %FALSE.
16255  *
16256  * Return value: whether or not the given tooltip context points to a row.
16257  *
16258  * Since: 2.12
16259  */
16260 gboolean
16261 gtk_tree_view_get_tooltip_context (GtkTreeView   *tree_view,
16262                                    gint          *x,
16263                                    gint          *y,
16264                                    gboolean       keyboard_tip,
16265                                    GtkTreeModel **model,
16266                                    GtkTreePath  **path,
16267                                    GtkTreeIter   *iter)
16268 {
16269   GtkTreePath *tmppath = NULL;
16270
16271   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
16272   g_return_val_if_fail (x != NULL, FALSE);
16273   g_return_val_if_fail (y != NULL, FALSE);
16274
16275   if (keyboard_tip)
16276     {
16277       gtk_tree_view_get_cursor (tree_view, &tmppath, NULL);
16278
16279       if (!tmppath)
16280         return FALSE;
16281     }
16282   else
16283     {
16284       gtk_tree_view_convert_widget_to_bin_window_coords (tree_view, *x, *y,
16285                                                          x, y);
16286
16287       if (!gtk_tree_view_get_path_at_pos (tree_view, *x, *y,
16288                                           &tmppath, NULL, NULL, NULL))
16289         return FALSE;
16290     }
16291
16292   if (model)
16293     *model = gtk_tree_view_get_model (tree_view);
16294
16295   if (iter)
16296     gtk_tree_model_get_iter (gtk_tree_view_get_model (tree_view),
16297                              iter, tmppath);
16298
16299   if (path)
16300     *path = tmppath;
16301   else
16302     gtk_tree_path_free (tmppath);
16303
16304   return TRUE;
16305 }
16306
16307 static gboolean
16308 gtk_tree_view_set_tooltip_query_cb (GtkWidget  *widget,
16309                                     gint        x,
16310                                     gint        y,
16311                                     gboolean    keyboard_tip,
16312                                     GtkTooltip *tooltip,
16313                                     gpointer    data)
16314 {
16315   GValue value = G_VALUE_INIT;
16316   GValue transformed = G_VALUE_INIT;
16317   GtkTreeIter iter;
16318   GtkTreePath *path;
16319   GtkTreeModel *model;
16320   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
16321
16322   if (!gtk_tree_view_get_tooltip_context (GTK_TREE_VIEW (widget),
16323                                           &x, &y,
16324                                           keyboard_tip,
16325                                           &model, &path, &iter))
16326     return FALSE;
16327
16328   gtk_tree_model_get_value (model, &iter,
16329                             tree_view->priv->tooltip_column, &value);
16330
16331   g_value_init (&transformed, G_TYPE_STRING);
16332
16333   if (!g_value_transform (&value, &transformed))
16334     {
16335       g_value_unset (&value);
16336       gtk_tree_path_free (path);
16337
16338       return FALSE;
16339     }
16340
16341   g_value_unset (&value);
16342
16343   if (!g_value_get_string (&transformed))
16344     {
16345       g_value_unset (&transformed);
16346       gtk_tree_path_free (path);
16347
16348       return FALSE;
16349     }
16350
16351   gtk_tooltip_set_markup (tooltip, g_value_get_string (&transformed));
16352   gtk_tree_view_set_tooltip_row (tree_view, tooltip, path);
16353
16354   gtk_tree_path_free (path);
16355   g_value_unset (&transformed);
16356
16357   return TRUE;
16358 }
16359
16360 /**
16361  * gtk_tree_view_set_tooltip_column:
16362  * @tree_view: a #GtkTreeView
16363  * @column: an integer, which is a valid column number for @tree_view's model
16364  *
16365  * If you only plan to have simple (text-only) tooltips on full rows, you
16366  * can use this function to have #GtkTreeView handle these automatically
16367  * for you. @column should be set to the column in @tree_view's model
16368  * containing the tooltip texts, or -1 to disable this feature.
16369  *
16370  * When enabled, #GtkWidget::has-tooltip will be set to %TRUE and
16371  * @tree_view will connect a #GtkWidget::query-tooltip signal handler.
16372  *
16373  * Note that the signal handler sets the text with gtk_tooltip_set_markup(),
16374  * so &amp;, &lt;, etc have to be escaped in the text.
16375  *
16376  * Since: 2.12
16377  */
16378 void
16379 gtk_tree_view_set_tooltip_column (GtkTreeView *tree_view,
16380                                   gint         column)
16381 {
16382   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
16383
16384   if (column == tree_view->priv->tooltip_column)
16385     return;
16386
16387   if (column == -1)
16388     {
16389       g_signal_handlers_disconnect_by_func (tree_view,
16390                                             gtk_tree_view_set_tooltip_query_cb,
16391                                             NULL);
16392       gtk_widget_set_has_tooltip (GTK_WIDGET (tree_view), FALSE);
16393     }
16394   else
16395     {
16396       if (tree_view->priv->tooltip_column == -1)
16397         {
16398           g_signal_connect (tree_view, "query-tooltip",
16399                             G_CALLBACK (gtk_tree_view_set_tooltip_query_cb), NULL);
16400           gtk_widget_set_has_tooltip (GTK_WIDGET (tree_view), TRUE);
16401         }
16402     }
16403
16404   tree_view->priv->tooltip_column = column;
16405   g_object_notify (G_OBJECT (tree_view), "tooltip-column");
16406 }
16407
16408 /**
16409  * gtk_tree_view_get_tooltip_column:
16410  * @tree_view: a #GtkTreeView
16411  *
16412  * Returns the column of @tree_view's model which is being used for
16413  * displaying tooltips on @tree_view's rows.
16414  *
16415  * Return value: the index of the tooltip column that is currently being
16416  * used, or -1 if this is disabled.
16417  *
16418  * Since: 2.12
16419  */
16420 gint
16421 gtk_tree_view_get_tooltip_column (GtkTreeView *tree_view)
16422 {
16423   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), 0);
16424
16425   return tree_view->priv->tooltip_column;
16426 }