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 #include <math.h>
  23 #include <string.h>
  24 #include <gdk/gdkkeysyms.h>
  25
  26 #include "gtktreeview.h"
  27 #include "gtkrbtree.h"
  28 #include "gtktreednd.h"
  29 #include "gtktreeprivate.h"
  30 #include "gtkcellrenderer.h"
  31 #include "gtkmain.h"
  32 #include "gtkmarshalers.h"
  33 #include "gtkbuildable.h"
  34 #include "gtkbutton.h"
  35 #include "gtkalignment.h"
  36 #include "gtklabel.h"
  37 #include "gtkhbox.h"
  38 #include "gtkvbox.h"
  39 #include "gtkarrow.h"
  40 #include "gtkintl.h"
  41 #include "gtkbindings.h"
  42 #include "gtkcontainer.h"
  43 #include "gtkentry.h"
  44 #include "gtkframe.h"
  45 #include "gtktreemodelsort.h"
  46 #include "gtktooltip.h"
  47 #include "gtkscrollable.h"
  48 #include "gtkcelllayout.h"
  49 #include "gtkprivate.h"
  50 #include "gtkwidgetprivate.h"
  51 #include "gtkentryprivate.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_shift;
 402   gint rubber_band_ctrl;
 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 ctrl_pressed : 1;
 467   guint shift_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 void     gtk_tree_view_set_focus_child      (GtkContainer     *container,
 606                                                     GtkWidget        *child);
 607 static gint     gtk_tree_view_focus_out            (GtkWidget        *widget,
 608                                                     GdkEventFocus    *event);
 609 static gint     gtk_tree_view_focus                (GtkWidget        *widget,
 610                                                     GtkDirectionType  direction);
 611 static void     gtk_tree_view_grab_focus           (GtkWidget        *widget);
 612 static void     gtk_tree_view_style_set            (GtkWidget        *widget,
 613                                                     GtkStyle         *previous_style);
 614 static void     gtk_tree_view_grab_notify          (GtkWidget        *widget,
 615                                                     gboolean          was_grabbed);
 616 static void     gtk_tree_view_state_changed        (GtkWidget        *widget,
 617                                                     GtkStateType      previous_state);
 618
 619 /* container signals */
 620 static void     gtk_tree_view_remove               (GtkContainer     *container,
 621                                                     GtkWidget        *widget);
 622 static void     gtk_tree_view_forall               (GtkContainer     *container,
 623                                                     gboolean          include_internals,
 624                                                     GtkCallback       callback,
 625                                                     gpointer          callback_data);
 626
 627 /* Source side drag signals */
 628 static void gtk_tree_view_drag_begin       (GtkWidget        *widget,
 629                                             GdkDragContext   *context);
 630 static void gtk_tree_view_drag_end         (GtkWidget        *widget,
 631                                             GdkDragContext   *context);
 632 static void gtk_tree_view_drag_data_get    (GtkWidget        *widget,
 633                                             GdkDragContext   *context,
 634                                             GtkSelectionData *selection_data,
 635                                             guint             info,
 636                                             guint             time);
 637 static void gtk_tree_view_drag_data_delete (GtkWidget        *widget,
 638                                             GdkDragContext   *context);
 639
 640 /* Target side drag signals */
 641 static void     gtk_tree_view_drag_leave         (GtkWidget        *widget,
 642                                                   GdkDragContext   *context,
 643                                                   guint             time);
 644 static gboolean gtk_tree_view_drag_motion        (GtkWidget        *widget,
 645                                                   GdkDragContext   *context,
 646                                                   gint              x,
 647                                                   gint              y,
 648                                                   guint             time);
 649 static gboolean gtk_tree_view_drag_drop          (GtkWidget        *widget,
 650                                                   GdkDragContext   *context,
 651                                                   gint              x,
 652                                                   gint              y,
 653                                                   guint             time);
 654 static void     gtk_tree_view_drag_data_received (GtkWidget        *widget,
 655                                                   GdkDragContext   *context,
 656                                                   gint              x,
 657                                                   gint              y,
 658                                                   GtkSelectionData *selection_data,
 659                                                   guint             info,
 660                                                   guint             time);
 661
 662 /* tree_model signals */
 663 static void     gtk_tree_view_set_hadjustment             (GtkTreeView     *tree_view,
 664                                                            GtkAdjustment   *adjustment);
 665 static void     gtk_tree_view_set_vadjustment             (GtkTreeView     *tree_view,
 666                                                            GtkAdjustment   *adjustment);
 667 static gboolean gtk_tree_view_real_move_cursor            (GtkTreeView     *tree_view,
 668                                                            GtkMovementStep  step,
 669                                                            gint             count);
 670 static gboolean gtk_tree_view_real_select_all             (GtkTreeView     *tree_view);
 671 static gboolean gtk_tree_view_real_unselect_all           (GtkTreeView     *tree_view);
 672 static gboolean gtk_tree_view_real_select_cursor_row      (GtkTreeView     *tree_view,
 673                                                            gboolean         start_editing);
 674 static gboolean gtk_tree_view_real_toggle_cursor_row      (GtkTreeView     *tree_view);
 675 static gboolean gtk_tree_view_real_expand_collapse_cursor_row (GtkTreeView     *tree_view,
 676                                                                gboolean         logical,
 677                                                                gboolean         expand,
 678                                                                gboolean         open_all);
 679 static gboolean gtk_tree_view_real_select_cursor_parent   (GtkTreeView     *tree_view);
 680 static void gtk_tree_view_row_changed                     (GtkTreeModel    *model,
 681                                                            GtkTreePath     *path,
 682                                                            GtkTreeIter     *iter,
 683                                                            gpointer         data);
 684 static void gtk_tree_view_row_inserted                    (GtkTreeModel    *model,
 685                                                            GtkTreePath     *path,
 686                                                            GtkTreeIter     *iter,
 687                                                            gpointer         data);
 688 static void gtk_tree_view_row_has_child_toggled           (GtkTreeModel    *model,
 689                                                            GtkTreePath     *path,
 690                                                            GtkTreeIter     *iter,
 691                                                            gpointer         data);
 692 static void gtk_tree_view_row_deleted                     (GtkTreeModel    *model,
 693                                                            GtkTreePath     *path,
 694                                                            gpointer         data);
 695 static void gtk_tree_view_rows_reordered                  (GtkTreeModel    *model,
 696                                                            GtkTreePath     *parent,
 697                                                            GtkTreeIter     *iter,
 698                                                            gint            *new_order,
 699                                                            gpointer         data);
 700
 701 /* Incremental reflow */
 702 static gboolean validate_row             (GtkTreeView *tree_view,
 703                                           GtkRBTree   *tree,
 704                                           GtkRBNode   *node,
 705                                           GtkTreeIter *iter,
 706                                           GtkTreePath *path);
 707 static void     validate_visible_area    (GtkTreeView *tree_view);
 708 static gboolean validate_rows_handler    (GtkTreeView *tree_view);
 709 static gboolean do_validate_rows         (GtkTreeView *tree_view,
 710                                           gboolean     size_request);
 711 static gboolean validate_rows            (GtkTreeView *tree_view);
 712 static gboolean presize_handler_callback (gpointer     data);
 713 static void     install_presize_handler  (GtkTreeView *tree_view);
 714 static void     install_scroll_sync_handler (GtkTreeView *tree_view);
 715 static void     gtk_tree_view_set_top_row   (GtkTreeView *tree_view,
 716                                              GtkTreePath *path,
 717                                              gint         offset);
 718 static void     gtk_tree_view_dy_to_top_row (GtkTreeView *tree_view);
 719 static void     gtk_tree_view_top_row_to_dy (GtkTreeView *tree_view);
 720 static void     invalidate_empty_focus      (GtkTreeView *tree_view);
 721
 722 /* Internal functions */
 723 static gboolean gtk_tree_view_is_expander_column             (GtkTreeView        *tree_view,
 724                                                               GtkTreeViewColumn  *column);
 725 static inline gboolean gtk_tree_view_draw_expanders          (GtkTreeView        *tree_view);
 726 static void     gtk_tree_view_add_move_binding               (GtkBindingSet      *binding_set,
 727                                                               guint               keyval,
 728                                                               guint               modmask,
 729                                                               gboolean            add_shifted_binding,
 730                                                               GtkMovementStep     step,
 731                                                               gint                count);
 732 static gint     gtk_tree_view_unref_and_check_selection_tree (GtkTreeView        *tree_view,
 733                                                               GtkRBTree          *tree);
 734 static void     gtk_tree_view_queue_draw_path                (GtkTreeView        *tree_view,
 735                                                               GtkTreePath        *path,
 736                                                               const GdkRectangle *clip_rect);
 737 static void     gtk_tree_view_queue_draw_arrow               (GtkTreeView        *tree_view,
 738                                                               GtkRBTree          *tree,
 739                                                               GtkRBNode          *node);
 740 static void     gtk_tree_view_draw_arrow                     (GtkTreeView        *tree_view,
 741                                                               cairo_t            *cr,
 742                                                               GtkRBTree          *tree,
 743                                                               GtkRBNode          *node,
 744                                                               gint                x,
 745                                                               gint                y);
 746 static void     gtk_tree_view_get_arrow_xrange               (GtkTreeView        *tree_view,
 747                                                               GtkRBTree          *tree,
 748                                                               gint               *x1,
 749                                                               gint               *x2);
 750 static gint     gtk_tree_view_new_column_width               (GtkTreeView        *tree_view,
 751                                                               gint                i,
 752                                                               gint               *x);
 753 static void     gtk_tree_view_adjustment_changed             (GtkAdjustment      *adjustment,
 754                                                               GtkTreeView        *tree_view);
 755 static void     gtk_tree_view_build_tree                     (GtkTreeView        *tree_view,
 756                                                               GtkRBTree          *tree,
 757                                                               GtkTreeIter        *iter,
 758                                                               gint                depth,
 759                                                               gboolean            recurse);
 760 static void     gtk_tree_view_clamp_node_visible             (GtkTreeView        *tree_view,
 761                                                               GtkRBTree          *tree,
 762                                                               GtkRBNode          *node);
 763 static void     gtk_tree_view_clamp_column_visible           (GtkTreeView        *tree_view,
 764                                                               GtkTreeViewColumn  *column,
 765                                                               gboolean            focus_to_cell);
 766 static gboolean gtk_tree_view_maybe_begin_dragging_row       (GtkTreeView        *tree_view,
 767                                                               GdkEventMotion     *event);
 768 static void     gtk_tree_view_focus_to_cursor                (GtkTreeView        *tree_view);
 769 static void     gtk_tree_view_move_cursor_up_down            (GtkTreeView        *tree_view,
 770                                                               gint                count);
 771 static void     gtk_tree_view_move_cursor_page_up_down       (GtkTreeView        *tree_view,
 772                                                               gint                count);
 773 static void     gtk_tree_view_move_cursor_left_right         (GtkTreeView        *tree_view,
 774                                                               gint                count);
 775 static void     gtk_tree_view_move_cursor_start_end          (GtkTreeView        *tree_view,
 776                                                               gint                count);
 777 static gboolean gtk_tree_view_real_collapse_row              (GtkTreeView        *tree_view,
 778                                                               GtkTreePath        *path,
 779                                                               GtkRBTree          *tree,
 780                                                               GtkRBNode          *node,
 781                                                               gboolean            animate);
 782 static gboolean gtk_tree_view_real_expand_row                (GtkTreeView        *tree_view,
 783                                                               GtkTreePath        *path,
 784                                                               GtkRBTree          *tree,
 785                                                               GtkRBNode          *node,
 786                                                               gboolean            open_all,
 787                                                               gboolean            animate);
 788 static void     gtk_tree_view_real_set_cursor                (GtkTreeView        *tree_view,
 789                                                               GtkTreePath        *path,
 790                                                               gboolean            clear_and_select,
 791                                                               gboolean            clamp_node);
 792 static gboolean gtk_tree_view_has_can_focus_cell             (GtkTreeView        *tree_view);
 793 static void     column_sizing_notify                         (GObject            *object,
 794                                                               GParamSpec         *pspec,
 795                                                               gpointer            data);
 796 static gboolean expand_collapse_timeout                      (gpointer            data);
 797 static void     add_expand_collapse_timeout                  (GtkTreeView        *tree_view,
 798                                                               GtkRBTree          *tree,
 799                                                               GtkRBNode          *node,
 800                                                               gboolean            expand);
 801 static void     remove_expand_collapse_timeout               (GtkTreeView        *tree_view);
 802 static void     cancel_arrow_animation                       (GtkTreeView        *tree_view);
 803 static gboolean do_expand_collapse                           (GtkTreeView        *tree_view);
 804 static void     gtk_tree_view_stop_rubber_band               (GtkTreeView        *tree_view);
 805 static void     update_prelight                              (GtkTreeView        *tree_view,
 806                                                               int                 x,
 807                                                               int                 y);
 808
 809 static inline gint gtk_tree_view_get_effective_header_height (GtkTreeView *tree_view);
 810
 811 static inline gint gtk_tree_view_get_cell_area_y_offset      (GtkTreeView *tree_view,
 812                                                               GtkRBTree   *tree,
 813                                                               GtkRBNode   *node,
 814                                                               gint         vertical_separator);
 815 static inline gint gtk_tree_view_get_cell_area_height        (GtkTreeView *tree_view,
 816                                                               GtkRBNode   *node,
 817                                                               gint         vertical_separator);
 818
 819 static inline gint gtk_tree_view_get_row_y_offset            (GtkTreeView *tree_view,
 820                                                               GtkRBTree   *tree,
 821                                                               GtkRBNode   *node);
 822 static inline gint gtk_tree_view_get_row_height              (GtkTreeView *tree_view,
 823                                                               GtkRBNode   *node);
 824
 825 /* interactive search */
 826 static void     gtk_tree_view_ensure_interactive_directory (GtkTreeView *tree_view);
 827 static void     gtk_tree_view_search_dialog_hide        (GtkWidget        *search_dialog,
 828                                                          GtkTreeView      *tree_view,
 829                                                          GdkDevice        *device);
 830 static void     gtk_tree_view_search_position_func      (GtkTreeView      *tree_view,
 831                                                          GtkWidget        *search_dialog,
 832                                                          gpointer          user_data);
 833 static void     gtk_tree_view_search_disable_popdown    (GtkEntry         *entry,
 834                                                          GtkMenu          *menu,
 835                                                          gpointer          data);
 836 static void     gtk_tree_view_search_preedit_changed    (GtkIMContext     *im_context,
 837                                                          GtkTreeView      *tree_view);
 838 static void     gtk_tree_view_search_activate           (GtkEntry         *entry,
 839                                                          GtkTreeView      *tree_view);
 840 static gboolean gtk_tree_view_real_search_enable_popdown(gpointer          data);
 841 static void     gtk_tree_view_search_enable_popdown     (GtkWidget        *widget,
 842                                                          gpointer          data);
 843 static gboolean gtk_tree_view_search_delete_event       (GtkWidget        *widget,
 844                                                          GdkEventAny      *event,
 845                                                          GtkTreeView      *tree_view);
 846 static gboolean gtk_tree_view_search_button_press_event (GtkWidget        *widget,
 847                                                          GdkEventButton   *event,
 848                                                          GtkTreeView      *tree_view);
 849 static gboolean gtk_tree_view_search_scroll_event       (GtkWidget        *entry,
 850                                                          GdkEventScroll   *event,
 851                                                          GtkTreeView      *tree_view);
 852 static gboolean gtk_tree_view_search_key_press_event    (GtkWidget        *entry,
 853                                                          GdkEventKey      *event,
 854                                                          GtkTreeView      *tree_view);
 855 static gboolean gtk_tree_view_search_move               (GtkWidget        *window,
 856                                                          GtkTreeView      *tree_view,
 857                                                          gboolean          up);
 858 static gboolean gtk_tree_view_search_equal_func         (GtkTreeModel     *model,
 859                                                          gint              column,
 860                                                          const gchar      *key,
 861                                                          GtkTreeIter      *iter,
 862                                                          gpointer          search_data);
 863 static gboolean gtk_tree_view_search_iter               (GtkTreeModel     *model,
 864                                                          GtkTreeSelection *selection,
 865                                                          GtkTreeIter      *iter,
 866                                                          const gchar      *text,
 867                                                          gint             *count,
 868                                                          gint              n);
 869 static void     gtk_tree_view_search_init               (GtkWidget        *entry,
 870                                                          GtkTreeView      *tree_view);
 871 static void     gtk_tree_view_put                       (GtkTreeView      *tree_view,
 872                                                          GtkWidget        *child_widget,
 873                                                          gint              x,
 874                                                          gint              y,
 875                                                          gint              width,
 876                                                          gint              height);
 877 static gboolean gtk_tree_view_start_editing             (GtkTreeView      *tree_view,
 878                                                          GtkTreePath      *cursor_path,
 879                                                          gboolean          edit_only);
 880 static void gtk_tree_view_stop_editing                  (GtkTreeView *tree_view,
 881                                                          gboolean     cancel_editing);
 882 static gboolean gtk_tree_view_real_start_interactive_search (GtkTreeView *tree_view,
 883                                                              GdkDevice   *device,
 884                                                              gboolean     keybinding);
 885 static gboolean gtk_tree_view_start_interactive_search      (GtkTreeView *tree_view);
 886 static GtkTreeViewColumn *gtk_tree_view_get_drop_column (GtkTreeView       *tree_view,
 887                                                          GtkTreeViewColumn *column,
 888                                                          gint               drop_position);
 889
 890 /* GtkBuildable */
 891 static void     gtk_tree_view_buildable_add_child          (GtkBuildable      *tree_view,
 892                                                             GtkBuilder        *builder,
 893                                                             GObject           *child,
 894                                                             const gchar       *type);
 895 static GObject *gtk_tree_view_buildable_get_internal_child (GtkBuildable      *buildable,
 896                                                             GtkBuilder        *builder,
 897                                                             const gchar       *childname);
 898 static void     gtk_tree_view_buildable_init               (GtkBuildableIface *iface);
 899
 900
 901 static gboolean scroll_row_timeout                   (gpointer     data);
 902 static void     add_scroll_timeout                   (GtkTreeView *tree_view);
 903 static void     remove_scroll_timeout                (GtkTreeView *tree_view);
 904
 905 static guint tree_view_signals [LAST_SIGNAL] = { 0 };
 906
 907 \f
 908
 909 /* GType Methods
 910  */
 911
 912 G_DEFINE_TYPE_WITH_CODE (GtkTreeView, gtk_tree_view, GTK_TYPE_CONTAINER,
 913                          G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE,
 914                                                 gtk_tree_view_buildable_init)
 915                          G_IMPLEMENT_INTERFACE (GTK_TYPE_SCROLLABLE, NULL))
 916
 917 static void
 918 gtk_tree_view_class_init (GtkTreeViewClass *class)
 919 {
 920   GObjectClass *o_class;
 921   GtkWidgetClass *widget_class;
 922   GtkContainerClass *container_class;
 923   GtkBindingSet *binding_set;
 924
 925   binding_set = gtk_binding_set_by_class (class);
 926
 927   o_class = (GObjectClass *) class;
 928   widget_class = (GtkWidgetClass *) class;
 929   container_class = (GtkContainerClass *) class;
 930
 931   /* GObject signals */
 932   o_class->set_property = gtk_tree_view_set_property;
 933   o_class->get_property = gtk_tree_view_get_property;
 934   o_class->finalize = gtk_tree_view_finalize;
 935
 936   /* GtkWidget signals */
 937   widget_class->destroy = gtk_tree_view_destroy;
 938   widget_class->map = gtk_tree_view_map;
 939   widget_class->realize = gtk_tree_view_realize;
 940   widget_class->unrealize = gtk_tree_view_unrealize;
 941   widget_class->get_preferred_width = gtk_tree_view_get_preferred_width;
 942   widget_class->get_preferred_height = gtk_tree_view_get_preferred_height;
 943   widget_class->size_allocate = gtk_tree_view_size_allocate;
 944   widget_class->button_press_event = gtk_tree_view_button_press;
 945   widget_class->button_release_event = gtk_tree_view_button_release;
 946   widget_class->grab_broken_event = gtk_tree_view_grab_broken;
 947   /*widget_class->configure_event = gtk_tree_view_configure;*/
 948   widget_class->motion_notify_event = gtk_tree_view_motion;
 949   widget_class->draw = gtk_tree_view_draw;
 950   widget_class->key_press_event = gtk_tree_view_key_press;
 951   widget_class->key_release_event = gtk_tree_view_key_release;
 952   widget_class->enter_notify_event = gtk_tree_view_enter_notify;
 953   widget_class->leave_notify_event = gtk_tree_view_leave_notify;
 954   widget_class->focus_out_event = gtk_tree_view_focus_out;
 955   widget_class->drag_begin = gtk_tree_view_drag_begin;
 956   widget_class->drag_end = gtk_tree_view_drag_end;
 957   widget_class->drag_data_get = gtk_tree_view_drag_data_get;
 958   widget_class->drag_data_delete = gtk_tree_view_drag_data_delete;
 959   widget_class->drag_leave = gtk_tree_view_drag_leave;
 960   widget_class->drag_motion = gtk_tree_view_drag_motion;
 961   widget_class->drag_drop = gtk_tree_view_drag_drop;
 962   widget_class->drag_data_received = gtk_tree_view_drag_data_received;
 963   widget_class->focus = gtk_tree_view_focus;
 964   widget_class->grab_focus = gtk_tree_view_grab_focus;
 965   widget_class->style_set = gtk_tree_view_style_set;
 966   widget_class->grab_notify = gtk_tree_view_grab_notify;
 967   widget_class->state_changed = gtk_tree_view_state_changed;
 968
 969   /* GtkContainer signals */
 970   container_class->remove = gtk_tree_view_remove;
 971   container_class->forall = gtk_tree_view_forall;
 972   container_class->set_focus_child = gtk_tree_view_set_focus_child;
 973
 974   class->move_cursor = gtk_tree_view_real_move_cursor;
 975   class->select_all = gtk_tree_view_real_select_all;
 976   class->unselect_all = gtk_tree_view_real_unselect_all;
 977   class->select_cursor_row = gtk_tree_view_real_select_cursor_row;
 978   class->toggle_cursor_row = gtk_tree_view_real_toggle_cursor_row;
 979   class->expand_collapse_cursor_row = gtk_tree_view_real_expand_collapse_cursor_row;
 980   class->select_cursor_parent = gtk_tree_view_real_select_cursor_parent;
 981   class->start_interactive_search = gtk_tree_view_start_interactive_search;
 982
 983   /* Properties */
 984
 985   g_object_class_install_property (o_class,
 986                                    PROP_MODEL,
 987                                    g_param_spec_object ("model",
 988                                                         P_("TreeView Model"),
 989                                                         P_("The model for the tree view"),
 990                                                         GTK_TYPE_TREE_MODEL,
 991                                                         GTK_PARAM_READWRITE));
 992
 993   g_object_class_override_property (o_class, PROP_HADJUSTMENT,    "hadjustment");
 994   g_object_class_override_property (o_class, PROP_VADJUSTMENT,    "vadjustment");
 995   g_object_class_override_property (o_class, PROP_HSCROLL_POLICY, "hscroll-policy");
 996   g_object_class_override_property (o_class, PROP_VSCROLL_POLICY, "vscroll-policy");
 997
 998   g_object_class_install_property (o_class,
 999                                    PROP_HEADERS_VISIBLE,
1000                                    g_param_spec_boolean ("headers-visible",
1001                                                          P_("Headers Visible"),
1002                                                          P_("Show the column header buttons"),
1003                                                          TRUE,
1004                                                          GTK_PARAM_READWRITE));
1005
1006   g_object_class_install_property (o_class,
1007                                    PROP_HEADERS_CLICKABLE,
1008                                    g_param_spec_boolean ("headers-clickable",
1009                                                          P_("Headers Clickable"),
1010                                                          P_("Column headers respond to click events"),
1011                                                          TRUE,
1012                                                          GTK_PARAM_READWRITE));
1013
1014   g_object_class_install_property (o_class,
1015                                    PROP_EXPANDER_COLUMN,
1016                                    g_param_spec_object ("expander-column",
1017                                                         P_("Expander Column"),
1018                                                         P_("Set the column for the expander column"),
1019                                                         GTK_TYPE_TREE_VIEW_COLUMN,
1020                                                         GTK_PARAM_READWRITE));
1021
1022   g_object_class_install_property (o_class,
1023                                    PROP_REORDERABLE,
1024                                    g_param_spec_boolean ("reorderable",
1025                                                          P_("Reorderable"),
1026                                                          P_("View is reorderable"),
1027                                                          FALSE,
1028                                                          GTK_PARAM_READWRITE));
1029
1030   g_object_class_install_property (o_class,
1031                                    PROP_RULES_HINT,
1032                                    g_param_spec_boolean ("rules-hint",
1033                                                          P_("Rules Hint"),
1034                                                          P_("Set a hint to the theme engine to draw rows in alternating colors"),
1035                                                          FALSE,
1036                                                          GTK_PARAM_READWRITE));
1037
1038     g_object_class_install_property (o_class,
1039                                      PROP_ENABLE_SEARCH,
1040                                      g_param_spec_boolean ("enable-search",
1041                                                            P_("Enable Search"),
1042                                                            P_("View allows user to search through columns interactively"),
1043                                                            TRUE,
1044                                                            GTK_PARAM_READWRITE));
1045
1046     g_object_class_install_property (o_class,
1047                                      PROP_SEARCH_COLUMN,
1048                                      g_param_spec_int ("search-column",
1049                                                        P_("Search Column"),
1050                                                        P_("Model column to search through during interactive search"),
1051                                                        -1,
1052                                                        G_MAXINT,
1053                                                        -1,
1054                                                        GTK_PARAM_READWRITE));
1055
1056     /**
1057      * GtkTreeView:fixed-height-mode:
1058      *
1059      * Setting the ::fixed-height-mode property to %TRUE speeds up
1060      * #GtkTreeView by assuming that all rows have the same height.
1061      * Only enable this option if all rows are the same height.
1062      * Please see gtk_tree_view_set_fixed_height_mode() for more
1063      * information on this option.
1064      *
1065      * Since: 2.4
1066      **/
1067     g_object_class_install_property (o_class,
1068                                      PROP_FIXED_HEIGHT_MODE,
1069                                      g_param_spec_boolean ("fixed-height-mode",
1070                                                            P_("Fixed Height Mode"),
1071                                                            P_("Speeds up GtkTreeView by assuming that all rows have the same height"),
1072                                                            FALSE,
1073                                                            GTK_PARAM_READWRITE));
1074
1075     /**
1076      * GtkTreeView:hover-selection:
1077      *
1078      * Enables or disables the hover selection mode of @tree_view.
1079      * Hover selection makes the selected row follow the pointer.
1080      * Currently, this works only for the selection modes
1081      * %GTK_SELECTION_SINGLE and %GTK_SELECTION_BROWSE.
1082      *
1083      * This mode is primarily intended for treeviews in popups, e.g.
1084      * in #GtkComboBox or #GtkEntryCompletion.
1085      *
1086      * Since: 2.6
1087      */
1088     g_object_class_install_property (o_class,
1089                                      PROP_HOVER_SELECTION,
1090                                      g_param_spec_boolean ("hover-selection",
1091                                                            P_("Hover Selection"),
1092                                                            P_("Whether the selection should follow the pointer"),
1093                                                            FALSE,
1094                                                            GTK_PARAM_READWRITE));
1095
1096     /**
1097      * GtkTreeView:hover-expand:
1098      *
1099      * Enables or disables the hover expansion mode of @tree_view.
1100      * Hover expansion makes rows expand or collapse if the pointer moves
1101      * over them.
1102      *
1103      * This mode is primarily intended for treeviews in popups, e.g.
1104      * in #GtkComboBox or #GtkEntryCompletion.
1105      *
1106      * Since: 2.6
1107      */
1108     g_object_class_install_property (o_class,
1109                                      PROP_HOVER_EXPAND,
1110                                      g_param_spec_boolean ("hover-expand",
1111                                                            P_("Hover Expand"),
1112                                                            P_("Whether rows should be expanded/collapsed when the pointer moves over them"),
1113                                                            FALSE,
1114                                                            GTK_PARAM_READWRITE));
1115
1116     /**
1117      * GtkTreeView:show-expanders:
1118      *
1119      * %TRUE if the view has expanders.
1120      *
1121      * Since: 2.12
1122      */
1123     g_object_class_install_property (o_class,
1124                                      PROP_SHOW_EXPANDERS,
1125                                      g_param_spec_boolean ("show-expanders",
1126                                                            P_("Show Expanders"),
1127                                                            P_("View has expanders"),
1128                                                            TRUE,
1129                                                            GTK_PARAM_READWRITE));
1130
1131     /**
1132      * GtkTreeView:level-indentation:
1133      *
1134      * Extra indentation for each level.
1135      *
1136      * Since: 2.12
1137      */
1138     g_object_class_install_property (o_class,
1139                                      PROP_LEVEL_INDENTATION,
1140                                      g_param_spec_int ("level-indentation",
1141                                                        P_("Level Indentation"),
1142                                                        P_("Extra indentation for each level"),
1143                                                        0,
1144                                                        G_MAXINT,
1145                                                        0,
1146                                                        GTK_PARAM_READWRITE));
1147
1148     g_object_class_install_property (o_class,
1149                                      PROP_RUBBER_BANDING,
1150                                      g_param_spec_boolean ("rubber-banding",
1151                                                            P_("Rubber Banding"),
1152                                                            P_("Whether to enable selection of multiple items by dragging the mouse pointer"),
1153                                                            FALSE,
1154                                                            GTK_PARAM_READWRITE));
1155
1156     g_object_class_install_property (o_class,
1157                                      PROP_ENABLE_GRID_LINES,
1158                                      g_param_spec_enum ("enable-grid-lines",
1159                                                         P_("Enable Grid Lines"),
1160                                                         P_("Whether grid lines should be drawn in the tree view"),
1161                                                         GTK_TYPE_TREE_VIEW_GRID_LINES,
1162                                                         GTK_TREE_VIEW_GRID_LINES_NONE,
1163                                                         GTK_PARAM_READWRITE));
1164
1165     g_object_class_install_property (o_class,
1166                                      PROP_ENABLE_TREE_LINES,
1167                                      g_param_spec_boolean ("enable-tree-lines",
1168                                                            P_("Enable Tree Lines"),
1169                                                            P_("Whether tree lines should be drawn in the tree view"),
1170                                                            FALSE,
1171                                                            GTK_PARAM_READWRITE));
1172
1173     g_object_class_install_property (o_class,
1174                                      PROP_TOOLTIP_COLUMN,
1175                                      g_param_spec_int ("tooltip-column",
1176                                                        P_("Tooltip Column"),
1177                                                        P_("The column in the model containing the tooltip texts for the rows"),
1178                                                        -1,
1179                                                        G_MAXINT,
1180                                                        -1,
1181                                                        GTK_PARAM_READWRITE));
1182
1183   /* Style properties */
1184 #define _TREE_VIEW_EXPANDER_SIZE 12
1185 #define _TREE_VIEW_VERTICAL_SEPARATOR 2
1186 #define _TREE_VIEW_HORIZONTAL_SEPARATOR 2
1187
1188   gtk_widget_class_install_style_property (widget_class,
1189                                            g_param_spec_int ("expander-size",
1190                                                              P_("Expander Size"),
1191                                                              P_("Size of the expander arrow"),
1192                                                              0,
1193                                                              G_MAXINT,
1194                                                              _TREE_VIEW_EXPANDER_SIZE,
1195                                                              GTK_PARAM_READABLE));
1196
1197   gtk_widget_class_install_style_property (widget_class,
1198                                            g_param_spec_int ("vertical-separator",
1199                                                              P_("Vertical Separator Width"),
1200                                                              P_("Vertical space between cells.  Must be an even number"),
1201                                                              0,
1202                                                              G_MAXINT,
1203                                                              _TREE_VIEW_VERTICAL_SEPARATOR,
1204                                                              GTK_PARAM_READABLE));
1205
1206   gtk_widget_class_install_style_property (widget_class,
1207                                            g_param_spec_int ("horizontal-separator",
1208                                                              P_("Horizontal Separator Width"),
1209                                                              P_("Horizontal space between cells.  Must be an even number"),
1210                                                              0,
1211                                                              G_MAXINT,
1212                                                              _TREE_VIEW_HORIZONTAL_SEPARATOR,
1213                                                              GTK_PARAM_READABLE));
1214
1215   gtk_widget_class_install_style_property (widget_class,
1216                                            g_param_spec_boolean ("allow-rules",
1217                                                                  P_("Allow Rules"),
1218                                                                  P_("Allow drawing of alternating color rows"),
1219                                                                  TRUE,
1220                                                                  GTK_PARAM_READABLE));
1221
1222   gtk_widget_class_install_style_property (widget_class,
1223                                            g_param_spec_boolean ("indent-expanders",
1224                                                                  P_("Indent Expanders"),
1225                                                                  P_("Make the expanders indented"),
1226                                                                  TRUE,
1227                                                                  GTK_PARAM_READABLE));
1228
1229   gtk_widget_class_install_style_property (widget_class,
1230                                            g_param_spec_boxed ("even-row-color",
1231                                                                P_("Even Row Color"),
1232                                                                P_("Color to use for even rows"),
1233                                                                GDK_TYPE_COLOR,
1234                                                                GTK_PARAM_READABLE));
1235
1236   gtk_widget_class_install_style_property (widget_class,
1237                                            g_param_spec_boxed ("odd-row-color",
1238                                                                P_("Odd Row Color"),
1239                                                                P_("Color to use for odd rows"),
1240                                                                GDK_TYPE_COLOR,
1241                                                                GTK_PARAM_READABLE));
1242
1243   gtk_widget_class_install_style_property (widget_class,
1244                                            g_param_spec_int ("grid-line-width",
1245                                                              P_("Grid line width"),
1246                                                              P_("Width, in pixels, of the tree view grid lines"),
1247                                                              0, G_MAXINT, 1,
1248                                                              GTK_PARAM_READABLE));
1249
1250   gtk_widget_class_install_style_property (widget_class,
1251                                            g_param_spec_int ("tree-line-width",
1252                                                              P_("Tree line width"),
1253                                                              P_("Width, in pixels, of the tree view lines"),
1254                                                              0, G_MAXINT, 1,
1255                                                              GTK_PARAM_READABLE));
1256
1257   gtk_widget_class_install_style_property (widget_class,
1258                                            g_param_spec_string ("grid-line-pattern",
1259                                                                 P_("Grid line pattern"),
1260                                                                 P_("Dash pattern used to draw the tree view grid lines"),
1261                                                                 "\1\1",
1262                                                                 GTK_PARAM_READABLE));
1263
1264   gtk_widget_class_install_style_property (widget_class,
1265                                            g_param_spec_string ("tree-line-pattern",
1266                                                                 P_("Tree line pattern"),
1267                                                                 P_("Dash pattern used to draw the tree view lines"),
1268                                                                 "\1\1",
1269                                                                 GTK_PARAM_READABLE));
1270
1271   /* Signals */
1272   /**
1273    * GtkTreeView::row-activated:
1274    * @tree_view: the object on which the signal is emitted
1275    * @path: the #GtkTreePath for the activated row
1276    * @column: the #GtkTreeViewColumn in which the activation occurred
1277    *
1278    * The "row-activated" signal is emitted when the method
1279    * gtk_tree_view_row_activated() is called or the user double clicks
1280    * a treeview row. It is also emitted when a non-editable row is
1281    * selected and one of the keys: Space, Shift+Space, Return or
1282    * Enter is pressed.
1283    *
1284    * For selection handling refer to the <link linkend="TreeWidget">tree
1285    * widget conceptual overview</link> as well as #GtkTreeSelection.
1286    */
1287   tree_view_signals[ROW_ACTIVATED] =
1288     g_signal_new (I_("row-activated"),
1289                   G_TYPE_FROM_CLASS (o_class),
1290                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1291                   G_STRUCT_OFFSET (GtkTreeViewClass, row_activated),
1292                   NULL, NULL,
1293                   _gtk_marshal_VOID__BOXED_OBJECT,
1294                   G_TYPE_NONE, 2,
1295                   GTK_TYPE_TREE_PATH,
1296                   GTK_TYPE_TREE_VIEW_COLUMN);
1297
1298   /**
1299    * GtkTreeView::test-expand-row:
1300    * @tree_view: the object on which the signal is emitted
1301    * @iter: the tree iter of the row to expand
1302    * @path: a tree path that points to the row
1303    *
1304    * The given row is about to be expanded (show its children nodes). Use this
1305    * signal if you need to control the expandability of individual rows.
1306    *
1307    * Returns: %FALSE to allow expansion, %TRUE to reject
1308    */
1309   tree_view_signals[TEST_EXPAND_ROW] =
1310     g_signal_new (I_("test-expand-row"),
1311                   G_TYPE_FROM_CLASS (o_class),
1312                   G_SIGNAL_RUN_LAST,
1313                   G_STRUCT_OFFSET (GtkTreeViewClass, test_expand_row),
1314                   _gtk_boolean_handled_accumulator, NULL,
1315                   _gtk_marshal_BOOLEAN__BOXED_BOXED,
1316                   G_TYPE_BOOLEAN, 2,
1317                   GTK_TYPE_TREE_ITER,
1318                   GTK_TYPE_TREE_PATH);
1319
1320   /**
1321    * GtkTreeView::test-collapse-row:
1322    * @tree_view: the object on which the signal is emitted
1323    * @iter: the tree iter of the row to collapse
1324    * @path: a tree path that points to the row
1325    *
1326    * The given row is about to be collapsed (hide its children nodes). Use this
1327    * signal if you need to control the collapsibility of individual rows.
1328    *
1329    * Returns: %FALSE to allow collapsing, %TRUE to reject
1330    */
1331   tree_view_signals[TEST_COLLAPSE_ROW] =
1332     g_signal_new (I_("test-collapse-row"),
1333                   G_TYPE_FROM_CLASS (o_class),
1334                   G_SIGNAL_RUN_LAST,
1335                   G_STRUCT_OFFSET (GtkTreeViewClass, test_collapse_row),
1336                   _gtk_boolean_handled_accumulator, NULL,
1337                   _gtk_marshal_BOOLEAN__BOXED_BOXED,
1338                   G_TYPE_BOOLEAN, 2,
1339                   GTK_TYPE_TREE_ITER,
1340                   GTK_TYPE_TREE_PATH);
1341
1342   /**
1343    * GtkTreeView::row-expanded:
1344    * @tree_view: the object on which the signal is emitted
1345    * @iter: the tree iter of the expanded row
1346    * @path: a tree path that points to the row
1347    *
1348    * The given row has been expanded (child nodes are shown).
1349    */
1350   tree_view_signals[ROW_EXPANDED] =
1351     g_signal_new (I_("row-expanded"),
1352                   G_TYPE_FROM_CLASS (o_class),
1353                   G_SIGNAL_RUN_LAST,
1354                   G_STRUCT_OFFSET (GtkTreeViewClass, row_expanded),
1355                   NULL, NULL,
1356                   _gtk_marshal_VOID__BOXED_BOXED,
1357                   G_TYPE_NONE, 2,
1358                   GTK_TYPE_TREE_ITER,
1359                   GTK_TYPE_TREE_PATH);
1360
1361   /**
1362    * GtkTreeView::row-collapsed:
1363    * @tree_view: the object on which the signal is emitted
1364    * @iter: the tree iter of the collapsed row
1365    * @path: a tree path that points to the row
1366    *
1367    * The given row has been collapsed (child nodes are hidden).
1368    */
1369   tree_view_signals[ROW_COLLAPSED] =
1370     g_signal_new (I_("row-collapsed"),
1371                   G_TYPE_FROM_CLASS (o_class),
1372                   G_SIGNAL_RUN_LAST,
1373                   G_STRUCT_OFFSET (GtkTreeViewClass, row_collapsed),
1374                   NULL, NULL,
1375                   _gtk_marshal_VOID__BOXED_BOXED,
1376                   G_TYPE_NONE, 2,
1377                   GTK_TYPE_TREE_ITER,
1378                   GTK_TYPE_TREE_PATH);
1379
1380   /**
1381    * GtkTreeView::columns-changed:
1382    * @tree_view: the object on which the signal is emitted
1383    *
1384    * The number of columns of the treeview has changed.
1385    */
1386   tree_view_signals[COLUMNS_CHANGED] =
1387     g_signal_new (I_("columns-changed"),
1388                   G_TYPE_FROM_CLASS (o_class),
1389                   G_SIGNAL_RUN_LAST,
1390                   G_STRUCT_OFFSET (GtkTreeViewClass, columns_changed),
1391                   NULL, NULL,
1392                   _gtk_marshal_VOID__VOID,
1393                   G_TYPE_NONE, 0);
1394
1395   /**
1396    * GtkTreeView::cursor-changed:
1397    * @tree_view: the object on which the signal is emitted
1398    *
1399    * The position of the cursor (focused cell) has changed.
1400    */
1401   tree_view_signals[CURSOR_CHANGED] =
1402     g_signal_new (I_("cursor-changed"),
1403                   G_TYPE_FROM_CLASS (o_class),
1404                   G_SIGNAL_RUN_LAST,
1405                   G_STRUCT_OFFSET (GtkTreeViewClass, cursor_changed),
1406                   NULL, NULL,
1407                   _gtk_marshal_VOID__VOID,
1408                   G_TYPE_NONE, 0);
1409
1410   tree_view_signals[MOVE_CURSOR] =
1411     g_signal_new (I_("move-cursor"),
1412                   G_TYPE_FROM_CLASS (o_class),
1413                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1414                   G_STRUCT_OFFSET (GtkTreeViewClass, move_cursor),
1415                   NULL, NULL,
1416                   _gtk_marshal_BOOLEAN__ENUM_INT,
1417                   G_TYPE_BOOLEAN, 2,
1418                   GTK_TYPE_MOVEMENT_STEP,
1419                   G_TYPE_INT);
1420
1421   tree_view_signals[SELECT_ALL] =
1422     g_signal_new (I_("select-all"),
1423                   G_TYPE_FROM_CLASS (o_class),
1424                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1425                   G_STRUCT_OFFSET (GtkTreeViewClass, select_all),
1426                   NULL, NULL,
1427                   _gtk_marshal_BOOLEAN__VOID,
1428                   G_TYPE_BOOLEAN, 0);
1429
1430   tree_view_signals[UNSELECT_ALL] =
1431     g_signal_new (I_("unselect-all"),
1432                   G_TYPE_FROM_CLASS (o_class),
1433                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1434                   G_STRUCT_OFFSET (GtkTreeViewClass, unselect_all),
1435                   NULL, NULL,
1436                   _gtk_marshal_BOOLEAN__VOID,
1437                   G_TYPE_BOOLEAN, 0);
1438
1439   tree_view_signals[SELECT_CURSOR_ROW] =
1440     g_signal_new (I_("select-cursor-row"),
1441                   G_TYPE_FROM_CLASS (o_class),
1442                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1443                   G_STRUCT_OFFSET (GtkTreeViewClass, select_cursor_row),
1444                   NULL, NULL,
1445                   _gtk_marshal_BOOLEAN__BOOLEAN,
1446                   G_TYPE_BOOLEAN, 1,
1447                   G_TYPE_BOOLEAN);
1448
1449   tree_view_signals[TOGGLE_CURSOR_ROW] =
1450     g_signal_new (I_("toggle-cursor-row"),
1451                   G_TYPE_FROM_CLASS (o_class),
1452                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1453                   G_STRUCT_OFFSET (GtkTreeViewClass, toggle_cursor_row),
1454                   NULL, NULL,
1455                   _gtk_marshal_BOOLEAN__VOID,
1456                   G_TYPE_BOOLEAN, 0);
1457
1458   tree_view_signals[EXPAND_COLLAPSE_CURSOR_ROW] =
1459     g_signal_new (I_("expand-collapse-cursor-row"),
1460                   G_TYPE_FROM_CLASS (o_class),
1461                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1462                   G_STRUCT_OFFSET (GtkTreeViewClass, expand_collapse_cursor_row),
1463                   NULL, NULL,
1464                   _gtk_marshal_BOOLEAN__BOOLEAN_BOOLEAN_BOOLEAN,
1465                   G_TYPE_BOOLEAN, 3,
1466                   G_TYPE_BOOLEAN,
1467                   G_TYPE_BOOLEAN,
1468                   G_TYPE_BOOLEAN);
1469
1470   tree_view_signals[SELECT_CURSOR_PARENT] =
1471     g_signal_new (I_("select-cursor-parent"),
1472                   G_TYPE_FROM_CLASS (o_class),
1473                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1474                   G_STRUCT_OFFSET (GtkTreeViewClass, select_cursor_parent),
1475                   NULL, NULL,
1476                   _gtk_marshal_BOOLEAN__VOID,
1477                   G_TYPE_BOOLEAN, 0);
1478
1479   tree_view_signals[START_INTERACTIVE_SEARCH] =
1480     g_signal_new (I_("start-interactive-search"),
1481                   G_TYPE_FROM_CLASS (o_class),
1482                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1483                   G_STRUCT_OFFSET (GtkTreeViewClass, start_interactive_search),
1484                   NULL, NULL,
1485                   _gtk_marshal_BOOLEAN__VOID,
1486                   G_TYPE_BOOLEAN, 0);
1487
1488   /* Key bindings */
1489   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_Up, 0, TRUE,
1490                                   GTK_MOVEMENT_DISPLAY_LINES, -1);
1491   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_KP_Up, 0, TRUE,
1492                                   GTK_MOVEMENT_DISPLAY_LINES, -1);
1493
1494   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_Down, 0, TRUE,
1495                                   GTK_MOVEMENT_DISPLAY_LINES, 1);
1496   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_KP_Down, 0, TRUE,
1497                                   GTK_MOVEMENT_DISPLAY_LINES, 1);
1498
1499   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_p, GDK_CONTROL_MASK, FALSE,
1500                                   GTK_MOVEMENT_DISPLAY_LINES, -1);
1501
1502   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_n, GDK_CONTROL_MASK, FALSE,
1503                                   GTK_MOVEMENT_DISPLAY_LINES, 1);
1504
1505   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_Home, 0, TRUE,
1506                                   GTK_MOVEMENT_BUFFER_ENDS, -1);
1507   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_KP_Home, 0, TRUE,
1508                                   GTK_MOVEMENT_BUFFER_ENDS, -1);
1509
1510   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_End, 0, TRUE,
1511                                   GTK_MOVEMENT_BUFFER_ENDS, 1);
1512   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_KP_End, 0, TRUE,
1513                                   GTK_MOVEMENT_BUFFER_ENDS, 1);
1514
1515   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_Page_Up, 0, TRUE,
1516                                   GTK_MOVEMENT_PAGES, -1);
1517   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_KP_Page_Up, 0, TRUE,
1518                                   GTK_MOVEMENT_PAGES, -1);
1519
1520   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_Page_Down, 0, TRUE,
1521                                   GTK_MOVEMENT_PAGES, 1);
1522   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_KP_Page_Down, 0, TRUE,
1523                                   GTK_MOVEMENT_PAGES, 1);
1524
1525
1526   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Right, 0, "move-cursor", 2,
1527                                 G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
1528                                 G_TYPE_INT, 1);
1529
1530   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Left, 0, "move-cursor", 2,
1531                                 G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
1532                                 G_TYPE_INT, -1);
1533
1534   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Right, 0, "move-cursor", 2,
1535                                 G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
1536                                 G_TYPE_INT, 1);
1537
1538   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Left, 0, "move-cursor", 2,
1539                                 G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
1540                                 G_TYPE_INT, -1);
1541
1542   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Right, GDK_CONTROL_MASK,
1543                                 "move-cursor", 2,
1544                                 G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
1545                                 G_TYPE_INT, 1);
1546
1547   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Left, GDK_CONTROL_MASK,
1548                                 "move-cursor", 2,
1549                                 G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
1550                                 G_TYPE_INT, -1);
1551
1552   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Right, GDK_CONTROL_MASK,
1553                                 "move-cursor", 2,
1554                                 G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
1555                                 G_TYPE_INT, 1);
1556
1557   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Left, GDK_CONTROL_MASK,
1558                                 "move-cursor", 2,
1559                                 G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
1560                                 G_TYPE_INT, -1);
1561
1562   gtk_binding_entry_add_signal (binding_set, GDK_KEY_space, GDK_CONTROL_MASK, "toggle-cursor-row", 0);
1563   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Space, GDK_CONTROL_MASK, "toggle-cursor-row", 0);
1564
1565   gtk_binding_entry_add_signal (binding_set, GDK_KEY_a, GDK_CONTROL_MASK, "select-all", 0);
1566   gtk_binding_entry_add_signal (binding_set, GDK_KEY_slash, GDK_CONTROL_MASK, "select-all", 0);
1567
1568   gtk_binding_entry_add_signal (binding_set, GDK_KEY_A, GDK_CONTROL_MASK | GDK_SHIFT_MASK, "unselect-all", 0);
1569   gtk_binding_entry_add_signal (binding_set, GDK_KEY_backslash, GDK_CONTROL_MASK, "unselect-all", 0);
1570
1571   gtk_binding_entry_add_signal (binding_set, GDK_KEY_space, GDK_SHIFT_MASK, "select-cursor-row", 1,
1572                                 G_TYPE_BOOLEAN, TRUE);
1573   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Space, GDK_SHIFT_MASK, "select-cursor-row", 1,
1574                                 G_TYPE_BOOLEAN, TRUE);
1575
1576   gtk_binding_entry_add_signal (binding_set, GDK_KEY_space, 0, "select-cursor-row", 1,
1577                                 G_TYPE_BOOLEAN, TRUE);
1578   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Space, 0, "select-cursor-row", 1,
1579                                 G_TYPE_BOOLEAN, TRUE);
1580   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Return, 0, "select-cursor-row", 1,
1581                                 G_TYPE_BOOLEAN, TRUE);
1582   gtk_binding_entry_add_signal (binding_set, GDK_KEY_ISO_Enter, 0, "select-cursor-row", 1,
1583                                 G_TYPE_BOOLEAN, TRUE);
1584   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Enter, 0, "select-cursor-row", 1,
1585                                 G_TYPE_BOOLEAN, TRUE);
1586
1587   /* expand and collapse rows */
1588   gtk_binding_entry_add_signal (binding_set, GDK_KEY_plus, 0, "expand-collapse-cursor-row", 3,
1589                                 G_TYPE_BOOLEAN, TRUE,
1590                                 G_TYPE_BOOLEAN, TRUE,
1591                                 G_TYPE_BOOLEAN, FALSE);
1592
1593   gtk_binding_entry_add_signal (binding_set, GDK_KEY_asterisk, 0,
1594                                 "expand-collapse-cursor-row", 3,
1595                                 G_TYPE_BOOLEAN, TRUE,
1596                                 G_TYPE_BOOLEAN, TRUE,
1597                                 G_TYPE_BOOLEAN, TRUE);
1598   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Multiply, 0,
1599                                 "expand-collapse-cursor-row", 3,
1600                                 G_TYPE_BOOLEAN, TRUE,
1601                                 G_TYPE_BOOLEAN, TRUE,
1602                                 G_TYPE_BOOLEAN, TRUE);
1603
1604   gtk_binding_entry_add_signal (binding_set, GDK_KEY_slash, 0,
1605                                 "expand-collapse-cursor-row", 3,
1606                                 G_TYPE_BOOLEAN, TRUE,
1607                                 G_TYPE_BOOLEAN, FALSE,
1608                                 G_TYPE_BOOLEAN, FALSE);
1609   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Divide, 0,
1610                                 "expand-collapse-cursor-row", 3,
1611                                 G_TYPE_BOOLEAN, TRUE,
1612                                 G_TYPE_BOOLEAN, FALSE,
1613                                 G_TYPE_BOOLEAN, FALSE);
1614
1615   /* Not doable on US keyboards */
1616   gtk_binding_entry_add_signal (binding_set, GDK_KEY_plus, GDK_SHIFT_MASK, "expand-collapse-cursor-row", 3,
1617                                 G_TYPE_BOOLEAN, TRUE,
1618                                 G_TYPE_BOOLEAN, TRUE,
1619                                 G_TYPE_BOOLEAN, TRUE);
1620   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Add, 0, "expand-collapse-cursor-row", 3,
1621                                 G_TYPE_BOOLEAN, TRUE,
1622                                 G_TYPE_BOOLEAN, TRUE,
1623                                 G_TYPE_BOOLEAN, FALSE);
1624   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Add, GDK_SHIFT_MASK, "expand-collapse-cursor-row", 3,
1625                                 G_TYPE_BOOLEAN, TRUE,
1626                                 G_TYPE_BOOLEAN, TRUE,
1627                                 G_TYPE_BOOLEAN, TRUE);
1628   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Add, GDK_SHIFT_MASK, "expand-collapse-cursor-row", 3,
1629                                 G_TYPE_BOOLEAN, TRUE,
1630                                 G_TYPE_BOOLEAN, TRUE,
1631                                 G_TYPE_BOOLEAN, TRUE);
1632   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Right, 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, GDK_SHIFT_MASK,
1638                                 "expand-collapse-cursor-row", 3,
1639                                 G_TYPE_BOOLEAN, FALSE,
1640                                 G_TYPE_BOOLEAN, TRUE,
1641                                 G_TYPE_BOOLEAN, TRUE);
1642   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Right,
1643                                 GDK_CONTROL_MASK | GDK_SHIFT_MASK,
1644                                 "expand-collapse-cursor-row", 3,
1645                                 G_TYPE_BOOLEAN, FALSE,
1646                                 G_TYPE_BOOLEAN, TRUE,
1647                                 G_TYPE_BOOLEAN, TRUE);
1648   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Right,
1649                                 GDK_CONTROL_MASK | GDK_SHIFT_MASK,
1650                                 "expand-collapse-cursor-row", 3,
1651                                 G_TYPE_BOOLEAN, FALSE,
1652                                 G_TYPE_BOOLEAN, TRUE,
1653                                 G_TYPE_BOOLEAN, TRUE);
1654
1655   gtk_binding_entry_add_signal (binding_set, GDK_KEY_minus, 0, "expand-collapse-cursor-row", 3,
1656                                 G_TYPE_BOOLEAN, TRUE,
1657                                 G_TYPE_BOOLEAN, FALSE,
1658                                 G_TYPE_BOOLEAN, FALSE);
1659   gtk_binding_entry_add_signal (binding_set, GDK_KEY_minus, GDK_SHIFT_MASK, "expand-collapse-cursor-row", 3,
1660                                 G_TYPE_BOOLEAN, TRUE,
1661                                 G_TYPE_BOOLEAN, FALSE,
1662                                 G_TYPE_BOOLEAN, TRUE);
1663   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Subtract, 0, "expand-collapse-cursor-row", 3,
1664                                 G_TYPE_BOOLEAN, TRUE,
1665                                 G_TYPE_BOOLEAN, FALSE,
1666                                 G_TYPE_BOOLEAN, FALSE);
1667   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Subtract, GDK_SHIFT_MASK, "expand-collapse-cursor-row", 3,
1668                                 G_TYPE_BOOLEAN, TRUE,
1669                                 G_TYPE_BOOLEAN, FALSE,
1670                                 G_TYPE_BOOLEAN, TRUE);
1671   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Left, 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, GDK_SHIFT_MASK,
1677                                 "expand-collapse-cursor-row", 3,
1678                                 G_TYPE_BOOLEAN, FALSE,
1679                                 G_TYPE_BOOLEAN, FALSE,
1680                                 G_TYPE_BOOLEAN, TRUE);
1681   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Left,
1682                                 GDK_CONTROL_MASK | GDK_SHIFT_MASK,
1683                                 "expand-collapse-cursor-row", 3,
1684                                 G_TYPE_BOOLEAN, FALSE,
1685                                 G_TYPE_BOOLEAN, FALSE,
1686                                 G_TYPE_BOOLEAN, TRUE);
1687   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Left,
1688                                 GDK_CONTROL_MASK | GDK_SHIFT_MASK,
1689                                 "expand-collapse-cursor-row", 3,
1690                                 G_TYPE_BOOLEAN, FALSE,
1691                                 G_TYPE_BOOLEAN, FALSE,
1692                                 G_TYPE_BOOLEAN, TRUE);
1693
1694   gtk_binding_entry_add_signal (binding_set, GDK_KEY_BackSpace, 0, "select-cursor-parent", 0);
1695   gtk_binding_entry_add_signal (binding_set, GDK_KEY_BackSpace, GDK_CONTROL_MASK, "select-cursor-parent", 0);
1696
1697   gtk_binding_entry_add_signal (binding_set, GDK_KEY_f, GDK_CONTROL_MASK, "start-interactive-search", 0);
1698
1699   gtk_binding_entry_add_signal (binding_set, GDK_KEY_F, GDK_CONTROL_MASK, "start-interactive-search", 0);
1700
1701   g_type_class_add_private (o_class, sizeof (GtkTreeViewPrivate));
1702 }
1703
1704 static void
1705 gtk_tree_view_init (GtkTreeView *tree_view)
1706 {
1707   tree_view->priv = G_TYPE_INSTANCE_GET_PRIVATE (tree_view, GTK_TYPE_TREE_VIEW, GtkTreeViewPrivate);
1708
1709   gtk_widget_set_can_focus (GTK_WIDGET (tree_view), TRUE);
1710   gtk_widget_set_redraw_on_allocate (GTK_WIDGET (tree_view), FALSE);
1711
1712   tree_view->priv->show_expanders = TRUE;
1713   tree_view->priv->draw_keyfocus = TRUE;
1714   tree_view->priv->headers_visible = TRUE;
1715
1716   /* We need some padding */
1717   tree_view->priv->dy = 0;
1718   tree_view->priv->cursor_offset = 0;
1719   tree_view->priv->n_columns = 0;
1720   tree_view->priv->header_height = 1;
1721   tree_view->priv->x_drag = 0;
1722   tree_view->priv->drag_pos = -1;
1723   tree_view->priv->header_has_focus = FALSE;
1724   tree_view->priv->pressed_button = -1;
1725   tree_view->priv->press_start_x = -1;
1726   tree_view->priv->press_start_y = -1;
1727   tree_view->priv->reorderable = FALSE;
1728   tree_view->priv->presize_handler_timer = 0;
1729   tree_view->priv->scroll_sync_timer = 0;
1730   tree_view->priv->fixed_height = -1;
1731   tree_view->priv->fixed_height_mode = FALSE;
1732   tree_view->priv->fixed_height_check = 0;
1733   tree_view->priv->selection = _gtk_tree_selection_new_with_tree_view (tree_view);
1734   tree_view->priv->enable_search = TRUE;
1735   tree_view->priv->search_column = -1;
1736   tree_view->priv->search_position_func = gtk_tree_view_search_position_func;
1737   tree_view->priv->search_equal_func = gtk_tree_view_search_equal_func;
1738   tree_view->priv->search_custom_entry_set = FALSE;
1739   tree_view->priv->typeselect_flush_timeout = 0;
1740   tree_view->priv->init_hadjust_value = TRUE;
1741   tree_view->priv->width = 0;
1742
1743   tree_view->priv->hover_selection = FALSE;
1744   tree_view->priv->hover_expand = FALSE;
1745
1746   tree_view->priv->level_indentation = 0;
1747
1748   tree_view->priv->rubber_banding_enable = FALSE;
1749
1750   tree_view->priv->grid_lines = GTK_TREE_VIEW_GRID_LINES_NONE;
1751   tree_view->priv->tree_lines_enabled = FALSE;
1752
1753   tree_view->priv->tooltip_column = -1;
1754
1755   tree_view->priv->post_validation_flag = FALSE;
1756
1757   tree_view->priv->last_button_x = -1;
1758   tree_view->priv->last_button_y = -1;
1759
1760   tree_view->priv->event_last_x = -10000;
1761   tree_view->priv->event_last_y = -10000;
1762
1763   gtk_tree_view_set_vadjustment (tree_view, NULL);
1764   gtk_tree_view_set_hadjustment (tree_view, NULL);
1765 }
1766
1767 \f
1768
1769 /* GObject Methods
1770  */
1771
1772 static void
1773 gtk_tree_view_set_property (GObject         *object,
1774                             guint            prop_id,
1775                             const GValue    *value,
1776                             GParamSpec      *pspec)
1777 {
1778   GtkTreeView *tree_view;
1779
1780   tree_view = GTK_TREE_VIEW (object);
1781
1782   switch (prop_id)
1783     {
1784     case PROP_MODEL:
1785       gtk_tree_view_set_model (tree_view, g_value_get_object (value));
1786       break;
1787     case PROP_HADJUSTMENT:
1788       gtk_tree_view_set_hadjustment (tree_view, g_value_get_object (value));
1789       break;
1790     case PROP_VADJUSTMENT:
1791       gtk_tree_view_set_vadjustment (tree_view, g_value_get_object (value));
1792       break;
1793     case PROP_HSCROLL_POLICY:
1794       tree_view->priv->hscroll_policy = g_value_get_enum (value);
1795       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
1796       break;
1797     case PROP_VSCROLL_POLICY:
1798       tree_view->priv->vscroll_policy = g_value_get_enum (value);
1799       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
1800       break;
1801     case PROP_HEADERS_VISIBLE:
1802       gtk_tree_view_set_headers_visible (tree_view, g_value_get_boolean (value));
1803       break;
1804     case PROP_HEADERS_CLICKABLE:
1805       gtk_tree_view_set_headers_clickable (tree_view, g_value_get_boolean (value));
1806       break;
1807     case PROP_EXPANDER_COLUMN:
1808       gtk_tree_view_set_expander_column (tree_view, g_value_get_object (value));
1809       break;
1810     case PROP_REORDERABLE:
1811       gtk_tree_view_set_reorderable (tree_view, g_value_get_boolean (value));
1812       break;
1813     case PROP_RULES_HINT:
1814       gtk_tree_view_set_rules_hint (tree_view, g_value_get_boolean (value));
1815       break;
1816     case PROP_ENABLE_SEARCH:
1817       gtk_tree_view_set_enable_search (tree_view, g_value_get_boolean (value));
1818       break;
1819     case PROP_SEARCH_COLUMN:
1820       gtk_tree_view_set_search_column (tree_view, g_value_get_int (value));
1821       break;
1822     case PROP_FIXED_HEIGHT_MODE:
1823       gtk_tree_view_set_fixed_height_mode (tree_view, g_value_get_boolean (value));
1824       break;
1825     case PROP_HOVER_SELECTION:
1826       tree_view->priv->hover_selection = g_value_get_boolean (value);
1827       break;
1828     case PROP_HOVER_EXPAND:
1829       tree_view->priv->hover_expand = g_value_get_boolean (value);
1830       break;
1831     case PROP_SHOW_EXPANDERS:
1832       gtk_tree_view_set_show_expanders (tree_view, g_value_get_boolean (value));
1833       break;
1834     case PROP_LEVEL_INDENTATION:
1835       tree_view->priv->level_indentation = g_value_get_int (value);
1836       break;
1837     case PROP_RUBBER_BANDING:
1838       tree_view->priv->rubber_banding_enable = g_value_get_boolean (value);
1839       break;
1840     case PROP_ENABLE_GRID_LINES:
1841       gtk_tree_view_set_grid_lines (tree_view, g_value_get_enum (value));
1842       break;
1843     case PROP_ENABLE_TREE_LINES:
1844       gtk_tree_view_set_enable_tree_lines (tree_view, g_value_get_boolean (value));
1845       break;
1846     case PROP_TOOLTIP_COLUMN:
1847       gtk_tree_view_set_tooltip_column (tree_view, g_value_get_int (value));
1848       break;
1849     default:
1850       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1851       break;
1852     }
1853 }
1854
1855 static void
1856 gtk_tree_view_get_property (GObject    *object,
1857                             guint       prop_id,
1858                             GValue     *value,
1859                             GParamSpec *pspec)
1860 {
1861   GtkTreeView *tree_view;
1862
1863   tree_view = GTK_TREE_VIEW (object);
1864
1865   switch (prop_id)
1866     {
1867     case PROP_MODEL:
1868       g_value_set_object (value, tree_view->priv->model);
1869       break;
1870     case PROP_HADJUSTMENT:
1871       g_value_set_object (value, tree_view->priv->hadjustment);
1872       break;
1873     case PROP_VADJUSTMENT:
1874       g_value_set_object (value, tree_view->priv->vadjustment);
1875       break;
1876     case PROP_HSCROLL_POLICY:
1877       g_value_set_enum (value, tree_view->priv->hscroll_policy);
1878       break;
1879     case PROP_VSCROLL_POLICY:
1880       g_value_set_enum (value, tree_view->priv->vscroll_policy);
1881       break;
1882     case PROP_HEADERS_VISIBLE:
1883       g_value_set_boolean (value, gtk_tree_view_get_headers_visible (tree_view));
1884       break;
1885     case PROP_HEADERS_CLICKABLE:
1886       g_value_set_boolean (value, gtk_tree_view_get_headers_clickable (tree_view));
1887       break;
1888     case PROP_EXPANDER_COLUMN:
1889       g_value_set_object (value, tree_view->priv->expander_column);
1890       break;
1891     case PROP_REORDERABLE:
1892       g_value_set_boolean (value, tree_view->priv->reorderable);
1893       break;
1894     case PROP_RULES_HINT:
1895       g_value_set_boolean (value, tree_view->priv->has_rules);
1896       break;
1897     case PROP_ENABLE_SEARCH:
1898       g_value_set_boolean (value, tree_view->priv->enable_search);
1899       break;
1900     case PROP_SEARCH_COLUMN:
1901       g_value_set_int (value, tree_view->priv->search_column);
1902       break;
1903     case PROP_FIXED_HEIGHT_MODE:
1904       g_value_set_boolean (value, tree_view->priv->fixed_height_mode);
1905       break;
1906     case PROP_HOVER_SELECTION:
1907       g_value_set_boolean (value, tree_view->priv->hover_selection);
1908       break;
1909     case PROP_HOVER_EXPAND:
1910       g_value_set_boolean (value, tree_view->priv->hover_expand);
1911       break;
1912     case PROP_SHOW_EXPANDERS:
1913       g_value_set_boolean (value, tree_view->priv->show_expanders);
1914       break;
1915     case PROP_LEVEL_INDENTATION:
1916       g_value_set_int (value, tree_view->priv->level_indentation);
1917       break;
1918     case PROP_RUBBER_BANDING:
1919       g_value_set_boolean (value, tree_view->priv->rubber_banding_enable);
1920       break;
1921     case PROP_ENABLE_GRID_LINES:
1922       g_value_set_enum (value, tree_view->priv->grid_lines);
1923       break;
1924     case PROP_ENABLE_TREE_LINES:
1925       g_value_set_boolean (value, tree_view->priv->tree_lines_enabled);
1926       break;
1927     case PROP_TOOLTIP_COLUMN:
1928       g_value_set_int (value, tree_view->priv->tooltip_column);
1929       break;
1930     default:
1931       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1932       break;
1933     }
1934 }
1935
1936 static void
1937 gtk_tree_view_finalize (GObject *object)
1938 {
1939   G_OBJECT_CLASS (gtk_tree_view_parent_class)->finalize (object);
1940 }
1941
1942
1943 static GtkBuildableIface *parent_buildable_iface;
1944
1945 static void
1946 gtk_tree_view_buildable_init (GtkBuildableIface *iface)
1947 {
1948   parent_buildable_iface = g_type_interface_peek_parent (iface);
1949   iface->add_child = gtk_tree_view_buildable_add_child;
1950   iface->get_internal_child = gtk_tree_view_buildable_get_internal_child;
1951 }
1952
1953 static void
1954 gtk_tree_view_buildable_add_child (GtkBuildable *tree_view,
1955                                    GtkBuilder  *builder,
1956                                    GObject     *child,
1957                                    const gchar *type)
1958 {
1959   gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), GTK_TREE_VIEW_COLUMN (child));
1960 }
1961
1962 static GObject *
1963 gtk_tree_view_buildable_get_internal_child (GtkBuildable      *buildable,
1964                                             GtkBuilder        *builder,
1965                                             const gchar       *childname)
1966 {
1967     if (strcmp (childname, "selection") == 0)
1968       return G_OBJECT (GTK_TREE_VIEW (buildable)->priv->selection);
1969
1970     return parent_buildable_iface->get_internal_child (buildable,
1971                                                        builder,
1972                                                        childname);
1973 }
1974
1975 /* GtkWidget Methods
1976  */
1977
1978 static void
1979 gtk_tree_view_free_rbtree (GtkTreeView *tree_view)
1980 {
1981   _gtk_rbtree_free (tree_view->priv->tree);
1982
1983   tree_view->priv->tree = NULL;
1984   tree_view->priv->button_pressed_node = NULL;
1985   tree_view->priv->button_pressed_tree = NULL;
1986   tree_view->priv->prelight_tree = NULL;
1987   tree_view->priv->prelight_node = NULL;
1988   tree_view->priv->expanded_collapsed_node = NULL;
1989   tree_view->priv->expanded_collapsed_tree = NULL;
1990 }
1991
1992 static void
1993 gtk_tree_view_destroy (GtkWidget *widget)
1994 {
1995   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
1996   GList *list;
1997
1998   gtk_tree_view_stop_editing (tree_view, TRUE);
1999
2000   if (tree_view->priv->columns != NULL)
2001     {
2002       list = tree_view->priv->columns;
2003       while (list)
2004         {
2005           GtkTreeViewColumn *column;
2006           column = GTK_TREE_VIEW_COLUMN (list->data);
2007           list = list->next;
2008           gtk_tree_view_remove_column (tree_view, column);
2009         }
2010       tree_view->priv->columns = NULL;
2011     }
2012
2013   if (tree_view->priv->tree != NULL)
2014     {
2015       gtk_tree_view_unref_and_check_selection_tree (tree_view, tree_view->priv->tree);
2016
2017       gtk_tree_view_free_rbtree (tree_view);
2018     }
2019
2020   if (tree_view->priv->selection != NULL)
2021     {
2022       _gtk_tree_selection_set_tree_view (tree_view->priv->selection, NULL);
2023       g_object_unref (tree_view->priv->selection);
2024       tree_view->priv->selection = NULL;
2025     }
2026
2027   if (tree_view->priv->scroll_to_path != NULL)
2028     {
2029       gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
2030       tree_view->priv->scroll_to_path = NULL;
2031     }
2032
2033   if (tree_view->priv->drag_dest_row != NULL)
2034     {
2035       gtk_tree_row_reference_free (tree_view->priv->drag_dest_row);
2036       tree_view->priv->drag_dest_row = NULL;
2037     }
2038
2039   if (tree_view->priv->top_row != NULL)
2040     {
2041       gtk_tree_row_reference_free (tree_view->priv->top_row);
2042       tree_view->priv->top_row = NULL;
2043     }
2044
2045   if (tree_view->priv->column_drop_func_data &&
2046       tree_view->priv->column_drop_func_data_destroy)
2047     {
2048       tree_view->priv->column_drop_func_data_destroy (tree_view->priv->column_drop_func_data);
2049       tree_view->priv->column_drop_func_data = NULL;
2050     }
2051
2052   if (tree_view->priv->destroy_count_destroy &&
2053       tree_view->priv->destroy_count_data)
2054     {
2055       tree_view->priv->destroy_count_destroy (tree_view->priv->destroy_count_data);
2056       tree_view->priv->destroy_count_data = NULL;
2057     }
2058
2059   gtk_tree_row_reference_free (tree_view->priv->cursor);
2060   tree_view->priv->cursor = NULL;
2061
2062   gtk_tree_row_reference_free (tree_view->priv->anchor);
2063   tree_view->priv->anchor = NULL;
2064
2065   /* destroy interactive search dialog */
2066   if (tree_view->priv->search_window)
2067     {
2068       gtk_widget_destroy (tree_view->priv->search_window);
2069       tree_view->priv->search_window = NULL;
2070       tree_view->priv->search_entry = NULL;
2071       if (tree_view->priv->typeselect_flush_timeout)
2072         {
2073           g_source_remove (tree_view->priv->typeselect_flush_timeout);
2074           tree_view->priv->typeselect_flush_timeout = 0;
2075         }
2076     }
2077
2078   if (tree_view->priv->search_destroy && tree_view->priv->search_user_data)
2079     {
2080       tree_view->priv->search_destroy (tree_view->priv->search_user_data);
2081       tree_view->priv->search_user_data = NULL;
2082     }
2083
2084   if (tree_view->priv->search_position_destroy && tree_view->priv->search_position_user_data)
2085     {
2086       tree_view->priv->search_position_destroy (tree_view->priv->search_position_user_data);
2087       tree_view->priv->search_position_user_data = NULL;
2088     }
2089
2090   if (tree_view->priv->row_separator_destroy && tree_view->priv->row_separator_data)
2091     {
2092       tree_view->priv->row_separator_destroy (tree_view->priv->row_separator_data);
2093       tree_view->priv->row_separator_data = NULL;
2094     }
2095
2096   gtk_tree_view_set_model (tree_view, NULL);
2097
2098   if (tree_view->priv->hadjustment)
2099     {
2100       g_object_unref (tree_view->priv->hadjustment);
2101       tree_view->priv->hadjustment = NULL;
2102     }
2103   if (tree_view->priv->vadjustment)
2104     {
2105       g_object_unref (tree_view->priv->vadjustment);
2106       tree_view->priv->vadjustment = NULL;
2107     }
2108
2109   GTK_WIDGET_CLASS (gtk_tree_view_parent_class)->destroy (widget);
2110 }
2111
2112 /* GtkWidget::map helper */
2113 static void
2114 gtk_tree_view_map_buttons (GtkTreeView *tree_view)
2115 {
2116   GList *list;
2117
2118   g_return_if_fail (gtk_widget_get_mapped (GTK_WIDGET (tree_view)));
2119
2120   if (tree_view->priv->headers_visible)
2121     {
2122       GtkTreeViewColumn *column;
2123       GtkWidget         *button;
2124       GdkWindow         *window;
2125
2126       for (list = tree_view->priv->columns; list; list = list->next)
2127         {
2128           column = list->data;
2129           button = gtk_tree_view_column_get_button (column);
2130
2131           if (gtk_tree_view_column_get_visible (column) && button)
2132             gtk_widget_show_now (button);
2133
2134           if (gtk_widget_get_visible (button) &&
2135               !gtk_widget_get_mapped (button))
2136             gtk_widget_map (button);
2137         }
2138       for (list = tree_view->priv->columns; list; list = list->next)
2139         {
2140           column = list->data;
2141           if (gtk_tree_view_column_get_visible (column) == FALSE)
2142             continue;
2143
2144           window = _gtk_tree_view_column_get_window (column);
2145           if (gtk_tree_view_column_get_resizable (column))
2146             {
2147               gdk_window_raise (window);
2148               gdk_window_show (window);
2149             }
2150           else
2151             gdk_window_hide (window);
2152         }
2153       gdk_window_show (tree_view->priv->header_window);
2154     }
2155 }
2156
2157 static void
2158 gtk_tree_view_map (GtkWidget *widget)
2159 {
2160   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
2161   GList *tmp_list;
2162
2163   gtk_widget_set_mapped (widget, TRUE);
2164
2165   tmp_list = tree_view->priv->children;
2166   while (tmp_list)
2167     {
2168       GtkTreeViewChild *child = tmp_list->data;
2169       tmp_list = tmp_list->next;
2170
2171       if (gtk_widget_get_visible (child->widget))
2172         {
2173           if (!gtk_widget_get_mapped (child->widget))
2174             gtk_widget_map (child->widget);
2175         }
2176     }
2177   gdk_window_show (tree_view->priv->bin_window);
2178
2179   gtk_tree_view_map_buttons (tree_view);
2180
2181   gdk_window_show (gtk_widget_get_window (widget));
2182 }
2183
2184 static void
2185 gtk_tree_view_realize (GtkWidget *widget)
2186 {
2187   GtkAllocation allocation;
2188   GtkStyle *style;
2189   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
2190   GdkWindow *window;
2191   GdkWindowAttr attributes;
2192   GList *tmp_list;
2193   gint attributes_mask;
2194
2195   gtk_widget_set_realized (widget, TRUE);
2196
2197   gtk_widget_get_allocation (widget, &allocation);
2198
2199   /* Make the main, clipping window */
2200   attributes.window_type = GDK_WINDOW_CHILD;
2201   attributes.x = allocation.x;
2202   attributes.y = allocation.y;
2203   attributes.width = allocation.width;
2204   attributes.height = allocation.height;
2205   attributes.wclass = GDK_INPUT_OUTPUT;
2206   attributes.visual = gtk_widget_get_visual (widget);
2207   attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK;
2208
2209   attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
2210
2211   window = gdk_window_new (gtk_widget_get_parent_window (widget),
2212                            &attributes, attributes_mask);
2213   gtk_widget_set_window (widget, window);
2214   gdk_window_set_user_data (window, widget);
2215
2216   gtk_widget_get_allocation (widget, &allocation);
2217
2218   /* Make the window for the tree */
2219   attributes.x = 0;
2220   attributes.y = gtk_tree_view_get_effective_header_height (tree_view);
2221   attributes.width = MAX (tree_view->priv->width, allocation.width);
2222   attributes.height = allocation.height;
2223   attributes.event_mask = (GDK_EXPOSURE_MASK |
2224                            GDK_SCROLL_MASK |
2225                            GDK_POINTER_MOTION_MASK |
2226                            GDK_ENTER_NOTIFY_MASK |
2227                            GDK_LEAVE_NOTIFY_MASK |
2228                            GDK_BUTTON_PRESS_MASK |
2229                            GDK_BUTTON_RELEASE_MASK |
2230                            gtk_widget_get_events (widget));
2231
2232   tree_view->priv->bin_window = gdk_window_new (window,
2233                                                 &attributes, attributes_mask);
2234   gdk_window_set_user_data (tree_view->priv->bin_window, widget);
2235
2236   gtk_widget_get_allocation (widget, &allocation);
2237
2238   /* Make the column header window */
2239   attributes.x = 0;
2240   attributes.y = 0;
2241   attributes.width = MAX (tree_view->priv->width, allocation.width);
2242   attributes.height = tree_view->priv->header_height;
2243   attributes.event_mask = (GDK_EXPOSURE_MASK |
2244                            GDK_SCROLL_MASK |
2245                            GDK_ENTER_NOTIFY_MASK |
2246                            GDK_LEAVE_NOTIFY_MASK |
2247                            GDK_BUTTON_PRESS_MASK |
2248                            GDK_BUTTON_RELEASE_MASK |
2249                            GDK_KEY_PRESS_MASK |
2250                            GDK_KEY_RELEASE_MASK |
2251                            gtk_widget_get_events (widget));
2252
2253   tree_view->priv->header_window = gdk_window_new (window,
2254                                                    &attributes, attributes_mask);
2255   gdk_window_set_user_data (tree_view->priv->header_window, widget);
2256
2257   /* Add them all up. */
2258   gtk_widget_style_attach (widget);
2259   style = gtk_widget_get_style (widget);
2260   gdk_window_set_background (tree_view->priv->bin_window,
2261                              &style->base[gtk_widget_get_state (widget)]);
2262   gtk_style_set_background (style, tree_view->priv->header_window, GTK_STATE_NORMAL);
2263
2264   tmp_list = tree_view->priv->children;
2265   while (tmp_list)
2266     {
2267       GtkTreeViewChild *child = tmp_list->data;
2268       tmp_list = tmp_list->next;
2269
2270       gtk_widget_set_parent_window (child->widget, tree_view->priv->bin_window);
2271     }
2272
2273   for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list = tmp_list->next)
2274     _gtk_tree_view_column_realize_button (GTK_TREE_VIEW_COLUMN (tmp_list->data));
2275
2276   /* Need to call those here, since they create GCs */
2277   gtk_tree_view_set_grid_lines (tree_view, tree_view->priv->grid_lines);
2278   gtk_tree_view_set_enable_tree_lines (tree_view, tree_view->priv->tree_lines_enabled);
2279
2280   install_presize_handler (tree_view);
2281 }
2282
2283 static void
2284 gtk_tree_view_unrealize (GtkWidget *widget)
2285 {
2286   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
2287   GtkTreeViewPrivate *priv = tree_view->priv;
2288   GList *list;
2289
2290   if (priv->scroll_timeout != 0)
2291     {
2292       g_source_remove (priv->scroll_timeout);
2293       priv->scroll_timeout = 0;
2294     }
2295
2296   if (priv->auto_expand_timeout != 0)
2297     {
2298       g_source_remove (priv->auto_expand_timeout);
2299       priv->auto_expand_timeout = 0;
2300     }
2301
2302   if (priv->open_dest_timeout != 0)
2303     {
2304       g_source_remove (priv->open_dest_timeout);
2305       priv->open_dest_timeout = 0;
2306     }
2307
2308   remove_expand_collapse_timeout (tree_view);
2309
2310   if (priv->presize_handler_timer != 0)
2311     {
2312       g_source_remove (priv->presize_handler_timer);
2313       priv->presize_handler_timer = 0;
2314     }
2315
2316   if (priv->validate_rows_timer != 0)
2317     {
2318       g_source_remove (priv->validate_rows_timer);
2319       priv->validate_rows_timer = 0;
2320     }
2321
2322   if (priv->scroll_sync_timer != 0)
2323     {
2324       g_source_remove (priv->scroll_sync_timer);
2325       priv->scroll_sync_timer = 0;
2326     }
2327
2328   if (priv->typeselect_flush_timeout)
2329     {
2330       g_source_remove (priv->typeselect_flush_timeout);
2331       priv->typeselect_flush_timeout = 0;
2332     }
2333
2334   for (list = priv->columns; list; list = list->next)
2335     _gtk_tree_view_column_unrealize_button (GTK_TREE_VIEW_COLUMN (list->data));
2336
2337   gdk_window_set_user_data (priv->bin_window, NULL);
2338   gdk_window_destroy (priv->bin_window);
2339   priv->bin_window = NULL;
2340
2341   gdk_window_set_user_data (priv->header_window, NULL);
2342   gdk_window_destroy (priv->header_window);
2343   priv->header_window = NULL;
2344
2345   if (priv->drag_window)
2346     {
2347       gdk_window_set_user_data (priv->drag_window, NULL);
2348       gdk_window_destroy (priv->drag_window);
2349       priv->drag_window = NULL;
2350     }
2351
2352   if (priv->drag_highlight_window)
2353     {
2354       gdk_window_set_user_data (priv->drag_highlight_window, NULL);
2355       gdk_window_destroy (priv->drag_highlight_window);
2356       priv->drag_highlight_window = NULL;
2357     }
2358
2359   GTK_WIDGET_CLASS (gtk_tree_view_parent_class)->unrealize (widget);
2360 }
2361
2362 /* GtkWidget::size_request helper */
2363 static void
2364 gtk_tree_view_size_request_columns (GtkTreeView *tree_view)
2365 {
2366   GList *list;
2367
2368   tree_view->priv->header_height = 0;
2369
2370   if (tree_view->priv->model)
2371     {
2372       for (list = tree_view->priv->columns; list; list = list->next)
2373         {
2374           GtkRequisition     requisition;
2375           GtkTreeViewColumn *column = list->data;
2376           GtkWidget         *button = gtk_tree_view_column_get_button (column);
2377
2378           if (button == NULL)
2379             continue;
2380
2381           column = list->data;
2382
2383           gtk_widget_get_preferred_size (button, &requisition, NULL);
2384           tree_view->priv->header_height = MAX (tree_view->priv->header_height, requisition.height);
2385         }
2386     }
2387 }
2388
2389
2390 /* Called only by ::size_request */
2391 static void
2392 gtk_tree_view_update_size (GtkTreeView *tree_view)
2393 {
2394   GList *list;
2395   GtkTreeViewColumn *column;
2396   gint i;
2397
2398   if (tree_view->priv->model == NULL)
2399     {
2400       tree_view->priv->width = 0;
2401       tree_view->priv->prev_width = 0;
2402       tree_view->priv->height = 0;
2403       return;
2404     }
2405
2406   tree_view->priv->prev_width = tree_view->priv->width;
2407   tree_view->priv->width = 0;
2408
2409   /* keep this in sync with size_allocate below */
2410   for (list = tree_view->priv->columns, i = 0; list; list = list->next, i++)
2411     {
2412       column = list->data;
2413       if (!gtk_tree_view_column_get_visible (column))
2414         continue;
2415
2416       tree_view->priv->width += _gtk_tree_view_column_request_width (column);
2417     }
2418
2419   if (tree_view->priv->tree == NULL)
2420     tree_view->priv->height = 0;
2421   else
2422     tree_view->priv->height = tree_view->priv->tree->root->offset;
2423 }
2424
2425 static void
2426 gtk_tree_view_size_request (GtkWidget      *widget,
2427                             GtkRequisition *requisition,
2428                             gboolean        may_validate)
2429 {
2430   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
2431   GList *tmp_list;
2432
2433   if (may_validate)
2434     {
2435       /* we validate some rows initially just to make sure we have some size.
2436        * In practice, with a lot of static lists, this should get a good width.
2437        */
2438       do_validate_rows (tree_view, FALSE);
2439     }
2440
2441   gtk_tree_view_size_request_columns (tree_view);
2442   gtk_tree_view_update_size (GTK_TREE_VIEW (widget));
2443
2444   requisition->width = tree_view->priv->width;
2445   requisition->height = tree_view->priv->height + gtk_tree_view_get_effective_header_height (tree_view);
2446
2447   tmp_list = tree_view->priv->children;
2448 }
2449
2450 static void
2451 gtk_tree_view_get_preferred_width (GtkWidget *widget,
2452                                    gint      *minimum,
2453                                    gint      *natural)
2454 {
2455   GtkRequisition requisition;
2456
2457   gtk_tree_view_size_request (widget, &requisition, TRUE);
2458
2459   *minimum = *natural = requisition.width;
2460 }
2461
2462 static void
2463 gtk_tree_view_get_preferred_height (GtkWidget *widget,
2464                                     gint      *minimum,
2465                                     gint      *natural)
2466 {
2467   GtkRequisition requisition;
2468
2469   gtk_tree_view_size_request (widget, &requisition, TRUE);
2470
2471   *minimum = *natural = requisition.height;
2472 }
2473
2474 static int
2475 gtk_tree_view_calculate_width_before_expander (GtkTreeView *tree_view)
2476 {
2477   int width = 0;
2478   GList *list;
2479   gboolean rtl;
2480
2481   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
2482   for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
2483        list->data != tree_view->priv->expander_column;
2484        list = (rtl ? list->prev : list->next))
2485     {
2486       GtkTreeViewColumn *column = list->data;
2487
2488       width += gtk_tree_view_column_get_width (column);
2489     }
2490
2491   return width;
2492 }
2493
2494 static void
2495 invalidate_column (GtkTreeView       *tree_view,
2496                    GtkTreeViewColumn *column)
2497 {
2498   gint column_offset = 0;
2499   GList *list;
2500   GtkWidget *widget = GTK_WIDGET (tree_view);
2501   gboolean rtl;
2502
2503   if (!gtk_widget_get_realized (widget))
2504     return;
2505
2506   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
2507   for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
2508        list;
2509        list = (rtl ? list->prev : list->next))
2510     {
2511       GtkTreeViewColumn *tmpcolumn = list->data;
2512       if (tmpcolumn == column)
2513         {
2514           GtkAllocation allocation;
2515           GdkRectangle invalid_rect;
2516
2517           gtk_widget_get_allocation (widget, &allocation);
2518           invalid_rect.x = column_offset;
2519           invalid_rect.y = 0;
2520           invalid_rect.width = gtk_tree_view_column_get_width (column);
2521           invalid_rect.height = allocation.height;
2522
2523           gdk_window_invalidate_rect (gtk_widget_get_window (widget), &invalid_rect, TRUE);
2524           break;
2525         }
2526
2527       column_offset += gtk_tree_view_column_get_width (tmpcolumn);
2528     }
2529 }
2530
2531 static void
2532 invalidate_last_column (GtkTreeView *tree_view)
2533 {
2534   GList *last_column;
2535   gboolean rtl;
2536
2537   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
2538
2539   for (last_column = (rtl ? g_list_first (tree_view->priv->columns) : g_list_last (tree_view->priv->columns));
2540        last_column;
2541        last_column = (rtl ? last_column->next : last_column->prev))
2542     {
2543       if (gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (last_column->data)))
2544         {
2545           invalidate_column (tree_view, last_column->data);
2546           return;
2547         }
2548     }
2549 }
2550
2551 /* GtkWidget::size_allocate helper */
2552 static void
2553 gtk_tree_view_size_allocate_columns (GtkWidget *widget,
2554                                      gboolean  *width_changed)
2555 {
2556   GtkTreeView *tree_view;
2557   GList *list, *first_column, *last_column;
2558   GtkTreeViewColumn *column;
2559   GtkAllocation widget_allocation;
2560   gint width = 0;
2561   gint extra, extra_per_column, extra_for_last;
2562   gint full_requested_width = 0;
2563   gint number_of_expand_columns = 0;
2564   gboolean column_changed = FALSE;
2565   gboolean rtl;
2566   gboolean update_expand;
2567
2568   tree_view = GTK_TREE_VIEW (widget);
2569
2570   for (last_column = g_list_last (tree_view->priv->columns);
2571        last_column &&
2572        !(gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (last_column->data)));
2573        last_column = last_column->prev)
2574     ;
2575   if (last_column == NULL)
2576     return;
2577
2578   for (first_column = g_list_first (tree_view->priv->columns);
2579        first_column &&
2580        !(gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (first_column->data)));
2581        first_column = first_column->next)
2582     ;
2583
2584   rtl = (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL);
2585
2586   /* find out how many extra space and expandable columns we have */
2587   for (list = tree_view->priv->columns; list != last_column->next; list = list->next)
2588     {
2589       column = (GtkTreeViewColumn *)list->data;
2590
2591       if (!gtk_tree_view_column_get_visible (column))
2592         continue;
2593
2594       full_requested_width += _gtk_tree_view_column_request_width (column);
2595
2596       if (gtk_tree_view_column_get_expand (column))
2597         number_of_expand_columns++;
2598     }
2599
2600   /* Only update the expand value if the width of the widget has changed,
2601    * or the number of expand columns has changed, or if there are no expand
2602    * columns, or if we didn't have an size-allocation yet after the
2603    * last validated node.
2604    */
2605   update_expand = (width_changed && *width_changed == TRUE)
2606       || number_of_expand_columns != tree_view->priv->last_number_of_expand_columns
2607       || number_of_expand_columns == 0
2608       || tree_view->priv->post_validation_flag == TRUE;
2609
2610   tree_view->priv->post_validation_flag = FALSE;
2611
2612   gtk_widget_get_allocation (widget, &widget_allocation);
2613   if (!update_expand)
2614     {
2615       extra = tree_view->priv->last_extra_space;
2616       extra_for_last = MAX (widget_allocation.width - full_requested_width - extra, 0);
2617     }
2618   else
2619     {
2620       extra = MAX (widget_allocation.width - full_requested_width, 0);
2621       extra_for_last = 0;
2622
2623       tree_view->priv->last_extra_space = extra;
2624     }
2625
2626   if (number_of_expand_columns > 0)
2627     extra_per_column = extra/number_of_expand_columns;
2628   else
2629     extra_per_column = 0;
2630
2631   if (update_expand)
2632     {
2633       tree_view->priv->last_extra_space_per_column = extra_per_column;
2634       tree_view->priv->last_number_of_expand_columns = number_of_expand_columns;
2635     }
2636
2637   for (list = (rtl ? last_column : first_column);
2638        list != (rtl ? first_column->prev : last_column->next);
2639        list = (rtl ? list->prev : list->next))
2640     {
2641       gint old_width, column_width;
2642
2643       column = list->data;
2644       old_width = gtk_tree_view_column_get_width (column);
2645
2646       if (!gtk_tree_view_column_get_visible (column))
2647         continue;
2648
2649       /* We need to handle the dragged button specially.
2650        */
2651       if (column == tree_view->priv->drag_column)
2652         {
2653           GtkAllocation drag_allocation;
2654           GtkWidget    *button;
2655
2656           button = gtk_tree_view_column_get_button (tree_view->priv->drag_column);
2657
2658           drag_allocation.x = 0;
2659           drag_allocation.y = 0;
2660           drag_allocation.width = gdk_window_get_width (tree_view->priv->drag_window);
2661           drag_allocation.height = gdk_window_get_height (tree_view->priv->drag_window);
2662           gtk_widget_size_allocate (button, &drag_allocation);
2663           width += drag_allocation.width;
2664           continue;
2665         }
2666
2667       column_width = _gtk_tree_view_column_request_width (column);
2668
2669       if (gtk_tree_view_column_get_expand (column))
2670         {
2671           if (number_of_expand_columns == 1)
2672             {
2673               /* We add the remander to the last column as
2674                * */
2675               column_width += extra;
2676             }
2677           else
2678             {
2679               column_width += extra_per_column;
2680               extra -= extra_per_column;
2681               number_of_expand_columns --;
2682             }
2683         }
2684       else if (number_of_expand_columns == 0 &&
2685                list == last_column)
2686         {
2687           column_width += extra;
2688         }
2689
2690       /* In addition to expand, the last column can get even more
2691        * extra space so all available space is filled up.
2692        */
2693       if (extra_for_last > 0 && list == last_column)
2694         column_width += extra_for_last;
2695
2696       _gtk_tree_view_column_allocate (column, width, column_width);
2697
2698       width += column_width;
2699
2700       if (column_width > old_width)
2701         column_changed = TRUE;
2702     }
2703
2704   /* We change the width here.  The user might have been resizing columns,
2705    * so the total width of the tree view changes.
2706    */
2707   tree_view->priv->width = width;
2708   if (width_changed)
2709     *width_changed = TRUE;
2710
2711   if (column_changed)
2712     gtk_widget_queue_draw (GTK_WIDGET (tree_view));
2713 }
2714
2715
2716 static void
2717 gtk_tree_view_size_allocate (GtkWidget     *widget,
2718                              GtkAllocation *allocation)
2719 {
2720   GtkAllocation widget_allocation;
2721   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
2722   GList *tmp_list;
2723   gboolean width_changed = FALSE;
2724   gint old_width;
2725
2726   gtk_widget_get_allocation (widget, &widget_allocation);
2727   old_width = widget_allocation.width;
2728   if (allocation->width != widget_allocation.width)
2729     width_changed = TRUE;
2730
2731   gtk_widget_set_allocation (widget, allocation);
2732
2733   tmp_list = tree_view->priv->children;
2734
2735   while (tmp_list)
2736     {
2737       GtkAllocation allocation;
2738
2739       GtkTreeViewChild *child = tmp_list->data;
2740       tmp_list = tmp_list->next;
2741
2742       /* totally ignore our child's requisition */
2743       allocation.x = child->x;
2744       allocation.y = child->y;
2745       allocation.width = child->width;
2746       allocation.height = child->height;
2747       gtk_widget_size_allocate (child->widget, &allocation);
2748     }
2749
2750   /* We size-allocate the columns first because the width of the
2751    * tree view (used in updating the adjustments below) might change.
2752    */
2753   gtk_tree_view_size_allocate_columns (widget, &width_changed);
2754
2755   g_object_freeze_notify (G_OBJECT (tree_view->priv->hadjustment));
2756   gtk_adjustment_set_page_size (tree_view->priv->hadjustment,
2757                                 allocation->width);
2758   gtk_adjustment_set_page_increment (tree_view->priv->hadjustment,
2759                                      allocation->width * 0.9);
2760   gtk_adjustment_set_step_increment (tree_view->priv->hadjustment,
2761                                      allocation->width * 0.1);
2762   gtk_adjustment_set_lower (tree_view->priv->hadjustment, 0);
2763   gtk_adjustment_set_upper (tree_view->priv->hadjustment,
2764                             MAX (tree_view->priv->hadjustment->page_size,
2765                                  tree_view->priv->width));
2766   g_object_thaw_notify (G_OBJECT (tree_view->priv->hadjustment));
2767
2768   if (gtk_widget_get_direction(widget) == GTK_TEXT_DIR_RTL)
2769     {
2770       if (allocation->width < tree_view->priv->width)
2771         {
2772           if (tree_view->priv->init_hadjust_value)
2773             {
2774               gtk_adjustment_set_value (tree_view->priv->hadjustment,
2775                                         MAX (tree_view->priv->width -
2776                                              allocation->width, 0));
2777               tree_view->priv->init_hadjust_value = FALSE;
2778             }
2779           else if (allocation->width != old_width)
2780             {
2781               gtk_adjustment_set_value (tree_view->priv->hadjustment,
2782                                         CLAMP (tree_view->priv->hadjustment->value - allocation->width + old_width,
2783                                                0,
2784                                                tree_view->priv->width - allocation->width));
2785             }
2786           else
2787             gtk_adjustment_set_value (tree_view->priv->hadjustment,
2788                                       CLAMP (tree_view->priv->width - (tree_view->priv->prev_width - tree_view->priv->hadjustment->value),
2789                                              0,
2790                                              tree_view->priv->width - allocation->width));
2791         }
2792       else
2793         {
2794           gtk_adjustment_set_value (tree_view->priv->hadjustment, 0);
2795           tree_view->priv->init_hadjust_value = TRUE;
2796         }
2797     }
2798   else
2799     if (tree_view->priv->hadjustment->value + allocation->width > tree_view->priv->width)
2800       gtk_adjustment_set_value (tree_view->priv->hadjustment,
2801                                 MAX (tree_view->priv->width -
2802                                      allocation->width, 0));
2803
2804   g_object_freeze_notify (G_OBJECT (tree_view->priv->vadjustment));
2805   gtk_adjustment_set_page_size (tree_view->priv->vadjustment,
2806                                 allocation->height -
2807                                 gtk_tree_view_get_effective_header_height (tree_view));
2808   gtk_adjustment_set_step_increment (tree_view->priv->vadjustment,
2809                                      tree_view->priv->vadjustment->page_size * 0.1);
2810   gtk_adjustment_set_page_increment (tree_view->priv->vadjustment,
2811                                      tree_view->priv->vadjustment->page_size * 0.9);
2812   gtk_adjustment_set_lower (tree_view->priv->vadjustment, 0);
2813   gtk_adjustment_set_upper (tree_view->priv->vadjustment,
2814                             MAX (tree_view->priv->vadjustment->page_size,
2815                                  tree_view->priv->height));
2816   g_object_thaw_notify (G_OBJECT (tree_view->priv->vadjustment));
2817
2818   /* now the adjustments and window sizes are in sync, we can sync toprow/dy again */
2819   if (tree_view->priv->height <= tree_view->priv->vadjustment->page_size)
2820     gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment), 0);
2821   else if (tree_view->priv->vadjustment->value + tree_view->priv->vadjustment->page_size > tree_view->priv->height)
2822     gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment),
2823                               tree_view->priv->height - tree_view->priv->vadjustment->page_size);
2824   else if (gtk_tree_row_reference_valid (tree_view->priv->top_row))
2825     gtk_tree_view_top_row_to_dy (tree_view);
2826   else
2827     gtk_tree_view_dy_to_top_row (tree_view);
2828
2829   if (gtk_widget_get_realized (widget))
2830     {
2831       gdk_window_move_resize (gtk_widget_get_window (widget),
2832                               allocation->x, allocation->y,
2833                               allocation->width, allocation->height);
2834       gdk_window_move_resize (tree_view->priv->header_window,
2835                               - (gint) tree_view->priv->hadjustment->value,
2836                               0,
2837                               MAX (tree_view->priv->width, allocation->width),
2838                               tree_view->priv->header_height);
2839       gdk_window_move_resize (tree_view->priv->bin_window,
2840                               - (gint) tree_view->priv->hadjustment->value,
2841                               gtk_tree_view_get_effective_header_height (tree_view),
2842                               MAX (tree_view->priv->width, allocation->width),
2843                               allocation->height - gtk_tree_view_get_effective_header_height (tree_view));
2844     }
2845
2846   if (tree_view->priv->tree == NULL)
2847     invalidate_empty_focus (tree_view);
2848
2849   if (gtk_widget_get_realized (widget))
2850     {
2851       gboolean has_expand_column = FALSE;
2852       for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list = tmp_list->next)
2853         {
2854           if (gtk_tree_view_column_get_expand (GTK_TREE_VIEW_COLUMN (tmp_list->data)))
2855             {
2856               has_expand_column = TRUE;
2857               break;
2858             }
2859         }
2860
2861       if (width_changed && tree_view->priv->expander_column)
2862         {
2863           /* Might seem awkward, but is the best heuristic I could come up
2864            * with.  Only if the width of the columns before the expander
2865            * changes, we will update the prelight status.  It is this
2866            * width that makes the expander move vertically.  Always updating
2867            * prelight status causes trouble with hover selections.
2868            */
2869           gint width_before_expander;
2870
2871           width_before_expander = gtk_tree_view_calculate_width_before_expander (tree_view);
2872
2873           if (tree_view->priv->prev_width_before_expander
2874               != width_before_expander)
2875               update_prelight (tree_view,
2876                                tree_view->priv->event_last_x,
2877                                tree_view->priv->event_last_y);
2878
2879           tree_view->priv->prev_width_before_expander = width_before_expander;
2880         }
2881
2882       /* This little hack only works if we have an LTR locale, and no column has the  */
2883       if (width_changed)
2884         {
2885           if (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_LTR &&
2886               ! has_expand_column)
2887             invalidate_last_column (tree_view);
2888           else
2889             gtk_widget_queue_draw (widget);
2890         }
2891     }
2892 }
2893
2894 /* Grabs the focus and unsets the GTK_TREE_VIEW_DRAW_KEYFOCUS flag */
2895 static void
2896 grab_focus_and_unset_draw_keyfocus (GtkTreeView *tree_view)
2897 {
2898   GtkWidget *widget = GTK_WIDGET (tree_view);
2899
2900   if (gtk_widget_get_can_focus (widget) && !gtk_widget_has_focus (widget))
2901     gtk_widget_grab_focus (widget);
2902   tree_view->priv->draw_keyfocus = 0;
2903 }
2904
2905 static inline gboolean
2906 row_is_separator (GtkTreeView *tree_view,
2907                   GtkTreeIter *iter,
2908                   GtkTreePath *path)
2909 {
2910   gboolean is_separator = FALSE;
2911
2912   if (tree_view->priv->row_separator_func)
2913     {
2914       GtkTreeIter tmpiter;
2915
2916       if (iter)
2917         tmpiter = *iter;
2918       else
2919         gtk_tree_model_get_iter (tree_view->priv->model, &tmpiter, path);
2920
2921       is_separator = tree_view->priv->row_separator_func (tree_view->priv->model,
2922                                                           &tmpiter,
2923                                                           tree_view->priv->row_separator_data);
2924     }
2925
2926   return is_separator;
2927 }
2928
2929 static gboolean
2930 gtk_tree_view_button_press (GtkWidget      *widget,
2931                             GdkEventButton *event)
2932 {
2933   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
2934   GList *list;
2935   GtkTreeViewColumn *column = NULL;
2936   gint i;
2937   GdkRectangle background_area;
2938   GdkRectangle cell_area;
2939   gint vertical_separator;
2940   gint horizontal_separator;
2941   gboolean path_is_selectable;
2942   gboolean rtl;
2943
2944   rtl = (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL);
2945   gtk_tree_view_stop_editing (tree_view, FALSE);
2946   gtk_widget_style_get (widget,
2947                         "vertical-separator", &vertical_separator,
2948                         "horizontal-separator", &horizontal_separator,
2949                         NULL);
2950
2951
2952   /* Because grab_focus can cause reentrancy, we delay grab_focus until after
2953    * we're done handling the button press.
2954    */
2955
2956   if (event->window == tree_view->priv->bin_window)
2957     {
2958       GtkRBNode *node;
2959       GtkRBTree *tree;
2960       GtkTreePath *path;
2961       gint depth;
2962       gint new_y;
2963       gint y_offset;
2964       gint dval;
2965       gint pre_val, aft_val;
2966       GtkTreeViewColumn *column = NULL;
2967       gint column_handled_click = FALSE;
2968       gboolean row_double_click = FALSE;
2969       gboolean rtl;
2970       gboolean node_selected;
2971
2972       /* Empty tree? */
2973       if (tree_view->priv->tree == NULL)
2974         {
2975           grab_focus_and_unset_draw_keyfocus (tree_view);
2976           return TRUE;
2977         }
2978
2979       /* are we in an arrow? */
2980       if (tree_view->priv->prelight_node &&
2981           tree_view->priv->arrow_prelit &&
2982           gtk_tree_view_draw_expanders (tree_view))
2983         {
2984           if (event->button == 1)
2985             {
2986               gtk_grab_add (widget);
2987               tree_view->priv->button_pressed_node = tree_view->priv->prelight_node;
2988               tree_view->priv->button_pressed_tree = tree_view->priv->prelight_tree;
2989               gtk_tree_view_queue_draw_arrow (GTK_TREE_VIEW (widget),
2990                                               tree_view->priv->prelight_tree,
2991                                               tree_view->priv->prelight_node);
2992             }
2993
2994           grab_focus_and_unset_draw_keyfocus (tree_view);
2995           return TRUE;
2996         }
2997
2998       /* find the node that was clicked */
2999       new_y = TREE_WINDOW_Y_TO_RBTREE_Y(tree_view, event->y);
3000       if (new_y < 0)
3001         new_y = 0;
3002       y_offset = -_gtk_rbtree_find_offset (tree_view->priv->tree, new_y, &tree, &node);
3003
3004       if (node == NULL)
3005         {
3006           /* We clicked in dead space */
3007           grab_focus_and_unset_draw_keyfocus (tree_view);
3008           return TRUE;
3009         }
3010
3011       /* Get the path and the node */
3012       path = _gtk_tree_view_find_path (tree_view, tree, node);
3013       path_is_selectable = !row_is_separator (tree_view, NULL, path);
3014
3015       if (!path_is_selectable)
3016         {
3017           gtk_tree_path_free (path);
3018           grab_focus_and_unset_draw_keyfocus (tree_view);
3019           return TRUE;
3020         }
3021
3022       depth = gtk_tree_path_get_depth (path);
3023       background_area.y = y_offset + event->y;
3024       background_area.height = gtk_tree_view_get_row_height (tree_view, node);
3025       background_area.x = 0;
3026
3027
3028       /* Let the column have a chance at selecting it. */
3029       rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
3030       for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
3031            list; list = (rtl ? list->prev : list->next))
3032         {
3033           GtkTreeViewColumn *candidate = list->data;
3034
3035           if (!gtk_tree_view_column_get_visible (candidate))
3036             continue;
3037
3038           background_area.width = gtk_tree_view_column_get_width (candidate);
3039           if ((background_area.x > (gint) event->x) ||
3040               (background_area.x + background_area.width <= (gint) event->x))
3041             {
3042               background_area.x += background_area.width;
3043               continue;
3044             }
3045
3046           /* we found the focus column */
3047           column = candidate;
3048           cell_area = background_area;
3049           cell_area.width -= horizontal_separator;
3050           cell_area.height -= vertical_separator;
3051           cell_area.x += horizontal_separator/2;
3052           cell_area.y += vertical_separator/2;
3053           if (gtk_tree_view_is_expander_column (tree_view, column))
3054             {
3055               if (!rtl)
3056                 cell_area.x += (depth - 1) * tree_view->priv->level_indentation;
3057               cell_area.width -= (depth - 1) * tree_view->priv->level_indentation;
3058
3059               if (gtk_tree_view_draw_expanders (tree_view))
3060                 {
3061                   if (!rtl)
3062                     cell_area.x += depth * tree_view->priv->expander_size;
3063                   cell_area.width -= depth * tree_view->priv->expander_size;
3064                 }
3065             }
3066           break;
3067         }
3068
3069       if (column == NULL)
3070         {
3071           gtk_tree_path_free (path);
3072           grab_focus_and_unset_draw_keyfocus (tree_view);
3073           return FALSE;
3074         }
3075
3076       tree_view->priv->focus_column = column;
3077
3078       /* decide if we edit */
3079       if (event->type == GDK_BUTTON_PRESS && event->button == 1 &&
3080           !(event->state & gtk_accelerator_get_default_mod_mask ()))
3081         {
3082           GtkTreePath *anchor;
3083           GtkTreeIter iter;
3084
3085           gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
3086           gtk_tree_view_column_cell_set_cell_data (column,
3087                                                    tree_view->priv->model,
3088                                                    &iter,
3089                                                    GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT),
3090                                                    node->children?TRUE:FALSE);
3091
3092           if (tree_view->priv->anchor)
3093             anchor = gtk_tree_row_reference_get_path (tree_view->priv->anchor);
3094           else
3095             anchor = NULL;
3096
3097           if ((anchor && !gtk_tree_path_compare (anchor, path))
3098               || !_gtk_tree_view_column_has_editable_cell (column))
3099             {
3100               GtkCellEditable *cell_editable = NULL;
3101
3102               /* FIXME: get the right flags */
3103               guint flags = 0;
3104
3105               if (_gtk_tree_view_column_cell_event (column,
3106                                                     (GdkEvent *)event,
3107                                                     &cell_area, flags))
3108                 {
3109                   GtkCellArea *area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (column));
3110                   cell_editable = gtk_cell_area_get_edit_widget (area);
3111
3112                   if (cell_editable != NULL)
3113                     {
3114                       gtk_tree_path_free (path);
3115                       gtk_tree_path_free (anchor);
3116                       return TRUE;
3117                     }
3118                   column_handled_click = TRUE;
3119                 }
3120             }
3121           if (anchor)
3122             gtk_tree_path_free (anchor);
3123         }
3124
3125       /* select */
3126       node_selected = GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED);
3127       pre_val = tree_view->priv->vadjustment->value;
3128
3129       /* we only handle selection modifications on the first button press
3130        */
3131       if (event->type == GDK_BUTTON_PRESS)
3132         {
3133           GtkCellRenderer *focus_cell;
3134
3135           if ((event->state & GDK_CONTROL_MASK) == GDK_CONTROL_MASK)
3136             tree_view->priv->ctrl_pressed = TRUE;
3137           if ((event->state & GDK_SHIFT_MASK) == GDK_SHIFT_MASK)
3138             tree_view->priv->shift_pressed = TRUE;
3139
3140           /* We update the focus cell here, this is also needed if the
3141            * column does not contain an editable cell.  In this case,
3142            * GtkCellArea did not receive the event for processing (and
3143            * could not update the focus cell).
3144            */
3145           focus_cell = _gtk_tree_view_column_get_cell_at_pos (column,
3146                                                               &cell_area,
3147                                                               &background_area,
3148                                                               event->x,
3149                                                               event->y);
3150
3151           if (focus_cell)
3152             gtk_tree_view_column_focus_cell (column, focus_cell);
3153
3154           if (event->state & GDK_CONTROL_MASK)
3155             {
3156               gtk_tree_view_real_set_cursor (tree_view, path, FALSE, TRUE);
3157               gtk_tree_view_real_toggle_cursor_row (tree_view);
3158             }
3159           else if (event->state & GDK_SHIFT_MASK)
3160             {
3161               gtk_tree_view_real_set_cursor (tree_view, path, FALSE, TRUE);
3162               gtk_tree_view_real_select_cursor_row (tree_view, FALSE);
3163             }
3164           else
3165             {
3166               gtk_tree_view_real_set_cursor (tree_view, path, TRUE, TRUE);
3167             }
3168
3169           tree_view->priv->ctrl_pressed = FALSE;
3170           tree_view->priv->shift_pressed = FALSE;
3171         }
3172
3173       /* the treeview may have been scrolled because of _set_cursor,
3174        * correct here
3175        */
3176
3177       aft_val = tree_view->priv->vadjustment->value;
3178       dval = pre_val - aft_val;
3179
3180       cell_area.y += dval;
3181       background_area.y += dval;
3182
3183       /* Save press to possibly begin a drag
3184        */
3185       if (!column_handled_click &&
3186           !tree_view->priv->in_grab &&
3187           tree_view->priv->pressed_button < 0)
3188         {
3189           tree_view->priv->pressed_button = event->button;
3190           tree_view->priv->press_start_x = event->x;
3191           tree_view->priv->press_start_y = event->y;
3192
3193           if (tree_view->priv->rubber_banding_enable
3194               && !node_selected
3195               && gtk_tree_selection_get_mode (tree_view->priv->selection) == GTK_SELECTION_MULTIPLE)
3196             {
3197               tree_view->priv->press_start_y += tree_view->priv->dy;
3198               tree_view->priv->rubber_band_x = event->x;
3199               tree_view->priv->rubber_band_y = event->y + tree_view->priv->dy;
3200               tree_view->priv->rubber_band_status = RUBBER_BAND_MAYBE_START;
3201
3202               if ((event->state & GDK_CONTROL_MASK) == GDK_CONTROL_MASK)
3203                 tree_view->priv->rubber_band_ctrl = TRUE;
3204               if ((event->state & GDK_SHIFT_MASK) == GDK_SHIFT_MASK)
3205                 tree_view->priv->rubber_band_shift = TRUE;
3206             }
3207         }
3208
3209       /* Test if a double click happened on the same row. */
3210       if (event->button == 1 && event->type == GDK_BUTTON_PRESS)
3211         {
3212           int double_click_time, double_click_distance;
3213
3214           g_object_get (gtk_settings_get_default (),
3215                         "gtk-double-click-time", &double_click_time,
3216                         "gtk-double-click-distance", &double_click_distance,
3217                         NULL);
3218
3219           /* Same conditions as _gdk_event_button_generate */
3220           if (tree_view->priv->last_button_x != -1 &&
3221               (event->time < tree_view->priv->last_button_time + double_click_time) &&
3222               (ABS (event->x - tree_view->priv->last_button_x) <= double_click_distance) &&
3223               (ABS (event->y - tree_view->priv->last_button_y) <= double_click_distance))
3224             {
3225               /* We do no longer compare paths of this row and the
3226                * row clicked previously.  We use the double click
3227                * distance to decide whether this is a valid click,
3228                * allowing the mouse to slightly move over another row.
3229                */
3230               row_double_click = TRUE;
3231
3232               tree_view->priv->last_button_time = 0;
3233               tree_view->priv->last_button_x = -1;
3234               tree_view->priv->last_button_y = -1;
3235             }
3236           else
3237             {
3238               tree_view->priv->last_button_time = event->time;
3239               tree_view->priv->last_button_x = event->x;
3240               tree_view->priv->last_button_y = event->y;
3241             }
3242         }
3243
3244       if (row_double_click)
3245         {
3246           gtk_grab_remove (widget);
3247           gtk_tree_view_row_activated (tree_view, path, column);
3248
3249           if (tree_view->priv->pressed_button == event->button)
3250             tree_view->priv->pressed_button = -1;
3251         }
3252
3253       gtk_tree_path_free (path);
3254
3255       /* If we activated the row through a double click we don't want to grab
3256        * focus back, as moving focus to another widget is pretty common.
3257        */
3258       if (!row_double_click)
3259         grab_focus_and_unset_draw_keyfocus (tree_view);
3260
3261       return TRUE;
3262     }
3263
3264   /* We didn't click in the window.  Let's check to see if we clicked on a column resize window.
3265    */
3266   for (i = 0, list = tree_view->priv->columns; list; list = list->next, i++)
3267     {
3268       column = list->data;
3269       if (event->window == _gtk_tree_view_column_get_window (column) &&
3270           gtk_tree_view_column_get_resizable (column) &&
3271           _gtk_tree_view_column_get_window (column))
3272         {
3273           GtkWidget *button;
3274           GtkAllocation button_allocation;
3275           gpointer drag_data;
3276
3277           if (event->type == GDK_2BUTTON_PRESS &&
3278               gtk_tree_view_column_get_sizing (column) != GTK_TREE_VIEW_COLUMN_AUTOSIZE)
3279             {
3280               _gtk_tree_view_column_set_use_resized_width (column, FALSE);
3281               _gtk_tree_view_column_autosize (tree_view, column);
3282               return TRUE;
3283             }
3284
3285           if (gdk_device_grab (gdk_event_get_device ((GdkEvent*)event),
3286                                _gtk_tree_view_column_get_window (column),
3287                                GDK_OWNERSHIP_NONE,
3288                                FALSE,
3289                                GDK_POINTER_MOTION_HINT_MASK
3290                                 | GDK_BUTTON1_MOTION_MASK
3291                                 | GDK_BUTTON_RELEASE_MASK,
3292                                NULL,
3293                                event->time) != GDK_GRAB_SUCCESS)
3294             return FALSE;
3295
3296           gtk_grab_add (widget);
3297           tree_view->priv->in_column_resize = TRUE;
3298
3299           _gtk_tree_view_column_set_resized_width (column, gtk_tree_view_column_get_width (column) -
3300                                                    tree_view->priv->last_extra_space_per_column);
3301
3302           /* block attached dnd signal handler */
3303           drag_data = g_object_get_data (G_OBJECT (widget), "gtk-site-data");
3304           if (drag_data)
3305             g_signal_handlers_block_matched (widget,
3306                                              G_SIGNAL_MATCH_DATA,
3307                                              0, 0, NULL, NULL,
3308                                              drag_data);
3309
3310           button = gtk_tree_view_column_get_button (column);
3311           gtk_widget_get_allocation (button, &button_allocation);
3312           tree_view->priv->drag_pos = i;
3313           tree_view->priv->x_drag = button_allocation.x + (rtl ? 0 : button_allocation.width);
3314
3315           if (!gtk_widget_has_focus (widget))
3316             gtk_widget_grab_focus (widget);
3317
3318           return TRUE;
3319         }
3320     }
3321   return FALSE;
3322 }
3323
3324 /* GtkWidget::button_release_event helper */
3325 static gboolean
3326 gtk_tree_view_button_release_drag_column (GtkWidget      *widget,
3327                                           GdkEventButton *event)
3328 {
3329   GtkTreeView *tree_view;
3330   GtkWidget *button;
3331   GList *l;
3332   gboolean rtl;
3333   GdkDevice *device, *other;
3334
3335   tree_view = GTK_TREE_VIEW (widget);
3336
3337   rtl = (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL);
3338   device = gdk_event_get_device ((GdkEvent*)event);
3339   other = gdk_device_get_associated_device (device);
3340   gdk_device_ungrab (device, event->time);
3341   gdk_device_ungrab (other, event->time);
3342
3343   /* Move the button back */
3344   button = gtk_tree_view_column_get_button (tree_view->priv->drag_column);
3345   g_object_ref (button);
3346   gtk_container_remove (GTK_CONTAINER (tree_view), button);
3347   gtk_widget_set_parent_window (button, tree_view->priv->header_window);
3348   gtk_widget_set_parent (button, GTK_WIDGET (tree_view));
3349   g_object_unref (button);
3350   gtk_widget_queue_resize (widget);
3351   if (gtk_tree_view_column_get_resizable (tree_view->priv->drag_column))
3352     {
3353       gdk_window_raise (_gtk_tree_view_column_get_window (tree_view->priv->drag_column));
3354       gdk_window_show (_gtk_tree_view_column_get_window (tree_view->priv->drag_column));
3355     }
3356   else
3357     gdk_window_hide (_gtk_tree_view_column_get_window (tree_view->priv->drag_column));
3358
3359   gtk_widget_grab_focus (button);
3360
3361   if (rtl)
3362     {
3363       if (tree_view->priv->cur_reorder &&
3364           tree_view->priv->cur_reorder->right_column != tree_view->priv->drag_column)
3365         gtk_tree_view_move_column_after (tree_view, tree_view->priv->drag_column,
3366                                          tree_view->priv->cur_reorder->right_column);
3367     }
3368   else
3369     {
3370       if (tree_view->priv->cur_reorder &&
3371           tree_view->priv->cur_reorder->left_column != tree_view->priv->drag_column)
3372         gtk_tree_view_move_column_after (tree_view, tree_view->priv->drag_column,
3373                                          tree_view->priv->cur_reorder->left_column);
3374     }
3375   tree_view->priv->drag_column = NULL;
3376   gdk_window_hide (tree_view->priv->drag_window);
3377
3378   for (l = tree_view->priv->column_drag_info; l != NULL; l = l->next)
3379     g_slice_free (GtkTreeViewColumnReorder, l->data);
3380   g_list_free (tree_view->priv->column_drag_info);
3381   tree_view->priv->column_drag_info = NULL;
3382   tree_view->priv->cur_reorder = NULL;
3383
3384   if (tree_view->priv->drag_highlight_window)
3385     gdk_window_hide (tree_view->priv->drag_highlight_window);
3386
3387   /* Reset our flags */
3388   tree_view->priv->drag_column_window_state = DRAG_COLUMN_WINDOW_STATE_UNSET;
3389   tree_view->priv->in_column_drag = FALSE;
3390
3391   return TRUE;
3392 }
3393
3394 /* GtkWidget::button_release_event helper */
3395 static gboolean
3396 gtk_tree_view_button_release_column_resize (GtkWidget      *widget,
3397                                             GdkEventButton *event)
3398 {
3399   GtkTreeView *tree_view;
3400   gpointer drag_data;
3401
3402   tree_view = GTK_TREE_VIEW (widget);
3403
3404   tree_view->priv->drag_pos = -1;
3405
3406   /* unblock attached dnd signal handler */
3407   drag_data = g_object_get_data (G_OBJECT (widget), "gtk-site-data");
3408   if (drag_data)
3409     g_signal_handlers_unblock_matched (widget,
3410                                        G_SIGNAL_MATCH_DATA,
3411                                        0, 0, NULL, NULL,
3412                                        drag_data);
3413
3414   tree_view->priv->in_column_resize = FALSE;
3415   gtk_grab_remove (widget);
3416   gdk_device_ungrab (gdk_event_get_device ((GdkEvent*)event), event->time);
3417   return TRUE;
3418 }
3419
3420 static gboolean
3421 gtk_tree_view_button_release (GtkWidget      *widget,
3422                               GdkEventButton *event)
3423 {
3424   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
3425
3426   if (tree_view->priv->in_column_drag)
3427     return gtk_tree_view_button_release_drag_column (widget, event);
3428
3429   if (tree_view->priv->rubber_band_status)
3430     gtk_tree_view_stop_rubber_band (tree_view);
3431
3432   if (tree_view->priv->pressed_button == event->button)
3433     tree_view->priv->pressed_button = -1;
3434
3435   if (tree_view->priv->in_column_resize)
3436     return gtk_tree_view_button_release_column_resize (widget, event);
3437
3438   if (tree_view->priv->button_pressed_node == NULL)
3439     return FALSE;
3440
3441   if (event->button == 1)
3442     {
3443       gtk_grab_remove (widget);
3444       if (tree_view->priv->button_pressed_node == tree_view->priv->prelight_node &&
3445           tree_view->priv->arrow_prelit)
3446         {
3447           GtkTreePath *path = NULL;
3448
3449           path = _gtk_tree_view_find_path (tree_view,
3450                                            tree_view->priv->button_pressed_tree,
3451                                            tree_view->priv->button_pressed_node);
3452           /* Actually activate the node */
3453           if (tree_view->priv->button_pressed_node->children == NULL)
3454             gtk_tree_view_real_expand_row (tree_view, path,
3455                                            tree_view->priv->button_pressed_tree,
3456                                            tree_view->priv->button_pressed_node,
3457                                            FALSE, TRUE);
3458           else
3459             gtk_tree_view_real_collapse_row (GTK_TREE_VIEW (widget), path,
3460                                              tree_view->priv->button_pressed_tree,
3461                                              tree_view->priv->button_pressed_node, TRUE);
3462           gtk_tree_path_free (path);
3463         }
3464
3465       tree_view->priv->button_pressed_tree = NULL;
3466       tree_view->priv->button_pressed_node = NULL;
3467     }
3468
3469   return TRUE;
3470 }
3471
3472 static gboolean
3473 gtk_tree_view_grab_broken (GtkWidget          *widget,
3474                            GdkEventGrabBroken *event)
3475 {
3476   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
3477
3478   if (tree_view->priv->in_column_drag)
3479     gtk_tree_view_button_release_drag_column (widget, (GdkEventButton *)event);
3480
3481   if (tree_view->priv->in_column_resize)
3482     gtk_tree_view_button_release_column_resize (widget, (GdkEventButton *)event);
3483
3484   return TRUE;
3485 }
3486
3487 #if 0
3488 static gboolean
3489 gtk_tree_view_configure (GtkWidget *widget,
3490                          GdkEventConfigure *event)
3491 {
3492   GtkTreeView *tree_view;
3493
3494   tree_view = GTK_TREE_VIEW (widget);
3495   tree_view->priv->search_position_func (tree_view, tree_view->priv->search_window);
3496
3497   return FALSE;
3498 }
3499 #endif
3500
3501 /* GtkWidget::motion_event function set.
3502  */
3503
3504 static gboolean
3505 coords_are_over_arrow (GtkTreeView *tree_view,
3506                        GtkRBTree   *tree,
3507                        GtkRBNode   *node,
3508                        /* these are in bin window coords */
3509                        gint         x,
3510                        gint         y)
3511 {
3512   GdkRectangle arrow;
3513   gint x2;
3514
3515   if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
3516     return FALSE;
3517
3518   if ((node->flags & GTK_RBNODE_IS_PARENT) == 0)
3519     return FALSE;
3520
3521   arrow.y = gtk_tree_view_get_row_y_offset (tree_view, tree, node);
3522   arrow.height = gtk_tree_view_get_row_height (tree_view, node);
3523
3524   gtk_tree_view_get_arrow_xrange (tree_view, tree, &arrow.x, &x2);
3525
3526   arrow.width = x2 - arrow.x;
3527
3528   return (x >= arrow.x &&
3529           x < (arrow.x + arrow.width) &&
3530           y >= arrow.y &&
3531           y < (arrow.y + arrow.height));
3532 }
3533
3534 static gboolean
3535 auto_expand_timeout (gpointer data)
3536 {
3537   GtkTreeView *tree_view = GTK_TREE_VIEW (data);
3538   GtkTreePath *path;
3539
3540   if (tree_view->priv->prelight_node)
3541     {
3542       path = _gtk_tree_view_find_path (tree_view,
3543                                        tree_view->priv->prelight_tree,
3544                                        tree_view->priv->prelight_node);
3545
3546       if (tree_view->priv->prelight_node->children)
3547         gtk_tree_view_collapse_row (tree_view, path);
3548       else
3549         gtk_tree_view_expand_row (tree_view, path, FALSE);
3550
3551       gtk_tree_path_free (path);
3552     }
3553
3554   tree_view->priv->auto_expand_timeout = 0;
3555
3556   return FALSE;
3557 }
3558
3559 static void
3560 remove_auto_expand_timeout (GtkTreeView *tree_view)
3561 {
3562   if (tree_view->priv->auto_expand_timeout != 0)
3563     {
3564       g_source_remove (tree_view->priv->auto_expand_timeout);
3565       tree_view->priv->auto_expand_timeout = 0;
3566     }
3567 }
3568
3569 static void
3570 do_prelight (GtkTreeView *tree_view,
3571              GtkRBTree   *tree,
3572              GtkRBNode   *node,
3573              /* these are in bin_window coords */
3574              gint         x,
3575              gint         y)
3576 {
3577   if (tree_view->priv->prelight_tree == tree &&
3578       tree_view->priv->prelight_node == node)
3579     {
3580       /*  We are still on the same node,
3581           but we might need to take care of the arrow  */
3582
3583       if (tree && node && gtk_tree_view_draw_expanders (tree_view))
3584         {
3585           gboolean over_arrow;
3586
3587           over_arrow = coords_are_over_arrow (tree_view, tree, node, x, y);
3588
3589           if (over_arrow != tree_view->priv->arrow_prelit)
3590             {
3591               if (over_arrow)
3592                 tree_view->priv->arrow_prelit = TRUE;
3593               else
3594                 tree_view->priv->arrow_prelit = FALSE;
3595
3596               gtk_tree_view_queue_draw_arrow (tree_view, tree, node);
3597             }
3598         }
3599
3600       return;
3601     }
3602
3603   if (tree_view->priv->prelight_tree && tree_view->priv->prelight_node)
3604     {
3605       /*  Unprelight the old node and arrow  */
3606
3607       GTK_RBNODE_UNSET_FLAG (tree_view->priv->prelight_node,
3608                              GTK_RBNODE_IS_PRELIT);
3609
3610       if (tree_view->priv->arrow_prelit
3611           && gtk_tree_view_draw_expanders (tree_view))
3612         {
3613           tree_view->priv->arrow_prelit = FALSE;
3614
3615           gtk_tree_view_queue_draw_arrow (tree_view,
3616                                           tree_view->priv->prelight_tree,
3617                                           tree_view->priv->prelight_node);
3618         }
3619
3620       _gtk_tree_view_queue_draw_node (tree_view,
3621                                       tree_view->priv->prelight_tree,
3622                                       tree_view->priv->prelight_node,
3623                                       NULL);
3624     }
3625
3626
3627   if (tree_view->priv->hover_expand)
3628     remove_auto_expand_timeout (tree_view);
3629
3630   /*  Set the new prelight values  */
3631   tree_view->priv->prelight_node = node;
3632   tree_view->priv->prelight_tree = tree;
3633
3634   if (!node || !tree)
3635     return;
3636
3637   /*  Prelight the new node and arrow  */
3638
3639   if (gtk_tree_view_draw_expanders (tree_view)
3640       && coords_are_over_arrow (tree_view, tree, node, x, y))
3641     {
3642       tree_view->priv->arrow_prelit = TRUE;
3643
3644       gtk_tree_view_queue_draw_arrow (tree_view, tree, node);
3645     }
3646
3647   GTK_RBNODE_SET_FLAG (node, GTK_RBNODE_IS_PRELIT);
3648
3649   _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
3650
3651   if (tree_view->priv->hover_expand)
3652     {
3653       tree_view->priv->auto_expand_timeout =
3654         gdk_threads_add_timeout (AUTO_EXPAND_TIMEOUT, auto_expand_timeout, tree_view);
3655     }
3656 }
3657
3658 static void
3659 prelight_or_select (GtkTreeView *tree_view,
3660                     GtkRBTree   *tree,
3661                     GtkRBNode   *node,
3662                     /* these are in bin_window coords */
3663                     gint         x,
3664                     gint         y)
3665 {
3666   GtkSelectionMode mode = gtk_tree_selection_get_mode (tree_view->priv->selection);
3667
3668   if (tree_view->priv->hover_selection &&
3669       (mode == GTK_SELECTION_SINGLE || mode == GTK_SELECTION_BROWSE) &&
3670       !(tree_view->priv->edited_column &&
3671         gtk_cell_area_get_edit_widget
3672         (gtk_cell_layout_get_area (GTK_CELL_LAYOUT (tree_view->priv->edited_column)))))
3673     {
3674       if (node)
3675         {
3676           if (!GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
3677             {
3678               GtkTreePath *path;
3679
3680               path = _gtk_tree_view_find_path (tree_view, tree, node);
3681               gtk_tree_selection_select_path (tree_view->priv->selection, path);
3682               if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
3683                 {
3684                   tree_view->priv->draw_keyfocus = FALSE;
3685                   gtk_tree_view_real_set_cursor (tree_view, path, FALSE, FALSE);
3686                 }
3687               gtk_tree_path_free (path);
3688             }
3689         }
3690
3691       else if (mode == GTK_SELECTION_SINGLE)
3692         gtk_tree_selection_unselect_all (tree_view->priv->selection);
3693     }
3694
3695     do_prelight (tree_view, tree, node, x, y);
3696 }
3697
3698 static void
3699 ensure_unprelighted (GtkTreeView *tree_view)
3700 {
3701   do_prelight (tree_view,
3702                NULL, NULL,
3703                -1000, -1000); /* coords not possibly over an arrow */
3704
3705   g_assert (tree_view->priv->prelight_node == NULL);
3706 }
3707
3708 static void
3709 update_prelight (GtkTreeView *tree_view,
3710                  gint         x,
3711                  gint         y)
3712 {
3713   int new_y;
3714   GtkRBTree *tree;
3715   GtkRBNode *node;
3716
3717   if (tree_view->priv->tree == NULL)
3718     return;
3719
3720   if (x == -10000)
3721     {
3722       ensure_unprelighted (tree_view);
3723       return;
3724     }
3725
3726   new_y = TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, y);
3727   if (new_y < 0)
3728     new_y = 0;
3729
3730   _gtk_rbtree_find_offset (tree_view->priv->tree,
3731                            new_y, &tree, &node);
3732
3733   if (node)
3734     prelight_or_select (tree_view, tree, node, x, y);
3735 }
3736
3737
3738
3739
3740 /* Our motion arrow is either a box (in the case of the original spot)
3741  * or an arrow.  It is expander_size wide.
3742  */
3743 /*
3744  * 11111111111111
3745  * 01111111111110
3746  * 00111111111100
3747  * 00011111111000
3748  * 00001111110000
3749  * 00000111100000
3750  * 00000111100000
3751  * 00000111100000
3752  * ~ ~ ~ ~ ~ ~ ~
3753  * 00000111100000
3754  * 00000111100000
3755  * 00000111100000
3756  * 00001111110000
3757  * 00011111111000
3758  * 00111111111100
3759  * 01111111111110
3760  * 11111111111111
3761  */
3762
3763 static void
3764 gtk_tree_view_motion_draw_column_motion_arrow (GtkTreeView *tree_view)
3765 {
3766   GtkTreeViewColumnReorder *reorder = tree_view->priv->cur_reorder;
3767   GtkWidget *widget = GTK_WIDGET (tree_view);
3768   cairo_surface_t *mask_image;
3769   cairo_region_t *mask_region;
3770   gint x;
3771   gint y;
3772   gint width;
3773   gint height;
3774   gint arrow_type = DRAG_COLUMN_WINDOW_STATE_UNSET;
3775   GdkWindowAttr attributes;
3776   guint attributes_mask;
3777   cairo_t *cr;
3778
3779   if (!reorder ||
3780       reorder->left_column == tree_view->priv->drag_column ||
3781       reorder->right_column == tree_view->priv->drag_column)
3782     arrow_type = DRAG_COLUMN_WINDOW_STATE_ORIGINAL;
3783   else if (reorder->left_column || reorder->right_column)
3784     {
3785       GtkAllocation left_allocation, right_allocation;
3786       GdkRectangle visible_rect;
3787       GtkWidget *button;
3788
3789       gtk_tree_view_get_visible_rect (tree_view, &visible_rect);
3790       if (reorder->left_column)
3791         {
3792           button = gtk_tree_view_column_get_button (reorder->left_column);
3793           gtk_widget_get_allocation (button, &left_allocation);
3794           x = left_allocation.x + left_allocation.width;
3795         }
3796       else
3797         {
3798           button = gtk_tree_view_column_get_button (reorder->right_column);
3799           gtk_widget_get_allocation (button, &right_allocation);
3800           x = right_allocation.x;
3801         }
3802
3803       if (x < visible_rect.x)
3804         arrow_type = DRAG_COLUMN_WINDOW_STATE_ARROW_LEFT;
3805       else if (x > visible_rect.x + visible_rect.width)
3806         arrow_type = DRAG_COLUMN_WINDOW_STATE_ARROW_RIGHT;
3807       else
3808         arrow_type = DRAG_COLUMN_WINDOW_STATE_ARROW;
3809     }
3810
3811   /* We want to draw the rectangle over the initial location. */
3812   if (arrow_type == DRAG_COLUMN_WINDOW_STATE_ORIGINAL)
3813     {
3814       if (tree_view->priv->drag_column_window_state != DRAG_COLUMN_WINDOW_STATE_ORIGINAL)
3815         {
3816           GtkAllocation drag_allocation;
3817           GtkWidget    *button;
3818
3819           if (tree_view->priv->drag_highlight_window)
3820             {
3821               gdk_window_set_user_data (tree_view->priv->drag_highlight_window,
3822                                         NULL);
3823               gdk_window_destroy (tree_view->priv->drag_highlight_window);
3824             }
3825
3826           button = gtk_tree_view_column_get_button (tree_view->priv->drag_column);
3827           attributes.window_type = GDK_WINDOW_CHILD;
3828           attributes.wclass = GDK_INPUT_OUTPUT;
3829           attributes.x = tree_view->priv->drag_column_x;
3830           attributes.y = 0;
3831           gtk_widget_get_allocation (button, &drag_allocation);
3832           width = attributes.width = drag_allocation.width;
3833           height = attributes.height = drag_allocation.height;
3834           attributes.visual = gtk_widget_get_visual (GTK_WIDGET (tree_view));
3835           attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK;
3836           attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
3837           tree_view->priv->drag_highlight_window = gdk_window_new (tree_view->priv->header_window, &attributes, attributes_mask);
3838           gdk_window_set_user_data (tree_view->priv->drag_highlight_window, GTK_WIDGET (tree_view));
3839
3840           mask_image = cairo_image_surface_create (CAIRO_FORMAT_A1, width, height);
3841           cr = cairo_create (mask_image);
3842
3843           cairo_rectangle (cr, 1, 1, width - 2, height - 2);
3844           cairo_stroke (cr);
3845           cairo_destroy (cr);
3846
3847           mask_region = gdk_cairo_region_create_from_surface (mask_image);
3848           gdk_window_shape_combine_region (tree_view->priv->drag_highlight_window,
3849                                            mask_region, 0, 0);
3850
3851           cairo_region_destroy (mask_region);
3852           cairo_surface_destroy (mask_image);
3853
3854           tree_view->priv->drag_column_window_state = DRAG_COLUMN_WINDOW_STATE_ORIGINAL;
3855         }
3856     }
3857   else if (arrow_type == DRAG_COLUMN_WINDOW_STATE_ARROW)
3858     {
3859       GtkAllocation button_allocation;
3860       GtkWidget    *button;
3861
3862       width = tree_view->priv->expander_size;
3863
3864       /* Get x, y, width, height of arrow */
3865       gdk_window_get_origin (tree_view->priv->header_window, &x, &y);
3866       if (reorder->left_column)
3867         {
3868           button = gtk_tree_view_column_get_button (reorder->left_column);
3869           gtk_widget_get_allocation (button, &button_allocation);
3870           x += button_allocation.x + button_allocation.width - width/2;
3871           height = button_allocation.height;
3872         }
3873       else
3874         {
3875           button = gtk_tree_view_column_get_button (reorder->right_column);
3876           gtk_widget_get_allocation (button, &button_allocation);
3877           x += button_allocation.x - width/2;
3878           height = button_allocation.height;
3879         }
3880       y -= tree_view->priv->expander_size/2; /* The arrow takes up only half the space */
3881       height += tree_view->priv->expander_size;
3882
3883       /* Create the new window */
3884       if (tree_view->priv->drag_column_window_state != DRAG_COLUMN_WINDOW_STATE_ARROW)
3885         {
3886           if (tree_view->priv->drag_highlight_window)
3887             {
3888               gdk_window_set_user_data (tree_view->priv->drag_highlight_window,
3889                                         NULL);
3890               gdk_window_destroy (tree_view->priv->drag_highlight_window);
3891             }
3892
3893           attributes.window_type = GDK_WINDOW_TEMP;
3894           attributes.wclass = GDK_INPUT_OUTPUT;
3895           attributes.visual = gtk_widget_get_visual (GTK_WIDGET (tree_view));
3896           attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK;
3897           attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
3898           attributes.x = x;
3899           attributes.y = y;
3900           attributes.width = width;
3901           attributes.height = height;
3902           tree_view->priv->drag_highlight_window = gdk_window_new (gtk_widget_get_root_window (widget),
3903                                                                    &attributes, attributes_mask);
3904           gdk_window_set_user_data (tree_view->priv->drag_highlight_window, GTK_WIDGET (tree_view));
3905
3906           mask_image = cairo_image_surface_create (CAIRO_FORMAT_A1, width, height);
3907
3908           cr = cairo_create (mask_image);
3909           cairo_move_to (cr, 0, 0);
3910           cairo_line_to (cr, width, 0);
3911           cairo_line_to (cr, width / 2., width / 2);
3912           cairo_move_to (cr, 0, height);
3913           cairo_line_to (cr, width, height);
3914           cairo_line_to (cr, width / 2., height - width / 2.);
3915           cairo_fill (cr);
3916           cairo_destroy (cr);
3917
3918           mask_region = gdk_cairo_region_create_from_surface (mask_image);
3919           gdk_window_shape_combine_region (tree_view->priv->drag_highlight_window,
3920                                            mask_region, 0, 0);
3921
3922           cairo_region_destroy (mask_region);
3923           cairo_surface_destroy (mask_image);
3924         }
3925
3926       tree_view->priv->drag_column_window_state = DRAG_COLUMN_WINDOW_STATE_ARROW;
3927       gdk_window_move (tree_view->priv->drag_highlight_window, x, y);
3928     }
3929   else if (arrow_type == DRAG_COLUMN_WINDOW_STATE_ARROW_LEFT ||
3930            arrow_type == DRAG_COLUMN_WINDOW_STATE_ARROW_RIGHT)
3931     {
3932       GtkAllocation allocation;
3933       GtkWidget    *button;
3934
3935       width = tree_view->priv->expander_size;
3936
3937       /* Get x, y, width, height of arrow */
3938       width = width/2; /* remember, the arrow only takes half the available width */
3939       gdk_window_get_origin (gtk_widget_get_window (widget),
3940                              &x, &y);
3941       if (arrow_type == DRAG_COLUMN_WINDOW_STATE_ARROW_RIGHT)
3942         {
3943           gtk_widget_get_allocation (widget, &allocation);
3944           x += allocation.width - width;
3945         }
3946
3947       if (reorder->left_column)
3948         {
3949           button = gtk_tree_view_column_get_button (reorder->left_column);
3950           gtk_widget_get_allocation (button, &allocation);
3951           height = allocation.height;
3952         }
3953       else
3954         {
3955           button = gtk_tree_view_column_get_button (reorder->right_column);
3956           gtk_widget_get_allocation (button, &allocation);
3957           height = allocation.height;
3958         }
3959
3960       y -= tree_view->priv->expander_size;
3961       height += 2*tree_view->priv->expander_size;
3962
3963       /* Create the new window */
3964       if (tree_view->priv->drag_column_window_state != DRAG_COLUMN_WINDOW_STATE_ARROW_LEFT &&
3965           tree_view->priv->drag_column_window_state != DRAG_COLUMN_WINDOW_STATE_ARROW_RIGHT)
3966         {
3967           if (tree_view->priv->drag_highlight_window)
3968             {
3969               gdk_window_set_user_data (tree_view->priv->drag_highlight_window,
3970                                         NULL);
3971               gdk_window_destroy (tree_view->priv->drag_highlight_window);
3972             }
3973
3974           attributes.window_type = GDK_WINDOW_TEMP;
3975           attributes.wclass = GDK_INPUT_OUTPUT;
3976           attributes.visual = gtk_widget_get_visual (GTK_WIDGET (tree_view));
3977           attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK;
3978           attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
3979           attributes.x = x;
3980           attributes.y = y;
3981           attributes.width = width;
3982           attributes.height = height;
3983           tree_view->priv->drag_highlight_window = gdk_window_new (NULL, &attributes, attributes_mask);
3984           gdk_window_set_user_data (tree_view->priv->drag_highlight_window, GTK_WIDGET (tree_view));
3985
3986           mask_image = cairo_image_surface_create (CAIRO_FORMAT_A1, width, height);
3987
3988           cr = cairo_create (mask_image);
3989           /* mirror if we're on the left */
3990           if (arrow_type == DRAG_COLUMN_WINDOW_STATE_ARROW_LEFT)
3991             {
3992               cairo_translate (cr, width, 0);
3993               cairo_scale (cr, -1, 1);
3994             }
3995           cairo_move_to (cr, 0, 0);
3996           cairo_line_to (cr, width, width);
3997           cairo_line_to (cr, 0, tree_view->priv->expander_size);
3998           cairo_move_to (cr, 0, height);
3999           cairo_line_to (cr, width, height - width);
4000           cairo_line_to (cr, 0, height - tree_view->priv->expander_size);
4001           cairo_fill (cr);
4002           cairo_destroy (cr);
4003
4004           mask_region = gdk_cairo_region_create_from_surface (mask_image);
4005           gdk_window_shape_combine_region (tree_view->priv->drag_highlight_window,
4006                                            mask_region, 0, 0);
4007
4008           cairo_region_destroy (mask_region);
4009           cairo_surface_destroy (mask_image);
4010         }
4011
4012       tree_view->priv->drag_column_window_state = arrow_type;
4013       gdk_window_move (tree_view->priv->drag_highlight_window, x, y);
4014    }
4015   else
4016     {
4017       g_warning (G_STRLOC"Invalid GtkTreeViewColumnReorder struct");
4018       gdk_window_hide (tree_view->priv->drag_highlight_window);
4019       return;
4020     }
4021
4022   gdk_window_show (tree_view->priv->drag_highlight_window);
4023   gdk_window_raise (tree_view->priv->drag_highlight_window);
4024 }
4025
4026 static gboolean
4027 gtk_tree_view_motion_resize_column (GtkWidget      *widget,
4028                                     GdkEventMotion *event)
4029 {
4030   gint x;
4031   gint new_width;
4032   GtkTreeViewColumn *column;
4033   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
4034
4035   column = gtk_tree_view_get_column (tree_view, tree_view->priv->drag_pos);
4036
4037   if (event->is_hint || event->window != gtk_widget_get_window (widget))
4038     gtk_widget_get_pointer (widget, &x, NULL);
4039   else
4040     x = event->x;
4041
4042   if (tree_view->priv->hadjustment)
4043     x += tree_view->priv->hadjustment->value;
4044
4045   new_width = gtk_tree_view_new_column_width (tree_view,
4046                                               tree_view->priv->drag_pos, &x);
4047   if (x != tree_view->priv->x_drag &&
4048       (new_width != gtk_tree_view_column_get_fixed_width (column)))
4049     {
4050       _gtk_tree_view_column_set_use_resized_width (column, TRUE);
4051
4052       if (gtk_tree_view_column_get_expand (column))
4053         new_width -= tree_view->priv->last_extra_space_per_column;
4054
4055       _gtk_tree_view_column_set_resized_width (column, new_width);
4056
4057
4058       gtk_widget_queue_resize (widget);
4059     }
4060
4061   return FALSE;
4062 }
4063
4064
4065 static void
4066 gtk_tree_view_update_current_reorder (GtkTreeView *tree_view)
4067 {
4068   GtkTreeViewColumnReorder *reorder = NULL;
4069   GList *list;
4070   gint mouse_x;
4071
4072   gdk_window_get_pointer (tree_view->priv->header_window, &mouse_x, NULL, NULL);
4073   for (list = tree_view->priv->column_drag_info; list; list = list->next)
4074     {
4075       reorder = (GtkTreeViewColumnReorder *) list->data;
4076       if (mouse_x >= reorder->left_align && mouse_x < reorder->right_align)
4077         break;
4078       reorder = NULL;
4079     }
4080
4081   /*  if (reorder && reorder == tree_view->priv->cur_reorder)
4082       return;*/
4083
4084   tree_view->priv->cur_reorder = reorder;
4085   gtk_tree_view_motion_draw_column_motion_arrow (tree_view);
4086 }
4087
4088 static void
4089 gtk_tree_view_vertical_autoscroll (GtkTreeView *tree_view)
4090 {
4091   GdkRectangle visible_rect;
4092   gint y;
4093   gint offset;
4094
4095   gdk_window_get_pointer (tree_view->priv->bin_window, NULL, &y, NULL);
4096   y += tree_view->priv->dy;
4097
4098   gtk_tree_view_get_visible_rect (tree_view, &visible_rect);
4099
4100   /* see if we are near the edge. */
4101   offset = y - (visible_rect.y + 2 * SCROLL_EDGE_SIZE);
4102   if (offset > 0)
4103     {
4104       offset = y - (visible_rect.y + visible_rect.height - 2 * SCROLL_EDGE_SIZE);
4105       if (offset < 0)
4106         return;
4107     }
4108
4109   gtk_adjustment_set_value (tree_view->priv->vadjustment,
4110                             MAX (tree_view->priv->vadjustment->value + offset, 0.0));
4111 }
4112
4113 static gboolean
4114 gtk_tree_view_horizontal_autoscroll (GtkTreeView *tree_view)
4115 {
4116   GdkRectangle visible_rect;
4117   gint x;
4118   gint offset;
4119
4120   gdk_window_get_pointer (tree_view->priv->bin_window, &x, NULL, NULL);
4121
4122   gtk_tree_view_get_visible_rect (tree_view, &visible_rect);
4123
4124   /* See if we are near the edge. */
4125   offset = x - (visible_rect.x + SCROLL_EDGE_SIZE);
4126   if (offset > 0)
4127     {
4128       offset = x - (visible_rect.x + visible_rect.width - SCROLL_EDGE_SIZE);
4129       if (offset < 0)
4130         return TRUE;
4131     }
4132   offset = offset/3;
4133
4134   gtk_adjustment_set_value (tree_view->priv->hadjustment,
4135                             MAX (tree_view->priv->hadjustment->value + offset, 0.0));
4136
4137   return TRUE;
4138
4139 }
4140
4141 static gboolean
4142 gtk_tree_view_motion_drag_column (GtkWidget      *widget,
4143                                   GdkEventMotion *event)
4144 {
4145   GtkAllocation allocation, button_allocation;
4146   GtkTreeView *tree_view = (GtkTreeView *) widget;
4147   GtkTreeViewColumn *column = tree_view->priv->drag_column;
4148   GtkWidget *button;
4149   gint x, y;
4150
4151   /* Sanity Check */
4152   if ((column == NULL) ||
4153       (event->window != tree_view->priv->drag_window))
4154     return FALSE;
4155
4156   button = gtk_tree_view_column_get_button (column);
4157
4158   /* Handle moving the header */
4159   gdk_window_get_position (tree_view->priv->drag_window, &x, &y);
4160   gtk_widget_get_allocation (widget, &allocation);
4161   gtk_widget_get_allocation (button, &button_allocation);
4162   x = CLAMP (x + (gint)event->x - _gtk_tree_view_column_get_drag_x (column), 0,
4163              MAX (tree_view->priv->width, allocation.width) - button_allocation.width);
4164   gdk_window_move (tree_view->priv->drag_window, x, y);
4165
4166   /* autoscroll, if needed */
4167   gtk_tree_view_horizontal_autoscroll (tree_view);
4168   /* Update the current reorder position and arrow; */
4169   gtk_tree_view_update_current_reorder (tree_view);
4170
4171   return TRUE;
4172 }
4173
4174 static void
4175 gtk_tree_view_stop_rubber_band (GtkTreeView *tree_view)
4176 {
4177   remove_scroll_timeout (tree_view);
4178   gtk_grab_remove (GTK_WIDGET (tree_view));
4179
4180   if (tree_view->priv->rubber_band_status == RUBBER_BAND_ACTIVE)
4181     {
4182       GtkTreePath *tmp_path;
4183
4184       gtk_widget_queue_draw (GTK_WIDGET (tree_view));
4185
4186       /* The anchor path should be set to the start path */
4187       tmp_path = _gtk_tree_view_find_path (tree_view,
4188                                            tree_view->priv->rubber_band_start_tree,
4189                                            tree_view->priv->rubber_band_start_node);
4190
4191       if (tree_view->priv->anchor)
4192         gtk_tree_row_reference_free (tree_view->priv->anchor);
4193
4194       tree_view->priv->anchor =
4195         gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view),
4196                                           tree_view->priv->model,
4197                                           tmp_path);
4198
4199       gtk_tree_path_free (tmp_path);
4200
4201       /* ... and the cursor to the end path */
4202       tmp_path = _gtk_tree_view_find_path (tree_view,
4203                                            tree_view->priv->rubber_band_end_tree,
4204                                            tree_view->priv->rubber_band_end_node);
4205       gtk_tree_view_real_set_cursor (GTK_TREE_VIEW (tree_view), tmp_path, FALSE, FALSE);
4206       gtk_tree_path_free (tmp_path);
4207
4208       _gtk_tree_selection_emit_changed (tree_view->priv->selection);
4209     }
4210
4211   /* Clear status variables */
4212   tree_view->priv->rubber_band_status = RUBBER_BAND_OFF;
4213   tree_view->priv->rubber_band_shift = 0;
4214   tree_view->priv->rubber_band_ctrl = 0;
4215
4216   tree_view->priv->rubber_band_start_node = NULL;
4217   tree_view->priv->rubber_band_start_tree = NULL;
4218   tree_view->priv->rubber_band_end_node = NULL;
4219   tree_view->priv->rubber_band_end_tree = NULL;
4220 }
4221
4222 static void
4223 gtk_tree_view_update_rubber_band_selection_range (GtkTreeView *tree_view,
4224                                                  GtkRBTree   *start_tree,
4225                                                  GtkRBNode   *start_node,
4226                                                  GtkRBTree   *end_tree,
4227                                                  GtkRBNode   *end_node,
4228                                                  gboolean     select,
4229                                                  gboolean     skip_start,
4230                                                  gboolean     skip_end)
4231 {
4232   if (start_node == end_node)
4233     return;
4234
4235   /* We skip the first node and jump inside the loop */
4236   if (skip_start)
4237     goto skip_first;
4238
4239   do
4240     {
4241       /* Small optimization by assuming insensitive nodes are never
4242        * selected.
4243        */
4244       if (!GTK_RBNODE_FLAG_SET (start_node, GTK_RBNODE_IS_SELECTED))
4245         {
4246           GtkTreePath *path;
4247           gboolean selectable;
4248
4249           path = _gtk_tree_view_find_path (tree_view, start_tree, start_node);
4250           selectable = _gtk_tree_selection_row_is_selectable (tree_view->priv->selection, start_node, path);
4251           gtk_tree_path_free (path);
4252
4253           if (!selectable)
4254             goto node_not_selectable;
4255         }
4256
4257       if (select)
4258         {
4259           if (tree_view->priv->rubber_band_shift)
4260             GTK_RBNODE_SET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
4261           else if (tree_view->priv->rubber_band_ctrl)
4262             {
4263               /* Toggle the selection state */
4264               if (GTK_RBNODE_FLAG_SET (start_node, GTK_RBNODE_IS_SELECTED))
4265                 GTK_RBNODE_UNSET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
4266               else
4267                 GTK_RBNODE_SET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
4268             }
4269           else
4270             GTK_RBNODE_SET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
4271         }
4272       else
4273         {
4274           /* Mirror the above */
4275           if (tree_view->priv->rubber_band_shift)
4276             GTK_RBNODE_UNSET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
4277           else if (tree_view->priv->rubber_band_ctrl)
4278             {
4279               /* Toggle the selection state */
4280               if (GTK_RBNODE_FLAG_SET (start_node, GTK_RBNODE_IS_SELECTED))
4281                 GTK_RBNODE_UNSET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
4282               else
4283                 GTK_RBNODE_SET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
4284             }
4285           else
4286             GTK_RBNODE_UNSET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
4287         }
4288
4289       _gtk_tree_view_queue_draw_node (tree_view, start_tree, start_node, NULL);
4290
4291 node_not_selectable:
4292       if (start_node == end_node)
4293         break;
4294
4295 skip_first:
4296
4297       if (start_node->children)
4298         {
4299           start_tree = start_node->children;
4300           start_node = start_tree->root;
4301           while (start_node->left != start_tree->nil)
4302             start_node = start_node->left;
4303         }
4304       else
4305         {
4306           _gtk_rbtree_next_full (start_tree, start_node, &start_tree, &start_node);
4307
4308           if (!start_tree)
4309             /* Ran out of tree */
4310             break;
4311         }
4312
4313       if (skip_end && start_node == end_node)
4314         break;
4315     }
4316   while (TRUE);
4317 }
4318
4319 static void
4320 gtk_tree_view_update_rubber_band_selection (GtkTreeView *tree_view)
4321 {
4322   GtkRBTree *start_tree, *end_tree;
4323   GtkRBNode *start_node, *end_node;
4324
4325   _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);
4326   _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);
4327
4328   /* Handle the start area first */
4329   if (!tree_view->priv->rubber_band_start_node)
4330     {
4331       gtk_tree_view_update_rubber_band_selection_range (tree_view,
4332                                                        start_tree,
4333                                                        start_node,
4334                                                        end_tree,
4335                                                        end_node,
4336                                                        TRUE,
4337                                                        FALSE,
4338                                                        FALSE);
4339     }
4340   else if (_gtk_rbtree_node_find_offset (start_tree, start_node) <
4341            _gtk_rbtree_node_find_offset (tree_view->priv->rubber_band_start_tree, tree_view->priv->rubber_band_start_node))
4342     {
4343       /* New node is above the old one; selection became bigger */
4344       gtk_tree_view_update_rubber_band_selection_range (tree_view,
4345                                                        start_tree,
4346                                                        start_node,
4347                                                        tree_view->priv->rubber_band_start_tree,
4348                                                        tree_view->priv->rubber_band_start_node,
4349                                                        TRUE,
4350                                                        FALSE,
4351                                                        TRUE);
4352     }
4353   else if (_gtk_rbtree_node_find_offset (start_tree, start_node) >
4354            _gtk_rbtree_node_find_offset (tree_view->priv->rubber_band_start_tree, tree_view->priv->rubber_band_start_node))
4355     {
4356       /* New node is below the old one; selection became smaller */
4357       gtk_tree_view_update_rubber_band_selection_range (tree_view,
4358                                                        tree_view->priv->rubber_band_start_tree,
4359                                                        tree_view->priv->rubber_band_start_node,
4360                                                        start_tree,
4361                                                        start_node,
4362                                                        FALSE,
4363                                                        FALSE,
4364                                                        TRUE);
4365     }
4366
4367   tree_view->priv->rubber_band_start_tree = start_tree;
4368   tree_view->priv->rubber_band_start_node = start_node;
4369
4370   /* Next, handle the end area */
4371   if (!tree_view->priv->rubber_band_end_node)
4372     {
4373       /* In the event this happens, start_node was also NULL; this case is
4374        * handled above.
4375        */
4376     }
4377   else if (!end_node)
4378     {
4379       /* Find the last node in the tree */
4380       _gtk_rbtree_find_offset (tree_view->priv->tree, tree_view->priv->height - 1,
4381                                &end_tree, &end_node);
4382
4383       /* Selection reached end of the tree */
4384       gtk_tree_view_update_rubber_band_selection_range (tree_view,
4385                                                        tree_view->priv->rubber_band_end_tree,
4386                                                        tree_view->priv->rubber_band_end_node,
4387                                                        end_tree,
4388                                                        end_node,
4389                                                        TRUE,
4390                                                        TRUE,
4391                                                        FALSE);
4392     }
4393   else if (_gtk_rbtree_node_find_offset (end_tree, end_node) >
4394            _gtk_rbtree_node_find_offset (tree_view->priv->rubber_band_end_tree, tree_view->priv->rubber_band_end_node))
4395     {
4396       /* New node is below the old one; selection became bigger */
4397       gtk_tree_view_update_rubber_band_selection_range (tree_view,
4398                                                        tree_view->priv->rubber_band_end_tree,
4399                                                        tree_view->priv->rubber_band_end_node,
4400                                                        end_tree,
4401                                                        end_node,
4402                                                        TRUE,
4403                                                        TRUE,
4404                                                        FALSE);
4405     }
4406   else if (_gtk_rbtree_node_find_offset (end_tree, end_node) <
4407            _gtk_rbtree_node_find_offset (tree_view->priv->rubber_band_end_tree, tree_view->priv->rubber_band_end_node))
4408     {
4409       /* New node is above the old one; selection became smaller */
4410       gtk_tree_view_update_rubber_band_selection_range (tree_view,
4411                                                        end_tree,
4412                                                        end_node,
4413                                                        tree_view->priv->rubber_band_end_tree,
4414                                                        tree_view->priv->rubber_band_end_node,
4415                                                        FALSE,
4416                                                        TRUE,
4417                                                        FALSE);
4418     }
4419
4420   tree_view->priv->rubber_band_end_tree = end_tree;
4421   tree_view->priv->rubber_band_end_node = end_node;
4422 }
4423
4424 static void
4425 gtk_tree_view_update_rubber_band (GtkTreeView *tree_view)
4426 {
4427   gint x, y;
4428   GdkRectangle old_area;
4429   GdkRectangle new_area;
4430   GdkRectangle common;
4431   cairo_region_t *invalid_region;
4432
4433   old_area.x = MIN (tree_view->priv->press_start_x, tree_view->priv->rubber_band_x);
4434   old_area.y = MIN (tree_view->priv->press_start_y, tree_view->priv->rubber_band_y) - tree_view->priv->dy;
4435   old_area.width = ABS (tree_view->priv->rubber_band_x - tree_view->priv->press_start_x) + 1;
4436   old_area.height = ABS (tree_view->priv->rubber_band_y - tree_view->priv->press_start_y) + 1;
4437
4438   gdk_window_get_pointer (tree_view->priv->bin_window, &x, &y, NULL);
4439
4440   x = MAX (x, 0);
4441   y = MAX (y, 0) + tree_view->priv->dy;
4442
4443   new_area.x = MIN (tree_view->priv->press_start_x, x);
4444   new_area.y = MIN (tree_view->priv->press_start_y, y) - tree_view->priv->dy;
4445   new_area.width = ABS (x - tree_view->priv->press_start_x) + 1;
4446   new_area.height = ABS (y - tree_view->priv->press_start_y) + 1;
4447
4448   invalid_region = cairo_region_create_rectangle (&old_area);
4449   cairo_region_union_rectangle (invalid_region, &new_area);
4450
4451   gdk_rectangle_intersect (&old_area, &new_area, &common);
4452   if (common.width > 2 && common.height > 2)
4453     {
4454       cairo_region_t *common_region;
4455
4456       /* make sure the border is invalidated */
4457       common.x += 1;
4458       common.y += 1;
4459       common.width -= 2;
4460       common.height -= 2;
4461
4462       common_region = cairo_region_create_rectangle (&common);
4463
4464       cairo_region_subtract (invalid_region, common_region);
4465       cairo_region_destroy (common_region);
4466     }
4467
4468   gdk_window_invalidate_region (tree_view->priv->bin_window, invalid_region, TRUE);
4469
4470   cairo_region_destroy (invalid_region);
4471
4472   tree_view->priv->rubber_band_x = x;
4473   tree_view->priv->rubber_band_y = y;
4474
4475   gtk_tree_view_update_rubber_band_selection (tree_view);
4476 }
4477
4478 static void
4479 gtk_tree_view_paint_rubber_band (GtkTreeView  *tree_view,
4480                                  cairo_t      *cr)
4481 {
4482   GdkRectangle rect;
4483   GtkStyle *style;
4484
4485   cairo_save (cr);
4486
4487   rect.x = MIN (tree_view->priv->press_start_x, tree_view->priv->rubber_band_x);
4488   rect.y = MIN (tree_view->priv->press_start_y, tree_view->priv->rubber_band_y) - tree_view->priv->dy;
4489   rect.width = ABS (tree_view->priv->press_start_x - tree_view->priv->rubber_band_x) + 1;
4490   rect.height = ABS (tree_view->priv->press_start_y - tree_view->priv->rubber_band_y) + 1;
4491
4492   cairo_set_line_width (cr, 1.0);
4493
4494   style = gtk_widget_get_style (GTK_WIDGET (tree_view));
4495
4496   gdk_cairo_set_source_color (cr, &style->fg[GTK_STATE_NORMAL]);
4497
4498   gdk_cairo_rectangle (cr, &rect);
4499   cairo_clip (cr);
4500   cairo_paint_with_alpha (cr, 0.25);
4501
4502   cairo_rectangle (cr,
4503                    rect.x + 0.5, rect.y + 0.5,
4504                    rect.width - 1, rect.height - 1);
4505   cairo_stroke (cr);
4506
4507   cairo_restore (cr);
4508 }
4509
4510 static gboolean
4511 gtk_tree_view_motion_bin_window (GtkWidget      *widget,
4512                                  GdkEventMotion *event)
4513 {
4514   GtkTreeView *tree_view;
4515   GtkRBTree *tree;
4516   GtkRBNode *node;
4517   gint new_y;
4518
4519   tree_view = (GtkTreeView *) widget;
4520
4521   if (tree_view->priv->tree == NULL)
4522     return FALSE;
4523
4524   if (tree_view->priv->rubber_band_status == RUBBER_BAND_MAYBE_START)
4525     {
4526       gtk_grab_add (GTK_WIDGET (tree_view));
4527       gtk_tree_view_update_rubber_band (tree_view);
4528
4529       tree_view->priv->rubber_band_status = RUBBER_BAND_ACTIVE;
4530     }
4531   else if (tree_view->priv->rubber_band_status == RUBBER_BAND_ACTIVE)
4532     {
4533       gtk_tree_view_update_rubber_band (tree_view);
4534
4535       add_scroll_timeout (tree_view);
4536     }
4537
4538   /* only check for an initiated drag when a button is pressed */
4539   if (tree_view->priv->pressed_button >= 0
4540       && !tree_view->priv->rubber_band_status)
4541     gtk_tree_view_maybe_begin_dragging_row (tree_view, event);
4542
4543   new_y = TREE_WINDOW_Y_TO_RBTREE_Y(tree_view, event->y);
4544   if (new_y < 0)
4545     new_y = 0;
4546
4547   _gtk_rbtree_find_offset (tree_view->priv->tree, new_y, &tree, &node);
4548
4549   /* If we are currently pressing down a button, we don't want to prelight anything else. */
4550   if ((tree_view->priv->button_pressed_node != NULL) &&
4551       (tree_view->priv->button_pressed_node != node))
4552     node = NULL;
4553
4554   tree_view->priv->event_last_x = event->x;
4555   tree_view->priv->event_last_y = event->y;
4556
4557   prelight_or_select (tree_view, tree, node, event->x, event->y);
4558
4559   return TRUE;
4560 }
4561
4562 static gboolean
4563 gtk_tree_view_motion (GtkWidget      *widget,
4564                       GdkEventMotion *event)
4565 {
4566   GtkTreeView *tree_view;
4567
4568   tree_view = (GtkTreeView *) widget;
4569
4570   /* Resizing a column */
4571   if (tree_view->priv->in_column_resize)
4572     return gtk_tree_view_motion_resize_column (widget, event);
4573
4574   /* Drag column */
4575   if (tree_view->priv->in_column_drag)
4576     return gtk_tree_view_motion_drag_column (widget, event);
4577
4578   /* Sanity check it */
4579   if (event->window == tree_view->priv->bin_window)
4580     return gtk_tree_view_motion_bin_window (widget, event);
4581
4582   return FALSE;
4583 }
4584
4585 /* Invalidate the focus rectangle near the edge of the bin_window; used when
4586  * the tree is empty.
4587  */
4588 static void
4589 invalidate_empty_focus (GtkTreeView *tree_view)
4590 {
4591   GdkRectangle area;
4592
4593   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
4594     return;
4595
4596   area.x = 0;
4597   area.y = 0;
4598   area.width = gdk_window_get_width (tree_view->priv->bin_window);
4599   area.height = gdk_window_get_height (tree_view->priv->bin_window);
4600   gdk_window_invalidate_rect (tree_view->priv->bin_window, &area, FALSE);
4601 }
4602
4603 /* Draws a focus rectangle near the edge of the bin_window; used when the tree
4604  * is empty.
4605  */
4606 static void
4607 draw_empty_focus (GtkTreeView *tree_view, cairo_t *cr)
4608 {
4609   GtkWidget *widget = GTK_WIDGET (tree_view);
4610   gint w, h;
4611
4612   if (!gtk_widget_has_focus (widget))
4613     return;
4614
4615   w = gdk_window_get_width (tree_view->priv->bin_window) - 2;
4616   h = gdk_window_get_height (tree_view->priv->bin_window) - 2;
4617
4618   if (w > 0 && h > 0)
4619     gtk_paint_focus (gtk_widget_get_style (widget),
4620                      cr,
4621                      gtk_widget_get_state (widget),
4622                      widget,
4623                      NULL,
4624                      1, 1, w, h);
4625 }
4626
4627 typedef enum {
4628   GTK_TREE_VIEW_GRID_LINE,
4629   GTK_TREE_VIEW_TREE_LINE,
4630   GTK_TREE_VIEW_FOREGROUND_LINE
4631 } GtkTreeViewLineType;
4632
4633 static void
4634 gtk_tree_view_draw_line (GtkTreeView         *tree_view,
4635                          cairo_t             *cr,
4636                          GtkTreeViewLineType  type,
4637                          int                  x1,
4638                          int                  y1,
4639                          int                  x2,
4640                          int                  y2)
4641 {
4642   cairo_save (cr);
4643
4644   switch (type)
4645     {
4646     case GTK_TREE_VIEW_TREE_LINE:
4647       cairo_set_source_rgb (cr, 0, 0, 0);
4648       cairo_set_line_width (cr, tree_view->priv->tree_line_width);
4649       if (tree_view->priv->tree_line_dashes[0])
4650         cairo_set_dash (cr,
4651                         tree_view->priv->tree_line_dashes,
4652                         2, 0.5);
4653       break;
4654     case GTK_TREE_VIEW_GRID_LINE:
4655       cairo_set_source_rgb (cr, 0, 0, 0);
4656       cairo_set_line_width (cr, tree_view->priv->grid_line_width);
4657       if (tree_view->priv->grid_line_dashes[0])
4658         cairo_set_dash (cr,
4659                         tree_view->priv->grid_line_dashes,
4660                         2, 0.5);
4661       break;
4662     default:
4663       g_assert_not_reached ();
4664       /* fall through */
4665     case GTK_TREE_VIEW_FOREGROUND_LINE:
4666       cairo_set_line_width (cr, 1.0);
4667       gdk_cairo_set_source_color (cr,
4668                                   &gtk_widget_get_style (GTK_WIDGET (tree_view))->fg[gtk_widget_get_state (GTK_WIDGET (tree_view))]);
4669       break;
4670     }
4671
4672   cairo_move_to (cr, x1 + 0.5, y1 + 0.5);
4673   cairo_line_to (cr, x2 + 0.5, y2 + 0.5);
4674   cairo_stroke (cr);
4675
4676   cairo_restore (cr);
4677 }
4678
4679 static void
4680 gtk_tree_view_draw_grid_lines (GtkTreeView    *tree_view,
4681                                cairo_t        *cr,
4682                                gint            n_visible_columns)
4683 {
4684   GList *list = tree_view->priv->columns;
4685   gint i = 0;
4686   gint current_x = 0;
4687
4688   if (tree_view->priv->grid_lines != GTK_TREE_VIEW_GRID_LINES_VERTICAL
4689       && tree_view->priv->grid_lines != GTK_TREE_VIEW_GRID_LINES_BOTH)
4690     return;
4691
4692   /* Only draw the lines for visible rows and columns */
4693   for (list = tree_view->priv->columns; list; list = list->next, i++)
4694     {
4695       GtkTreeViewColumn *column = list->data;
4696
4697       /* We don't want a line for the last column */
4698       if (i == n_visible_columns - 1)
4699         break;
4700
4701       if (!gtk_tree_view_column_get_visible (column))
4702         continue;
4703
4704       current_x += gtk_tree_view_column_get_width (column);
4705
4706       gtk_tree_view_draw_line (tree_view, cr,
4707                                GTK_TREE_VIEW_GRID_LINE,
4708                                current_x - 1, 0,
4709                                current_x - 1, tree_view->priv->height);
4710     }
4711 }
4712
4713 /* Warning: Very scary function.
4714  * Modify at your own risk
4715  *
4716  * KEEP IN SYNC WITH gtk_tree_view_create_row_drag_icon()!
4717  * FIXME: It's not...
4718  */
4719 static gboolean
4720 gtk_tree_view_bin_draw (GtkWidget      *widget,
4721                         cairo_t        *cr)
4722 {
4723   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
4724   GtkTreePath *path;
4725   GtkStyle *style;
4726   GtkRBTree *tree;
4727   GList *list;
4728   GtkRBNode *node;
4729   GtkRBNode *cursor = NULL;
4730   GtkRBTree *cursor_tree = NULL;
4731   GtkRBNode *drag_highlight = NULL;
4732   GtkRBTree *drag_highlight_tree = NULL;
4733   GtkTreeIter iter;
4734   gint new_y;
4735   gint y_offset, cell_offset;
4736   gint max_height;
4737   gint depth;
4738   GdkRectangle background_area;
4739   GdkRectangle cell_area;
4740   GdkRectangle clip;
4741   guint flags;
4742   gint highlight_x;
4743   gint expander_cell_width;
4744   gint bin_window_width;
4745   gint bin_window_height;
4746   GtkTreePath *cursor_path;
4747   GtkTreePath *drag_dest_path;
4748   GList *first_column, *last_column;
4749   gint vertical_separator;
4750   gint horizontal_separator;
4751   gint focus_line_width;
4752   gboolean allow_rules;
4753   gboolean has_can_focus_cell;
4754   gboolean rtl;
4755   gint n_visible_columns;
4756   gint pointer_x, pointer_y;
4757   gint grid_line_width;
4758   gboolean got_pointer = FALSE;
4759   gboolean draw_vgrid_lines, draw_hgrid_lines;
4760
4761   rtl = (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL);
4762
4763   gtk_widget_style_get (widget,
4764                         "horizontal-separator", &horizontal_separator,
4765                         "vertical-separator", &vertical_separator,
4766                         "allow-rules", &allow_rules,
4767                         "focus-line-width", &focus_line_width,
4768                         NULL);
4769
4770   if (tree_view->priv->tree == NULL)
4771     {
4772       draw_empty_focus (tree_view, cr);
4773       return TRUE;
4774     }
4775
4776   style = gtk_widget_get_style (widget);
4777
4778   bin_window_width = gdk_window_get_width (tree_view->priv->bin_window);
4779   bin_window_height = gdk_window_get_height (tree_view->priv->bin_window);
4780   cairo_rectangle (cr, 0, 0, bin_window_width, bin_window_height);
4781   cairo_clip (cr);
4782   if (!gdk_cairo_get_clip_rectangle (cr, &clip))
4783     return TRUE;
4784
4785   new_y = TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, clip.y);
4786
4787   if (new_y < 0)
4788     new_y = 0;
4789   y_offset = -_gtk_rbtree_find_offset (tree_view->priv->tree, new_y, &tree, &node);
4790
4791   if (tree_view->priv->height < bin_window_height)
4792     {
4793       gtk_paint_flat_box (style,
4794                           cr,
4795                           gtk_widget_get_state (widget),
4796                           GTK_SHADOW_NONE,
4797                           widget,
4798                           "cell_even",
4799                           0, tree_view->priv->height,
4800                           bin_window_width,
4801                           bin_window_height - tree_view->priv->height);
4802     }
4803
4804   if (node == NULL)
4805     return TRUE;
4806
4807   /* find the path for the node */
4808   path = _gtk_tree_view_find_path ((GtkTreeView *)widget,
4809                                    tree,
4810                                    node);
4811   gtk_tree_model_get_iter (tree_view->priv->model,
4812                            &iter,
4813                            path);
4814   depth = gtk_tree_path_get_depth (path);
4815   gtk_tree_path_free (path);
4816
4817   cursor_path = NULL;
4818   drag_dest_path = NULL;
4819
4820   if (tree_view->priv->cursor)
4821     cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
4822
4823   if (cursor_path)
4824     _gtk_tree_view_find_node (tree_view, cursor_path,
4825                               &cursor_tree, &cursor);
4826
4827   if (tree_view->priv->drag_dest_row)
4828     drag_dest_path = gtk_tree_row_reference_get_path (tree_view->priv->drag_dest_row);
4829
4830   if (drag_dest_path)
4831     _gtk_tree_view_find_node (tree_view, drag_dest_path,
4832                               &drag_highlight_tree, &drag_highlight);
4833
4834   draw_vgrid_lines =
4835     tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_VERTICAL
4836     || tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_BOTH;
4837   draw_hgrid_lines =
4838     tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_HORIZONTAL
4839     || tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_BOTH;
4840
4841   if (draw_vgrid_lines || draw_hgrid_lines)
4842     gtk_widget_style_get (widget, "grid-line-width", &grid_line_width, NULL);
4843
4844   n_visible_columns = 0;
4845   for (list = tree_view->priv->columns; list; list = list->next)
4846     {
4847       if (!gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (list->data)))
4848         continue;
4849       n_visible_columns ++;
4850     }
4851
4852   /* Find the last column */
4853   for (last_column = g_list_last (tree_view->priv->columns);
4854        last_column &&
4855        !(gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (last_column->data)));
4856        last_column = last_column->prev)
4857     ;
4858
4859   /* and the first */
4860   for (first_column = g_list_first (tree_view->priv->columns);
4861        first_column &&
4862        !(gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (first_column->data)));
4863        first_column = first_column->next)
4864     ;
4865
4866   /* Actually process the expose event.  To do this, we want to
4867    * start at the first node of the event, and walk the tree in
4868    * order, drawing each successive node.
4869    */
4870
4871   do
4872     {
4873       gboolean parity;
4874       gboolean is_separator = FALSE;
4875       gboolean is_first = FALSE;
4876       gboolean is_last = FALSE;
4877
4878       is_separator = row_is_separator (tree_view, &iter, NULL);
4879
4880       max_height = gtk_tree_view_get_row_height (tree_view, node);
4881
4882       cell_offset = 0;
4883       highlight_x = 0; /* should match x coord of first cell */
4884       expander_cell_width = 0;
4885
4886       background_area.y = y_offset + clip.y;
4887       background_area.height = max_height;
4888
4889       flags = 0;
4890
4891       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PRELIT))
4892         flags |= GTK_CELL_RENDERER_PRELIT;
4893
4894       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
4895         flags |= GTK_CELL_RENDERER_SELECTED;
4896
4897       parity = _gtk_rbtree_node_find_parity (tree, node);
4898
4899       /* we *need* to set cell data on all cells before the call
4900        * to _has_can_focus_cell, else _has_can_focus_cell() does not
4901        * return a correct value.
4902        */
4903       for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
4904            list;
4905            list = (rtl ? list->prev : list->next))
4906         {
4907           GtkTreeViewColumn *column = list->data;
4908           gtk_tree_view_column_cell_set_cell_data (column,
4909                                                    tree_view->priv->model,
4910                                                    &iter,
4911                                                    GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT),
4912                                                    node->children?TRUE:FALSE);
4913         }
4914
4915       has_can_focus_cell = gtk_tree_view_has_can_focus_cell (tree_view);
4916
4917       for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
4918            list;
4919            list = (rtl ? list->prev : list->next))
4920         {
4921           GtkTreeViewColumn *column = list->data;
4922           const gchar *detail = NULL;
4923           gchar new_detail[128];
4924           gint width;
4925           GtkStateType state;
4926           gboolean draw_focus;
4927
4928           if (!gtk_tree_view_column_get_visible (column))
4929             continue;
4930
4931           width = gtk_tree_view_column_get_width (column);
4932
4933           if (cell_offset > clip.x + clip.width ||
4934               cell_offset + width < clip.x)
4935             {
4936               cell_offset += width;
4937               continue;
4938             }
4939
4940           if (gtk_tree_view_column_get_sort_indicator (column))
4941             flags |= GTK_CELL_RENDERER_SORTED;
4942           else
4943             flags &= ~GTK_CELL_RENDERER_SORTED;
4944
4945           if (cursor == node)
4946             flags |= GTK_CELL_RENDERER_FOCUSED;
4947           else
4948             flags &= ~GTK_CELL_RENDERER_FOCUSED;
4949
4950           background_area.x = cell_offset;
4951           background_area.width = width;
4952
4953           cell_area = background_area;
4954           cell_area.y += vertical_separator / 2;
4955           cell_area.x += horizontal_separator / 2;
4956           cell_area.height -= vertical_separator;
4957           cell_area.width -= horizontal_separator;
4958
4959           if (draw_vgrid_lines)
4960             {
4961               if (list == first_column)
4962                 {
4963                   cell_area.width -= grid_line_width / 2;
4964                 }
4965               else if (list == last_column)
4966                 {
4967                   cell_area.x += grid_line_width / 2;
4968                   cell_area.width -= grid_line_width / 2;
4969                 }
4970               else
4971                 {
4972                   cell_area.x += grid_line_width / 2;
4973                   cell_area.width -= grid_line_width;
4974                 }
4975             }
4976
4977           if (draw_hgrid_lines)
4978             {
4979               cell_area.y += grid_line_width / 2;
4980               cell_area.height -= grid_line_width;
4981             }
4982
4983           if (!gdk_rectangle_intersect (&clip, &background_area, NULL))
4984             {
4985               cell_offset += gtk_tree_view_column_get_width (column);
4986               continue;
4987             }
4988
4989           gtk_tree_view_column_cell_set_cell_data (column,
4990                                                    tree_view->priv->model,
4991                                                    &iter,
4992                                                    GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT),
4993                                                    node->children?TRUE:FALSE);
4994
4995           /* Select the detail for drawing the cell.  relevant
4996            * factors are parity, sortedness, and whether to
4997            * display rules.
4998            */
4999           if (allow_rules && tree_view->priv->has_rules)
5000             {
5001               if ((flags & GTK_CELL_RENDERER_SORTED) &&
5002                   n_visible_columns >= 3)
5003                 {
5004                   if (parity)
5005                     detail = "cell_odd_ruled_sorted";
5006                   else
5007                     detail = "cell_even_ruled_sorted";
5008                 }
5009               else
5010                 {
5011                   if (parity)
5012                     detail = "cell_odd_ruled";
5013                   else
5014                     detail = "cell_even_ruled";
5015                 }
5016             }
5017           else
5018             {
5019               if ((flags & GTK_CELL_RENDERER_SORTED) &&
5020                   n_visible_columns >= 3)
5021                 {
5022                   if (parity)
5023                     detail = "cell_odd_sorted";
5024                   else
5025                     detail = "cell_even_sorted";
5026                 }
5027               else
5028                 {
5029                   if (parity)
5030                     detail = "cell_odd";
5031                   else
5032                     detail = "cell_even";
5033                 }
5034             }
5035
5036           g_assert (detail);
5037
5038           if (gtk_widget_get_state (widget) == GTK_STATE_INSENSITIVE)
5039             state = GTK_STATE_INSENSITIVE;
5040           else if (flags & GTK_CELL_RENDERER_SELECTED)
5041             state = GTK_STATE_SELECTED;
5042           else
5043             state = GTK_STATE_NORMAL;
5044
5045           if (node == cursor && has_can_focus_cell
5046               && ((column == tree_view->priv->focus_column
5047                    && tree_view->priv->draw_keyfocus &&
5048                    gtk_widget_has_focus (widget))
5049                   || (column == tree_view->priv->edited_column)))
5050             draw_focus = TRUE;
5051           else
5052             draw_focus = FALSE;
5053
5054           /* Draw background */
5055           is_first = (rtl ? !list->next : !list->prev);
5056           is_last = (rtl ? !list->prev : !list->next);
5057
5058           /* (I don't like the snprintfs either, but couldn't find a
5059            * less messy way).
5060            */
5061           if (is_first && is_last)
5062             g_snprintf (new_detail, 127, "%s", detail);
5063           else if (is_first)
5064             g_snprintf (new_detail, 127, "%s_start", detail);
5065           else if (is_last)
5066             g_snprintf (new_detail, 127, "%s_end", detail);
5067           else
5068             g_snprintf (new_detail, 127, "%s_middle", detail);
5069
5070           gtk_paint_flat_box (style,
5071                               cr,
5072                               state,
5073                               GTK_SHADOW_NONE,
5074                               widget,
5075                               new_detail,
5076                               background_area.x,
5077                               background_area.y,
5078                               background_area.width,
5079                               background_area.height);
5080
5081           if (gtk_tree_view_is_expander_column (tree_view, column))
5082             {
5083               if (!rtl)
5084                 cell_area.x += (depth - 1) * tree_view->priv->level_indentation;
5085               cell_area.width -= (depth - 1) * tree_view->priv->level_indentation;
5086
5087               if (gtk_tree_view_draw_expanders (tree_view))
5088                 {
5089                   if (!rtl)
5090                     cell_area.x += depth * tree_view->priv->expander_size;
5091                   cell_area.width -= depth * tree_view->priv->expander_size;
5092                 }
5093
5094               /* If we have an expander column, the highlight underline
5095                * starts with that column, so that it indicates which
5096                * level of the tree we're dropping at.
5097                */
5098               highlight_x = cell_area.x;
5099               expander_cell_width = cell_area.width;
5100
5101               if (is_separator)
5102                 gtk_paint_hline (style,
5103                                  cr,
5104                                  state,
5105                                  widget,
5106                                  NULL,
5107                                  cell_area.x,
5108                                  cell_area.x + cell_area.width,
5109                                  cell_area.y + cell_area.height / 2);
5110               else
5111                 _gtk_tree_view_column_cell_render (column,
5112                                                    cr,
5113                                                    &background_area,
5114                                                    &cell_area,
5115                                                    flags,
5116                                                    draw_focus);
5117               if (gtk_tree_view_draw_expanders (tree_view)
5118                   && (node->flags & GTK_RBNODE_IS_PARENT) == GTK_RBNODE_IS_PARENT)
5119                 {
5120                   if (!got_pointer)
5121                     {
5122                       gdk_window_get_pointer (tree_view->priv->bin_window,
5123                                               &pointer_x, &pointer_y, NULL);
5124                       got_pointer = TRUE;
5125                     }
5126
5127                   gtk_tree_view_draw_arrow (GTK_TREE_VIEW (widget),
5128                                             cr,
5129                                             tree,
5130                                             node,
5131                                             pointer_x, pointer_y);
5132                 }
5133             }
5134           else
5135             {
5136               if (is_separator)
5137                 gtk_paint_hline (style,
5138                                  cr,
5139                                  state,
5140                                  widget,
5141                                  NULL,
5142                                  cell_area.x,
5143                                  cell_area.x + cell_area.width,
5144                                  cell_area.y + cell_area.height / 2);
5145               else
5146                 _gtk_tree_view_column_cell_render (column,
5147                                                    cr,
5148                                                    &background_area,
5149                                                    &cell_area,
5150                                                    flags,
5151                                                    draw_focus);
5152             }
5153
5154           if (draw_hgrid_lines)
5155             {
5156               if (background_area.y > 0)
5157                 gtk_tree_view_draw_line (tree_view, cr,
5158                                          GTK_TREE_VIEW_GRID_LINE,
5159                                          background_area.x, background_area.y,
5160                                          background_area.x + background_area.width,
5161                                          background_area.y);
5162
5163               if (y_offset + max_height >= clip.height)
5164                 gtk_tree_view_draw_line (tree_view, cr,
5165                                          GTK_TREE_VIEW_GRID_LINE,
5166                                          background_area.x, background_area.y + max_height,
5167                                          background_area.x + background_area.width,
5168                                          background_area.y + max_height);
5169             }
5170
5171           if (gtk_tree_view_is_expander_column (tree_view, column) &&
5172               tree_view->priv->tree_lines_enabled)
5173             {
5174               gint x = background_area.x;
5175               gint mult = rtl ? -1 : 1;
5176               gint y0 = background_area.y;
5177               gint y1 = background_area.y + background_area.height/2;
5178               gint y2 = background_area.y + background_area.height;
5179
5180               if (rtl)
5181                 x += background_area.width - 1;
5182
5183               if ((node->flags & GTK_RBNODE_IS_PARENT) == GTK_RBNODE_IS_PARENT
5184                   && depth > 1)
5185                 {
5186                   gtk_tree_view_draw_line (tree_view, cr,
5187                                            GTK_TREE_VIEW_TREE_LINE,
5188                                            x + tree_view->priv->expander_size * (depth - 1.5) * mult,
5189                                            y1,
5190                                            x + tree_view->priv->expander_size * (depth - 1.1) * mult,
5191                                            y1);
5192                 }
5193               else if (depth > 1)
5194                 {
5195                   gtk_tree_view_draw_line (tree_view, cr,
5196                                            GTK_TREE_VIEW_TREE_LINE,
5197                                            x + tree_view->priv->expander_size * (depth - 1.5) * mult,
5198                                            y1,
5199                                            x + tree_view->priv->expander_size * (depth - 0.5) * mult,
5200                                            y1);
5201                 }
5202
5203               if (depth > 1)
5204                 {
5205                   gint i;
5206                   GtkRBNode *tmp_node;
5207                   GtkRBTree *tmp_tree;
5208
5209                   if (!_gtk_rbtree_next (tree, node))
5210                     gtk_tree_view_draw_line (tree_view, cr,
5211                                              GTK_TREE_VIEW_TREE_LINE,
5212                                              x + tree_view->priv->expander_size * (depth - 1.5) * mult,
5213                                              y0,
5214                                              x + tree_view->priv->expander_size * (depth - 1.5) * mult,
5215                                              y1);
5216                   else
5217                     gtk_tree_view_draw_line (tree_view, cr,
5218                                              GTK_TREE_VIEW_TREE_LINE,
5219                                              x + tree_view->priv->expander_size * (depth - 1.5) * mult,
5220                                              y0,
5221                                              x + tree_view->priv->expander_size * (depth - 1.5) * mult,
5222                                              y2);
5223
5224                   tmp_node = tree->parent_node;
5225                   tmp_tree = tree->parent_tree;
5226
5227                   for (i = depth - 2; i > 0; i--)
5228                     {
5229                       if (_gtk_rbtree_next (tmp_tree, tmp_node))
5230                         gtk_tree_view_draw_line (tree_view, cr,
5231                                                  GTK_TREE_VIEW_TREE_LINE,
5232                                                  x + tree_view->priv->expander_size * (i - 0.5) * mult,
5233                                                  y0,
5234                                                  x + tree_view->priv->expander_size * (i - 0.5) * mult,
5235                                                  y2);
5236
5237                       tmp_node = tmp_tree->parent_node;
5238                       tmp_tree = tmp_tree->parent_tree;
5239                     }
5240                 }
5241             }
5242
5243           cell_offset += gtk_tree_view_column_get_width (column);
5244         }
5245
5246       if (node == drag_highlight)
5247         {
5248           /* Draw indicator for the drop
5249            */
5250           gint highlight_y = -1;
5251           GtkRBTree *tree = NULL;
5252           GtkRBNode *node = NULL;
5253
5254           switch (tree_view->priv->drag_dest_pos)
5255             {
5256             case GTK_TREE_VIEW_DROP_BEFORE:
5257               highlight_y = background_area.y - 1;
5258               if (highlight_y < 0)
5259                       highlight_y = 0;
5260               break;
5261
5262             case GTK_TREE_VIEW_DROP_AFTER:
5263               highlight_y = background_area.y + background_area.height - 1;
5264               break;
5265
5266             case GTK_TREE_VIEW_DROP_INTO_OR_BEFORE:
5267             case GTK_TREE_VIEW_DROP_INTO_OR_AFTER:
5268               _gtk_tree_view_find_node (tree_view, drag_dest_path, &tree, &node);
5269
5270               if (tree == NULL)
5271                 break;
5272
5273               gtk_paint_focus (style,
5274                                cr,
5275                                gtk_widget_get_state (widget),
5276                                widget,
5277                                (is_first
5278                                 ? (is_last ? "treeview-drop-indicator" : "treeview-drop-indicator-left" )
5279                                 : (is_last ? "treeview-drop-indicator-right" : "tree-view-drop-indicator-middle" )),
5280                                 0, gtk_tree_view_get_row_y_offset (tree_view, tree, node)
5281                                    - focus_line_width / 2,
5282                                 gdk_window_get_width (tree_view->priv->bin_window),
5283                                 gtk_tree_view_get_row_height (tree_view, node)
5284                                    - focus_line_width + 1);
5285               break;
5286             }
5287
5288           if (highlight_y >= 0)
5289             {
5290               gtk_tree_view_draw_line (tree_view, cr,
5291                                        GTK_TREE_VIEW_FOREGROUND_LINE,
5292                                        rtl ? highlight_x + expander_cell_width : highlight_x,
5293                                        highlight_y,
5294                                        rtl ? 0 : bin_window_width,
5295                                        highlight_y);
5296             }
5297         }
5298
5299       /* draw the big row-spanning focus rectangle, if needed */
5300       if (!has_can_focus_cell && node == cursor &&
5301           tree_view->priv->draw_keyfocus &&
5302           gtk_widget_has_focus (widget))
5303         {
5304           gint tmp_y, tmp_height;
5305           GtkStateType focus_rect_state;
5306
5307           focus_rect_state =
5308             flags & GTK_CELL_RENDERER_SELECTED ? GTK_STATE_SELECTED :
5309             (flags & GTK_CELL_RENDERER_PRELIT ? GTK_STATE_PRELIGHT :
5310              (flags & GTK_CELL_RENDERER_INSENSITIVE ? GTK_STATE_INSENSITIVE :
5311               GTK_STATE_NORMAL));
5312
5313           if (draw_hgrid_lines)
5314             {
5315               tmp_y = gtk_tree_view_get_row_y_offset (tree_view, tree, node) + grid_line_width / 2;
5316               tmp_height = gtk_tree_view_get_row_height (tree_view, node) - grid_line_width;
5317             }
5318           else
5319             {
5320               tmp_y = gtk_tree_view_get_row_y_offset (tree_view, tree, node);
5321               tmp_height = gtk_tree_view_get_row_height (tree_view, node);
5322             }
5323
5324           gtk_paint_focus (style,
5325                            cr,
5326                            focus_rect_state,
5327                            widget,
5328                            (is_first
5329                             ? (is_last ? "treeview" : "treeview-left" )
5330                             : (is_last ? "treeview-right" : "treeview-middle" )),
5331                            0, tmp_y,
5332                            gdk_window_get_width (tree_view->priv->bin_window),
5333                            tmp_height);
5334         }
5335
5336       y_offset += max_height;
5337       if (node->children)
5338         {
5339           GtkTreeIter parent = iter;
5340           gboolean has_child;
5341
5342           tree = node->children;
5343           node = tree->root;
5344
5345           g_assert (node != tree->nil);
5346
5347           while (node->left != tree->nil)
5348             node = node->left;
5349           has_child = gtk_tree_model_iter_children (tree_view->priv->model,
5350                                                     &iter,
5351                                                     &parent);
5352           depth++;
5353
5354           /* Sanity Check! */
5355           TREE_VIEW_INTERNAL_ASSERT (has_child, FALSE);
5356         }
5357       else
5358         {
5359           gboolean done = FALSE;
5360
5361           do
5362             {
5363               node = _gtk_rbtree_next (tree, node);
5364               if (node != NULL)
5365                 {
5366                   gboolean has_next = gtk_tree_model_iter_next (tree_view->priv->model, &iter);
5367                   done = TRUE;
5368
5369                   /* Sanity Check! */
5370                   TREE_VIEW_INTERNAL_ASSERT (has_next, FALSE);
5371                 }
5372               else
5373                 {
5374                   GtkTreeIter parent_iter = iter;
5375                   gboolean has_parent;
5376
5377                   node = tree->parent_node;
5378                   tree = tree->parent_tree;
5379                   if (tree == NULL)
5380                     /* we should go to done to free some memory */
5381                     goto done;
5382                   has_parent = gtk_tree_model_iter_parent (tree_view->priv->model,
5383                                                            &iter,
5384                                                            &parent_iter);
5385                   depth--;
5386
5387                   /* Sanity check */
5388                   TREE_VIEW_INTERNAL_ASSERT (has_parent, FALSE);
5389                 }
5390             }
5391           while (!done);
5392         }
5393     }
5394   while (y_offset < clip.height);
5395
5396 done:
5397   gtk_tree_view_draw_grid_lines (tree_view, cr, n_visible_columns);
5398
5399   if (tree_view->priv->rubber_band_status == RUBBER_BAND_ACTIVE)
5400     gtk_tree_view_paint_rubber_band (tree_view, cr);
5401
5402   if (cursor_path)
5403     gtk_tree_path_free (cursor_path);
5404
5405   if (drag_dest_path)
5406     gtk_tree_path_free (drag_dest_path);
5407
5408   return FALSE;
5409 }
5410
5411 static gboolean
5412 gtk_tree_view_draw (GtkWidget *widget,
5413                     cairo_t   *cr)
5414 {
5415   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
5416   GtkWidget   *button;
5417
5418   if (gtk_cairo_should_draw_window (cr, tree_view->priv->bin_window))
5419     {
5420       GList *tmp_list;
5421
5422       cairo_save (cr);
5423
5424       gtk_cairo_transform_to_window (cr, widget, tree_view->priv->bin_window);
5425
5426       gtk_tree_view_bin_draw (widget, cr);
5427
5428       cairo_restore (cr);
5429
5430       /* We can't just chain up to Container::draw as it will try to send the
5431        * event to the headers, so we handle propagating it to our children
5432        * (eg. widgets being edited) ourselves.
5433        */
5434       tmp_list = tree_view->priv->children;
5435       while (tmp_list)
5436         {
5437           GtkTreeViewChild *child = tmp_list->data;
5438           tmp_list = tmp_list->next;
5439
5440           gtk_container_propagate_draw (GTK_CONTAINER (tree_view), child->widget, cr);
5441         }
5442     }
5443
5444   if (gtk_cairo_should_draw_window (cr, tree_view->priv->header_window))
5445     {
5446       GList *list;
5447
5448       for (list = tree_view->priv->columns; list != NULL; list = list->next)
5449         {
5450           GtkTreeViewColumn *column = list->data;
5451
5452           if (column == tree_view->priv->drag_column)
5453             continue;
5454
5455           if (gtk_tree_view_column_get_visible (column))
5456             {
5457               button = gtk_tree_view_column_get_button (column);
5458               gtk_container_propagate_draw (GTK_CONTAINER (tree_view),
5459                                             button, cr);
5460             }
5461         }
5462     }
5463
5464   if (tree_view->priv->drag_window &&
5465       gtk_cairo_should_draw_window (cr, tree_view->priv->drag_window))
5466     {
5467       button = gtk_tree_view_column_get_button (tree_view->priv->drag_column);
5468       gtk_container_propagate_draw (GTK_CONTAINER (tree_view),
5469                                     button, cr);
5470     }
5471
5472   return TRUE;
5473 }
5474
5475 enum
5476 {
5477   DROP_HOME,
5478   DROP_RIGHT,
5479   DROP_LEFT,
5480   DROP_END
5481 };
5482
5483 /* returns 0x1 when no column has been found -- yes it's hackish */
5484 static GtkTreeViewColumn *
5485 gtk_tree_view_get_drop_column (GtkTreeView       *tree_view,
5486                                GtkTreeViewColumn *column,
5487                                gint               drop_position)
5488 {
5489   GtkTreeViewColumn *left_column = NULL;
5490   GtkTreeViewColumn *cur_column = NULL;
5491   GList *tmp_list;
5492
5493   if (!gtk_tree_view_column_get_reorderable (column))
5494     return (GtkTreeViewColumn *)0x1;
5495
5496   switch (drop_position)
5497     {
5498       case DROP_HOME:
5499         /* find first column where we can drop */
5500         tmp_list = tree_view->priv->columns;
5501         if (column == GTK_TREE_VIEW_COLUMN (tmp_list->data))
5502           return (GtkTreeViewColumn *)0x1;
5503
5504         while (tmp_list)
5505           {
5506             g_assert (tmp_list);
5507
5508             cur_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
5509             tmp_list = tmp_list->next;
5510
5511             if (left_column &&
5512                 gtk_tree_view_column_get_visible (left_column) == FALSE)
5513               continue;
5514
5515             if (!tree_view->priv->column_drop_func)
5516               return left_column;
5517
5518             if (!tree_view->priv->column_drop_func (tree_view, column, left_column, cur_column, tree_view->priv->column_drop_func_data))
5519               {
5520                 left_column = cur_column;
5521                 continue;
5522               }
5523
5524             return left_column;
5525           }
5526
5527         if (!tree_view->priv->column_drop_func)
5528           return left_column;
5529
5530         if (tree_view->priv->column_drop_func (tree_view, column, left_column, NULL, tree_view->priv->column_drop_func_data))
5531           return left_column;
5532         else
5533           return (GtkTreeViewColumn *)0x1;
5534         break;
5535
5536       case DROP_RIGHT:
5537         /* find first column after column where we can drop */
5538         tmp_list = tree_view->priv->columns;
5539
5540         for (; tmp_list; tmp_list = tmp_list->next)
5541           if (GTK_TREE_VIEW_COLUMN (tmp_list->data) == column)
5542             break;
5543
5544         if (!tmp_list || !tmp_list->next)
5545           return (GtkTreeViewColumn *)0x1;
5546
5547         tmp_list = tmp_list->next;
5548         left_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
5549         tmp_list = tmp_list->next;
5550
5551         while (tmp_list)
5552           {
5553             g_assert (tmp_list);
5554
5555             cur_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
5556             tmp_list = tmp_list->next;
5557
5558             if (left_column &&
5559                 gtk_tree_view_column_get_visible (left_column) == FALSE)
5560               {
5561                 left_column = cur_column;
5562                 if (tmp_list)
5563                   tmp_list = tmp_list->next;
5564                 continue;
5565               }
5566
5567             if (!tree_view->priv->column_drop_func)
5568               return left_column;
5569
5570             if (!tree_view->priv->column_drop_func (tree_view, column, left_column, cur_column, tree_view->priv->column_drop_func_data))
5571               {
5572                 left_column = cur_column;
5573                 continue;
5574               }
5575
5576             return left_column;
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, NULL, tree_view->priv->column_drop_func_data))
5583           return left_column;
5584         else
5585           return (GtkTreeViewColumn *)0x1;
5586         break;
5587
5588       case DROP_LEFT:
5589         /* find first column before column where we can drop */
5590         tmp_list = tree_view->priv->columns;
5591
5592         for (; tmp_list; tmp_list = tmp_list->next)
5593           if (GTK_TREE_VIEW_COLUMN (tmp_list->data) == column)
5594             break;
5595
5596         if (!tmp_list || !tmp_list->prev)
5597           return (GtkTreeViewColumn *)0x1;
5598
5599         tmp_list = tmp_list->prev;
5600         cur_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
5601         tmp_list = tmp_list->prev;
5602
5603         while (tmp_list)
5604           {
5605             g_assert (tmp_list);
5606
5607             left_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
5608
5609             if (left_column &&
5610                 gtk_tree_view_column_get_visible (left_column) == FALSE)
5611               {
5612                 /*if (!tmp_list->prev)
5613                   return (GtkTreeViewColumn *)0x1;
5614                   */
5615 /*
5616                 cur_column = GTK_TREE_VIEW_COLUMN (tmp_list->prev->data);
5617                 tmp_list = tmp_list->prev->prev;
5618                 continue;*/
5619
5620                 cur_column = left_column;
5621                 if (tmp_list)
5622                   tmp_list = tmp_list->prev;
5623                 continue;
5624               }
5625
5626             if (!tree_view->priv->column_drop_func)
5627               return left_column;
5628
5629             if (tree_view->priv->column_drop_func (tree_view, column, left_column, cur_column, tree_view->priv->column_drop_func_data))
5630               return left_column;
5631
5632             cur_column = left_column;
5633             tmp_list = tmp_list->prev;
5634           }
5635
5636         if (!tree_view->priv->column_drop_func)
5637           return NULL;
5638
5639         if (tree_view->priv->column_drop_func (tree_view, column, NULL, cur_column, tree_view->priv->column_drop_func_data))
5640           return NULL;
5641         else
5642           return (GtkTreeViewColumn *)0x1;
5643         break;
5644
5645       case DROP_END:
5646         /* same as DROP_HOME case, but doing it backwards */
5647         tmp_list = g_list_last (tree_view->priv->columns);
5648         cur_column = NULL;
5649
5650         if (column == GTK_TREE_VIEW_COLUMN (tmp_list->data))
5651           return (GtkTreeViewColumn *)0x1;
5652
5653         while (tmp_list)
5654           {
5655             g_assert (tmp_list);
5656
5657             left_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
5658
5659             if (left_column &&
5660                 gtk_tree_view_column_get_visible (left_column) == FALSE)
5661               {
5662                 cur_column = left_column;
5663                 tmp_list = tmp_list->prev;
5664               }
5665
5666             if (!tree_view->priv->column_drop_func)
5667               return left_column;
5668
5669             if (tree_view->priv->column_drop_func (tree_view, column, left_column, cur_column, tree_view->priv->column_drop_func_data))
5670               return left_column;
5671
5672             cur_column = left_column;
5673             tmp_list = tmp_list->prev;
5674           }
5675
5676         if (!tree_view->priv->column_drop_func)
5677           return NULL;
5678
5679         if (tree_view->priv->column_drop_func (tree_view, column, NULL, cur_column, tree_view->priv->column_drop_func_data))
5680           return NULL;
5681         else
5682           return (GtkTreeViewColumn *)0x1;
5683         break;
5684     }
5685
5686   return (GtkTreeViewColumn *)0x1;
5687 }
5688
5689 static gboolean
5690 gtk_tree_view_key_press (GtkWidget   *widget,
5691                          GdkEventKey *event)
5692 {
5693   GtkTreeView *tree_view = (GtkTreeView *) widget;
5694   GtkWidget   *button;
5695
5696   if (tree_view->priv->rubber_band_status)
5697     {
5698       if (event->keyval == GDK_KEY_Escape)
5699         gtk_tree_view_stop_rubber_band (tree_view);
5700
5701       return TRUE;
5702     }
5703
5704   if (tree_view->priv->in_column_drag)
5705     {
5706       if (event->keyval == GDK_KEY_Escape)
5707         {
5708           tree_view->priv->cur_reorder = NULL;
5709           gtk_tree_view_button_release_drag_column (widget, NULL);
5710         }
5711       return TRUE;
5712     }
5713
5714   if (tree_view->priv->headers_visible)
5715     {
5716       GList *focus_column;
5717       gboolean rtl;
5718
5719       rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
5720
5721       for (focus_column = tree_view->priv->columns;
5722            focus_column;
5723            focus_column = focus_column->next)
5724         {
5725           GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN (focus_column->data);
5726
5727           button = gtk_tree_view_column_get_button (column);
5728           if (gtk_widget_has_focus (button))
5729             break;
5730         }
5731
5732       if (focus_column &&
5733           (event->state & GDK_SHIFT_MASK) && (event->state & GDK_MOD1_MASK) &&
5734           (event->keyval == GDK_KEY_Left || event->keyval == GDK_KEY_KP_Left
5735            || event->keyval == GDK_KEY_Right || event->keyval == GDK_KEY_KP_Right))
5736         {
5737           GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN (focus_column->data);
5738           gint max_width, min_width;
5739
5740           if (!gtk_tree_view_column_get_resizable (column))
5741             {
5742               gtk_widget_error_bell (widget);
5743               return TRUE;
5744             }
5745
5746           if (event->keyval == (rtl ? GDK_KEY_Right : GDK_KEY_Left)
5747               || event->keyval == (rtl ? GDK_KEY_KP_Right : GDK_KEY_KP_Left))
5748             {
5749               GtkRequisition button_req;
5750               gint old_width = _gtk_tree_view_column_get_resized_width (column);
5751               gint new_width;
5752
5753               button = gtk_tree_view_column_get_button (column);
5754
5755               gtk_widget_get_preferred_size (button, &button_req, NULL);
5756
5757               new_width = MAX (old_width, gtk_tree_view_column_get_width (column));
5758               new_width -= 2;
5759               if (new_width < 0)
5760                 new_width = 0;
5761
5762               _gtk_tree_view_column_set_resized_width (column, new_width);
5763
5764               min_width = gtk_tree_view_column_get_min_width (column);
5765               if (min_width == -1)
5766                 new_width = MAX (button_req.width, new_width);
5767               else
5768                 {
5769                   new_width = MAX (min_width, new_width);
5770                 }
5771
5772               max_width = gtk_tree_view_column_get_max_width (column);
5773               if (max_width != -1)
5774                 new_width = MIN (new_width, max_width);
5775
5776               _gtk_tree_view_column_set_use_resized_width (column, TRUE);
5777
5778               if (new_width != old_width)
5779                 {
5780                   _gtk_tree_view_column_set_resized_width (column, new_width);
5781                   gtk_widget_queue_resize (widget);
5782                 }
5783               else
5784                 gtk_widget_error_bell (widget);
5785             }
5786           else if (event->keyval == (rtl ? GDK_KEY_Left : GDK_KEY_Right)
5787                    || event->keyval == (rtl ? GDK_KEY_KP_Left : GDK_KEY_KP_Right))
5788             {
5789               gint old_width = _gtk_tree_view_column_get_resized_width (column);
5790               gint new_width;
5791
5792               new_width = MAX (old_width, gtk_tree_view_column_get_width (column));
5793               new_width += 2;
5794
5795               max_width = gtk_tree_view_column_get_max_width (column);
5796               if (max_width != -1)
5797                 new_width = MIN (new_width, max_width);
5798
5799               _gtk_tree_view_column_set_use_resized_width (column, TRUE);
5800
5801               if (new_width != old_width)
5802                 {
5803                   _gtk_tree_view_column_set_resized_width (column, new_width);
5804                   gtk_widget_queue_resize (widget);
5805                 }
5806               else
5807                 gtk_widget_error_bell (widget);
5808             }
5809
5810           return TRUE;
5811         }
5812
5813       if (focus_column &&
5814           (event->state & GDK_MOD1_MASK) &&
5815           (event->keyval == GDK_KEY_Left || event->keyval == GDK_KEY_KP_Left
5816            || event->keyval == GDK_KEY_Right || event->keyval == GDK_KEY_KP_Right
5817            || event->keyval == GDK_KEY_Home || event->keyval == GDK_KEY_KP_Home
5818            || event->keyval == GDK_KEY_End || event->keyval == GDK_KEY_KP_End))
5819         {
5820           GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN (focus_column->data);
5821
5822           if (event->keyval == (rtl ? GDK_KEY_Right : GDK_KEY_Left)
5823               || event->keyval == (rtl ? GDK_KEY_KP_Right : GDK_KEY_KP_Left))
5824             {
5825               GtkTreeViewColumn *col;
5826               col = gtk_tree_view_get_drop_column (tree_view, column, DROP_LEFT);
5827               if (col != (GtkTreeViewColumn *)0x1)
5828                 gtk_tree_view_move_column_after (tree_view, column, col);
5829               else
5830                 gtk_widget_error_bell (widget);
5831             }
5832           else if (event->keyval == (rtl ? GDK_KEY_Left : GDK_KEY_Right)
5833                    || event->keyval == (rtl ? GDK_KEY_KP_Left : GDK_KEY_KP_Right))
5834             {
5835               GtkTreeViewColumn *col;
5836               col = gtk_tree_view_get_drop_column (tree_view, column, DROP_RIGHT);
5837               if (col != (GtkTreeViewColumn *)0x1)
5838                 gtk_tree_view_move_column_after (tree_view, column, col);
5839               else
5840                 gtk_widget_error_bell (widget);
5841             }
5842           else if (event->keyval == GDK_KEY_Home || event->keyval == GDK_KEY_KP_Home)
5843             {
5844               GtkTreeViewColumn *col;
5845               col = gtk_tree_view_get_drop_column (tree_view, column, DROP_HOME);
5846               if (col != (GtkTreeViewColumn *)0x1)
5847                 gtk_tree_view_move_column_after (tree_view, column, col);
5848               else
5849                 gtk_widget_error_bell (widget);
5850             }
5851           else if (event->keyval == GDK_KEY_End || event->keyval == GDK_KEY_KP_End)
5852             {
5853               GtkTreeViewColumn *col;
5854               col = gtk_tree_view_get_drop_column (tree_view, column, DROP_END);
5855               if (col != (GtkTreeViewColumn *)0x1)
5856                 gtk_tree_view_move_column_after (tree_view, column, col);
5857               else
5858                 gtk_widget_error_bell (widget);
5859             }
5860
5861           return TRUE;
5862         }
5863     }
5864
5865   /* Chain up to the parent class.  It handles the keybindings. */
5866   if (GTK_WIDGET_CLASS (gtk_tree_view_parent_class)->key_press_event (widget, event))
5867     return TRUE;
5868
5869   if (tree_view->priv->search_entry_avoid_unhandled_binding)
5870     {
5871       tree_view->priv->search_entry_avoid_unhandled_binding = FALSE;
5872       return FALSE;
5873     }
5874
5875   /* We pass the event to the search_entry.  If its text changes, then we start
5876    * the typeahead find capabilities. */
5877   if (gtk_widget_has_focus (GTK_WIDGET (tree_view))
5878       && tree_view->priv->enable_search
5879       && !tree_view->priv->search_custom_entry_set)
5880     {
5881       GdkEvent *new_event;
5882       char *old_text;
5883       const char *new_text;
5884       gboolean retval;
5885       GdkScreen *screen;
5886       gboolean text_modified;
5887       gulong popup_menu_id;
5888
5889       gtk_tree_view_ensure_interactive_directory (tree_view);
5890
5891       /* Make a copy of the current text */
5892       old_text = g_strdup (gtk_entry_get_text (GTK_ENTRY (tree_view->priv->search_entry)));
5893       new_event = gdk_event_copy ((GdkEvent *) event);
5894       g_object_unref (((GdkEventKey *) new_event)->window);
5895       ((GdkEventKey *) new_event)->window = g_object_ref (gtk_widget_get_window (tree_view->priv->search_window));
5896       gtk_widget_realize (tree_view->priv->search_window);
5897
5898       popup_menu_id = g_signal_connect (tree_view->priv->search_entry,
5899                                         "popup-menu", G_CALLBACK (gtk_true),
5900                                         NULL);
5901
5902       /* Move the entry off screen */
5903       screen = gtk_widget_get_screen (GTK_WIDGET (tree_view));
5904       gtk_window_move (GTK_WINDOW (tree_view->priv->search_window),
5905                        gdk_screen_get_width (screen) + 1,
5906                        gdk_screen_get_height (screen) + 1);
5907       gtk_widget_show (tree_view->priv->search_window);
5908
5909       /* Send the event to the window.  If the preedit_changed signal is emitted
5910        * during this event, we will set priv->imcontext_changed  */
5911       tree_view->priv->imcontext_changed = FALSE;
5912       retval = gtk_widget_event (tree_view->priv->search_window, new_event);
5913       gdk_event_free (new_event);
5914       gtk_widget_hide (tree_view->priv->search_window);
5915
5916       g_signal_handler_disconnect (tree_view->priv->search_entry,
5917                                    popup_menu_id);
5918
5919       /* We check to make sure that the entry tried to handle the text, and that
5920        * the text has changed.
5921        */
5922       new_text = gtk_entry_get_text (GTK_ENTRY (tree_view->priv->search_entry));
5923       text_modified = strcmp (old_text, new_text) != 0;
5924       g_free (old_text);
5925       if (tree_view->priv->imcontext_changed ||    /* we're in a preedit */
5926           (retval && text_modified))               /* ...or the text was modified */
5927         {
5928           if (gtk_tree_view_real_start_interactive_search (tree_view,
5929                                                            gdk_event_get_device ((GdkEvent *) event),
5930                                                            FALSE))
5931             {
5932               gtk_widget_grab_focus (GTK_WIDGET (tree_view));
5933               return TRUE;
5934             }
5935           else
5936             {
5937               gtk_entry_set_text (GTK_ENTRY (tree_view->priv->search_entry), "");
5938               return FALSE;
5939             }
5940         }
5941     }
5942
5943   return FALSE;
5944 }
5945
5946 static gboolean
5947 gtk_tree_view_key_release (GtkWidget   *widget,
5948                            GdkEventKey *event)
5949 {
5950   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
5951
5952   if (tree_view->priv->rubber_band_status)
5953     return TRUE;
5954
5955   return GTK_WIDGET_CLASS (gtk_tree_view_parent_class)->key_release_event (widget, event);
5956 }
5957
5958 /* FIXME Is this function necessary? Can I get an enter_notify event
5959  * w/o either an expose event or a mouse motion event?
5960  */
5961 static gboolean
5962 gtk_tree_view_enter_notify (GtkWidget        *widget,
5963                             GdkEventCrossing *event)
5964 {
5965   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
5966   GtkRBTree *tree;
5967   GtkRBNode *node;
5968   gint new_y;
5969
5970   /* Sanity check it */
5971   if (event->window != tree_view->priv->bin_window)
5972     return FALSE;
5973
5974   if (tree_view->priv->tree == NULL)
5975     return FALSE;
5976
5977   if (event->mode == GDK_CROSSING_GRAB ||
5978       event->mode == GDK_CROSSING_GTK_GRAB ||
5979       event->mode == GDK_CROSSING_GTK_UNGRAB ||
5980       event->mode == GDK_CROSSING_STATE_CHANGED)
5981     return TRUE;
5982
5983   /* find the node internally */
5984   new_y = TREE_WINDOW_Y_TO_RBTREE_Y(tree_view, event->y);
5985   if (new_y < 0)
5986     new_y = 0;
5987   _gtk_rbtree_find_offset (tree_view->priv->tree, new_y, &tree, &node);
5988
5989   tree_view->priv->event_last_x = event->x;
5990   tree_view->priv->event_last_y = event->y;
5991
5992   if ((tree_view->priv->button_pressed_node == NULL) ||
5993       (tree_view->priv->button_pressed_node == node))
5994     prelight_or_select (tree_view, tree, node, event->x, event->y);
5995
5996   return TRUE;
5997 }
5998
5999 static gboolean
6000 gtk_tree_view_leave_notify (GtkWidget        *widget,
6001                             GdkEventCrossing *event)
6002 {
6003   GtkTreeView *tree_view;
6004
6005   if (event->mode == GDK_CROSSING_GRAB)
6006     return TRUE;
6007
6008   tree_view = GTK_TREE_VIEW (widget);
6009
6010   if (tree_view->priv->prelight_node)
6011     _gtk_tree_view_queue_draw_node (tree_view,
6012                                    tree_view->priv->prelight_tree,
6013                                    tree_view->priv->prelight_node,
6014                                    NULL);
6015
6016   tree_view->priv->event_last_x = -10000;
6017   tree_view->priv->event_last_y = -10000;
6018
6019   prelight_or_select (tree_view,
6020                       NULL, NULL,
6021                       -1000, -1000); /* coords not possibly over an arrow */
6022
6023   return TRUE;
6024 }
6025
6026
6027 static gint
6028 gtk_tree_view_focus_out (GtkWidget     *widget,
6029                          GdkEventFocus *event)
6030 {
6031   GtkTreeView *tree_view;
6032
6033   tree_view = GTK_TREE_VIEW (widget);
6034
6035   gtk_widget_queue_draw (widget);
6036
6037   /* destroy interactive search dialog */
6038   if (tree_view->priv->search_window)
6039     gtk_tree_view_search_dialog_hide (tree_view->priv->search_window, tree_view,
6040                                       gdk_event_get_device ((GdkEvent *) event));
6041
6042   return FALSE;
6043 }
6044
6045
6046 /* Incremental Reflow
6047  */
6048
6049 static void
6050 gtk_tree_view_node_queue_redraw (GtkTreeView *tree_view,
6051                                  GtkRBTree   *tree,
6052                                  GtkRBNode   *node)
6053 {
6054   GtkAllocation allocation;
6055   gint y;
6056
6057   y = _gtk_rbtree_node_find_offset (tree, node)
6058     - tree_view->priv->vadjustment->value
6059     + gtk_tree_view_get_effective_header_height (tree_view);
6060
6061   gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
6062   gtk_widget_queue_draw_area (GTK_WIDGET (tree_view),
6063                               0, y,
6064                               allocation.width,
6065                               GTK_RBNODE_GET_HEIGHT (node));
6066 }
6067
6068 static gboolean
6069 node_is_visible (GtkTreeView *tree_view,
6070                  GtkRBTree   *tree,
6071                  GtkRBNode   *node)
6072 {
6073   int y;
6074   int height;
6075
6076   y = _gtk_rbtree_node_find_offset (tree, node);
6077   height = gtk_tree_view_get_row_height (tree_view, node);
6078
6079   if (y >= tree_view->priv->vadjustment->value &&
6080       y + height <= (tree_view->priv->vadjustment->value
6081                      + tree_view->priv->vadjustment->page_size))
6082     return TRUE;
6083
6084   return FALSE;
6085 }
6086
6087 /* Returns TRUE if it updated the size
6088  */
6089 static gboolean
6090 validate_row (GtkTreeView *tree_view,
6091               GtkRBTree   *tree,
6092               GtkRBNode   *node,
6093               GtkTreeIter *iter,
6094               GtkTreePath *path)
6095 {
6096   GtkTreeViewColumn *column;
6097   GList *list, *first_column, *last_column;
6098   gint height = 0;
6099   gint horizontal_separator;
6100   gint vertical_separator;
6101   gint depth = gtk_tree_path_get_depth (path);
6102   gboolean retval = FALSE;
6103   gboolean is_separator = FALSE;
6104   gboolean draw_vgrid_lines, draw_hgrid_lines;
6105   gint focus_pad;
6106   gint grid_line_width;
6107   gboolean wide_separators;
6108   gint separator_height;
6109
6110   /* double check the row needs validating */
6111   if (! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) &&
6112       ! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
6113     return FALSE;
6114
6115   is_separator = row_is_separator (tree_view, iter, NULL);
6116
6117   gtk_widget_style_get (GTK_WIDGET (tree_view),
6118                         "focus-padding", &focus_pad,
6119                         "horizontal-separator", &horizontal_separator,
6120                         "vertical-separator", &vertical_separator,
6121                         "grid-line-width", &grid_line_width,
6122                         "wide-separators",  &wide_separators,
6123                         "separator-height", &separator_height,
6124                         NULL);
6125
6126   draw_vgrid_lines =
6127     tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_VERTICAL
6128     || tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_BOTH;
6129   draw_hgrid_lines =
6130     tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_HORIZONTAL
6131     || tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_BOTH;
6132
6133   for (last_column = g_list_last (tree_view->priv->columns);
6134        last_column &&
6135        !(gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (last_column->data)));
6136        last_column = last_column->prev)
6137     ;
6138
6139   for (first_column = g_list_first (tree_view->priv->columns);
6140        first_column &&
6141        !(gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (first_column->data)));
6142        first_column = first_column->next)
6143     ;
6144
6145   for (list = tree_view->priv->columns; list; list = list->next)
6146     {
6147       gint padding = 0;
6148       gint original_width;
6149       gint new_width;
6150       gint row_height;
6151
6152       column = list->data;
6153
6154       if (!gtk_tree_view_column_get_visible (column))
6155         continue;
6156
6157       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID) &&
6158           !_gtk_tree_view_column_cell_get_dirty (column))
6159         continue;
6160
6161       original_width = _gtk_tree_view_column_get_requested_width (column);
6162
6163       gtk_tree_view_column_cell_set_cell_data (column, tree_view->priv->model, iter,
6164                                                GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT),
6165                                                node->children?TRUE:FALSE);
6166       gtk_tree_view_column_cell_get_size (column,
6167                                           NULL, NULL, NULL,
6168                                           NULL, &row_height);
6169
6170       if (!is_separator)
6171         {
6172           row_height += vertical_separator;
6173           height = MAX (height, row_height);
6174           height = MAX (height, tree_view->priv->expander_size);
6175         }
6176       else
6177         {
6178           if (wide_separators)
6179             height = separator_height + 2 * focus_pad;
6180           else
6181             height = 2 + 2 * focus_pad;
6182         }
6183
6184       if (gtk_tree_view_is_expander_column (tree_view, column))
6185         {
6186           padding += horizontal_separator + (depth - 1) * tree_view->priv->level_indentation;
6187
6188           if (gtk_tree_view_draw_expanders (tree_view))
6189             padding += depth * tree_view->priv->expander_size;
6190         }
6191       else
6192         padding += horizontal_separator;
6193
6194       if (draw_vgrid_lines)
6195         {
6196           if (list->data == first_column || list->data == last_column)
6197             padding += grid_line_width / 2.0;
6198           else
6199             padding += grid_line_width;
6200         }
6201
6202       /* Update the padding for the column */
6203       _gtk_tree_view_column_push_padding (column, padding);
6204       new_width = _gtk_tree_view_column_get_requested_width (column);
6205
6206       if (new_width > original_width)
6207         retval = TRUE;
6208     }
6209
6210   if (draw_hgrid_lines)
6211     height += grid_line_width;
6212
6213   if (height != GTK_RBNODE_GET_HEIGHT (node))
6214     {
6215       retval = TRUE;
6216       _gtk_rbtree_node_set_height (tree, node, height);
6217     }
6218   _gtk_rbtree_node_mark_valid (tree, node);
6219   tree_view->priv->post_validation_flag = TRUE;
6220
6221   return retval;
6222 }
6223
6224
6225 static void
6226 validate_visible_area (GtkTreeView *tree_view)
6227 {
6228   GtkAllocation allocation;
6229   GtkTreePath *path = NULL;
6230   GtkTreePath *above_path = NULL;
6231   GtkTreeIter iter;
6232   GtkRBTree *tree = NULL;
6233   GtkRBNode *node = NULL;
6234   gboolean need_redraw = FALSE;
6235   gboolean size_changed = FALSE;
6236   gint total_height;
6237   gint area_above = 0;
6238   gint area_below = 0;
6239
6240   if (tree_view->priv->tree == NULL)
6241     return;
6242
6243   if (! GTK_RBNODE_FLAG_SET (tree_view->priv->tree->root, GTK_RBNODE_DESCENDANTS_INVALID) &&
6244       tree_view->priv->scroll_to_path == NULL)
6245     return;
6246
6247   gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
6248   total_height = allocation.height - gtk_tree_view_get_effective_header_height (tree_view);
6249
6250   if (total_height == 0)
6251     return;
6252
6253   /* First, we check to see if we need to scroll anywhere
6254    */
6255   if (tree_view->priv->scroll_to_path)
6256     {
6257       path = gtk_tree_row_reference_get_path (tree_view->priv->scroll_to_path);
6258       if (path && !_gtk_tree_view_find_node (tree_view, path, &tree, &node))
6259         {
6260           /* we are going to scroll, and will update dy */
6261           gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
6262           if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) ||
6263               GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
6264             {
6265               _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
6266               if (validate_row (tree_view, tree, node, &iter, path))
6267                 size_changed = TRUE;
6268             }
6269
6270           if (tree_view->priv->scroll_to_use_align)
6271             {
6272               gint height = gtk_tree_view_get_row_height (tree_view, node);
6273               area_above = (total_height - height) *
6274                 tree_view->priv->scroll_to_row_align;
6275               area_below = total_height - area_above - height;
6276               area_above = MAX (area_above, 0);
6277               area_below = MAX (area_below, 0);
6278             }
6279           else
6280             {
6281               /* two cases:
6282                * 1) row not visible
6283                * 2) row visible
6284                */
6285               gint dy;
6286               gint height = gtk_tree_view_get_row_height (tree_view, node);
6287
6288               dy = _gtk_rbtree_node_find_offset (tree, node);
6289
6290               if (dy >= tree_view->priv->vadjustment->value &&
6291                   dy + height <= (tree_view->priv->vadjustment->value
6292                                   + tree_view->priv->vadjustment->page_size))
6293                 {
6294                   /* row visible: keep the row at the same position */
6295                   area_above = dy - tree_view->priv->vadjustment->value;
6296                   area_below = (tree_view->priv->vadjustment->value +
6297                                 tree_view->priv->vadjustment->page_size)
6298                                - dy - height;
6299                 }
6300               else
6301                 {
6302                   /* row not visible */
6303                   if (dy >= 0
6304                       && dy + height <= tree_view->priv->vadjustment->page_size)
6305                     {
6306                       /* row at the beginning -- fixed */
6307                       area_above = dy;
6308                       area_below = tree_view->priv->vadjustment->page_size
6309                                    - area_above - height;
6310                     }
6311                   else if (dy >= (tree_view->priv->vadjustment->upper -
6312                                   tree_view->priv->vadjustment->page_size))
6313                     {
6314                       /* row at the end -- fixed */
6315                       area_above = dy - (tree_view->priv->vadjustment->upper -
6316                                    tree_view->priv->vadjustment->page_size);
6317                       area_below = tree_view->priv->vadjustment->page_size -
6318                                    area_above - height;
6319
6320                       if (area_below < 0)
6321                         {
6322                           area_above = tree_view->priv->vadjustment->page_size - height;
6323                           area_below = 0;
6324                         }
6325                     }
6326                   else
6327                     {
6328                       /* row somewhere in the middle, bring it to the top
6329                        * of the view
6330                        */
6331                       area_above = 0;
6332                       area_below = total_height - height;
6333                     }
6334                 }
6335             }
6336         }
6337       else
6338         /* the scroll to isn't valid; ignore it.
6339          */
6340         {
6341           if (tree_view->priv->scroll_to_path && !path)
6342             {
6343               gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
6344               tree_view->priv->scroll_to_path = NULL;
6345             }
6346           if (path)
6347             gtk_tree_path_free (path);
6348           path = NULL;
6349         }
6350     }
6351
6352   /* We didn't have a scroll_to set, so we just handle things normally
6353    */
6354   if (path == NULL)
6355     {
6356       gint offset;
6357
6358       offset = _gtk_rbtree_find_offset (tree_view->priv->tree,
6359                                         TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, 0),
6360                                         &tree, &node);
6361       if (node == NULL)
6362         {
6363           /* In this case, nothing has been validated */
6364           path = gtk_tree_path_new_first ();
6365           _gtk_tree_view_find_node (tree_view, path, &tree, &node);
6366         }
6367       else
6368         {
6369           path = _gtk_tree_view_find_path (tree_view, tree, node);
6370           total_height += offset;
6371         }
6372
6373       gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
6374
6375       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) ||
6376           GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
6377         {
6378           _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
6379           if (validate_row (tree_view, tree, node, &iter, path))
6380             size_changed = TRUE;
6381         }
6382       area_above = 0;
6383       area_below = total_height - gtk_tree_view_get_row_height (tree_view, node);
6384     }
6385
6386   above_path = gtk_tree_path_copy (path);
6387
6388   /* if we do not validate any row above the new top_row, we will make sure
6389    * that the row immediately above top_row has been validated. (if we do not
6390    * do this, _gtk_rbtree_find_offset will find the row above top_row, because
6391    * when invalidated that row's height will be zero. and this will mess up
6392    * scrolling).
6393    */
6394   if (area_above == 0)
6395     {
6396       GtkRBTree *tmptree;
6397       GtkRBNode *tmpnode;
6398
6399       _gtk_tree_view_find_node (tree_view, above_path, &tmptree, &tmpnode);
6400       _gtk_rbtree_prev_full (tmptree, tmpnode, &tmptree, &tmpnode);
6401
6402       if (tmpnode)
6403         {
6404           GtkTreePath *tmppath;
6405           GtkTreeIter tmpiter;
6406
6407           tmppath = _gtk_tree_view_find_path (tree_view, tmptree, tmpnode);
6408           gtk_tree_model_get_iter (tree_view->priv->model, &tmpiter, tmppath);
6409
6410           if (GTK_RBNODE_FLAG_SET (tmpnode, GTK_RBNODE_INVALID) ||
6411               GTK_RBNODE_FLAG_SET (tmpnode, GTK_RBNODE_COLUMN_INVALID))
6412             {
6413               _gtk_tree_view_queue_draw_node (tree_view, tmptree, tmpnode, NULL);
6414               if (validate_row (tree_view, tmptree, tmpnode, &tmpiter, tmppath))
6415                 size_changed = TRUE;
6416             }
6417
6418           gtk_tree_path_free (tmppath);
6419         }
6420     }
6421
6422   /* Now, we walk forwards and backwards, measuring rows. Unfortunately,
6423    * backwards is much slower then forward, as there is no iter_prev function.
6424    * We go forwards first in case we run out of tree.  Then we go backwards to
6425    * fill out the top.
6426    */
6427   while (node && area_below > 0)
6428     {
6429       if (node->children)
6430         {
6431           GtkTreeIter parent = iter;
6432           gboolean has_child;
6433
6434           tree = node->children;
6435           node = tree->root;
6436
6437           g_assert (node != tree->nil);
6438
6439           while (node->left != tree->nil)
6440             node = node->left;
6441           has_child = gtk_tree_model_iter_children (tree_view->priv->model,
6442                                                     &iter,
6443                                                     &parent);
6444           TREE_VIEW_INTERNAL_ASSERT_VOID (has_child);
6445           gtk_tree_path_down (path);
6446         }
6447       else
6448         {
6449           gboolean done = FALSE;
6450           do
6451             {
6452               node = _gtk_rbtree_next (tree, node);
6453               if (node != NULL)
6454                 {
6455                   gboolean has_next = gtk_tree_model_iter_next (tree_view->priv->model, &iter);
6456                   done = TRUE;
6457                   gtk_tree_path_next (path);
6458
6459                   /* Sanity Check! */
6460                   TREE_VIEW_INTERNAL_ASSERT_VOID (has_next);
6461                 }
6462               else
6463                 {
6464                   GtkTreeIter parent_iter = iter;
6465                   gboolean has_parent;
6466
6467                   node = tree->parent_node;
6468                   tree = tree->parent_tree;
6469                   if (tree == NULL)
6470                     break;
6471                   has_parent = gtk_tree_model_iter_parent (tree_view->priv->model,
6472                                                            &iter,
6473                                                            &parent_iter);
6474                   gtk_tree_path_up (path);
6475
6476                   /* Sanity check */
6477                   TREE_VIEW_INTERNAL_ASSERT_VOID (has_parent);
6478                 }
6479             }
6480           while (!done);
6481         }
6482
6483       if (!node)
6484         break;
6485
6486       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) ||
6487           GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
6488         {
6489           _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
6490           if (validate_row (tree_view, tree, node, &iter, path))
6491               size_changed = TRUE;
6492         }
6493
6494       area_below -= gtk_tree_view_get_row_height (tree_view, node);
6495     }
6496   gtk_tree_path_free (path);
6497
6498   /* If we ran out of tree, and have extra area_below left, we need to add it
6499    * to area_above */
6500   if (area_below > 0)
6501     area_above += area_below;
6502
6503   _gtk_tree_view_find_node (tree_view, above_path, &tree, &node);
6504
6505   /* We walk backwards */
6506   while (area_above > 0)
6507     {
6508       _gtk_rbtree_prev_full (tree, node, &tree, &node);
6509
6510       /* Always find the new path in the tree.  We cannot just assume
6511        * a gtk_tree_path_prev() is enough here, as there might be children
6512        * in between this node and the previous sibling node.  If this
6513        * appears to be a performance hotspot in profiles, we can look into
6514        * intrigate logic for keeping path, node and iter in sync like
6515        * we do for forward walks.  (Which will be hard because of the lacking
6516        * iter_prev).
6517        */
6518
6519       if (node == NULL)
6520         break;
6521
6522       gtk_tree_path_free (above_path);
6523       above_path = _gtk_tree_view_find_path (tree_view, tree, node);
6524
6525       gtk_tree_model_get_iter (tree_view->priv->model, &iter, above_path);
6526
6527       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) ||
6528           GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
6529         {
6530           _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
6531           if (validate_row (tree_view, tree, node, &iter, above_path))
6532             size_changed = TRUE;
6533         }
6534       area_above -= gtk_tree_view_get_row_height (tree_view, node);
6535     }
6536
6537   /* if we scrolled to a path, we need to set the dy here,
6538    * and sync the top row accordingly
6539    */
6540   if (tree_view->priv->scroll_to_path)
6541     {
6542       gtk_tree_view_set_top_row (tree_view, above_path, -area_above);
6543       gtk_tree_view_top_row_to_dy (tree_view);
6544
6545       need_redraw = TRUE;
6546     }
6547   else if (tree_view->priv->height <= tree_view->priv->vadjustment->page_size)
6548     {
6549       /* when we are not scrolling, we should never set dy to something
6550        * else than zero. we update top_row to be in sync with dy = 0.
6551        */
6552       gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment), 0);
6553       gtk_tree_view_dy_to_top_row (tree_view);
6554     }
6555   else if (tree_view->priv->vadjustment->value + tree_view->priv->vadjustment->page_size > tree_view->priv->height)
6556     {
6557       gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment), tree_view->priv->height - tree_view->priv->vadjustment->page_size);
6558       gtk_tree_view_dy_to_top_row (tree_view);
6559     }
6560   else
6561     gtk_tree_view_top_row_to_dy (tree_view);
6562
6563   /* update width/height and queue a resize */
6564   if (size_changed)
6565     {
6566       GtkRequisition requisition;
6567
6568       /* We temporarily guess a size, under the assumption that it will be the
6569        * same when we get our next size_allocate.  If we don't do this, we'll be
6570        * in an inconsistent state if we call top_row_to_dy. */
6571
6572       gtk_widget_get_preferred_size (GTK_WIDGET (tree_view),
6573                                      &requisition, NULL);
6574       tree_view->priv->hadjustment->upper = MAX (tree_view->priv->hadjustment->upper, (gfloat)requisition.width);
6575       tree_view->priv->vadjustment->upper = MAX (tree_view->priv->vadjustment->upper, (gfloat)requisition.height);
6576       gtk_adjustment_changed (tree_view->priv->hadjustment);
6577       gtk_adjustment_changed (tree_view->priv->vadjustment);
6578       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
6579     }
6580
6581   if (tree_view->priv->scroll_to_path)
6582     {
6583       gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
6584       tree_view->priv->scroll_to_path = NULL;
6585     }
6586
6587   if (above_path)
6588     gtk_tree_path_free (above_path);
6589
6590   if (tree_view->priv->scroll_to_column)
6591     {
6592       tree_view->priv->scroll_to_column = NULL;
6593     }
6594   if (need_redraw)
6595     gtk_widget_queue_draw (GTK_WIDGET (tree_view));
6596 }
6597
6598 static void
6599 initialize_fixed_height_mode (GtkTreeView *tree_view)
6600 {
6601   if (!tree_view->priv->tree)
6602     return;
6603
6604   if (tree_view->priv->fixed_height < 0)
6605     {
6606       GtkTreeIter iter;
6607       GtkTreePath *path;
6608
6609       GtkRBTree *tree = NULL;
6610       GtkRBNode *node = NULL;
6611
6612       tree = tree_view->priv->tree;
6613       node = tree->root;
6614
6615       path = _gtk_tree_view_find_path (tree_view, tree, node);
6616       gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
6617
6618       validate_row (tree_view, tree, node, &iter, path);
6619
6620       gtk_tree_path_free (path);
6621
6622       tree_view->priv->fixed_height = gtk_tree_view_get_row_height (tree_view, node);
6623     }
6624
6625    _gtk_rbtree_set_fixed_height (tree_view->priv->tree,
6626                                  tree_view->priv->fixed_height, TRUE);
6627 }
6628
6629 /* Our strategy for finding nodes to validate is a little convoluted.  We find
6630  * the left-most uninvalidated node.  We then try walking right, validating
6631  * nodes.  Once we find a valid node, we repeat the previous process of finding
6632  * the first invalid node.
6633  */
6634
6635 static gboolean
6636 do_validate_rows (GtkTreeView *tree_view, gboolean queue_resize)
6637 {
6638   GtkRBTree *tree = NULL;
6639   GtkRBNode *node = NULL;
6640   gboolean validated_area = FALSE;
6641   gint retval = TRUE;
6642   GtkTreePath *path = NULL;
6643   GtkTreeIter iter;
6644   GTimer *timer;
6645   gint i = 0;
6646
6647   gint prev_height = -1;
6648   gboolean fixed_height = TRUE;
6649
6650   g_assert (tree_view);
6651
6652   if (tree_view->priv->tree == NULL)
6653       return FALSE;
6654
6655   if (tree_view->priv->fixed_height_mode)
6656     {
6657       if (tree_view->priv->fixed_height < 0)
6658         initialize_fixed_height_mode (tree_view);
6659
6660       return FALSE;
6661     }
6662
6663   timer = g_timer_new ();
6664   g_timer_start (timer);
6665
6666   do
6667     {
6668       if (! GTK_RBNODE_FLAG_SET (tree_view->priv->tree->root, GTK_RBNODE_DESCENDANTS_INVALID))
6669         {
6670           retval = FALSE;
6671           goto done;
6672         }
6673
6674       if (path != NULL)
6675         {
6676           node = _gtk_rbtree_next (tree, node);
6677           if (node != NULL)
6678             {
6679               TREE_VIEW_INTERNAL_ASSERT (gtk_tree_model_iter_next (tree_view->priv->model, &iter), FALSE);
6680               gtk_tree_path_next (path);
6681             }
6682           else
6683             {
6684               gtk_tree_path_free (path);
6685               path = NULL;
6686             }
6687         }
6688
6689       if (path == NULL)
6690         {
6691           tree = tree_view->priv->tree;
6692           node = tree_view->priv->tree->root;
6693
6694           g_assert (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_DESCENDANTS_INVALID));
6695
6696           do
6697             {
6698               if (node->left != tree->nil &&
6699                   GTK_RBNODE_FLAG_SET (node->left, GTK_RBNODE_DESCENDANTS_INVALID))
6700                 {
6701                   node = node->left;
6702                 }
6703               else if (node->right != tree->nil &&
6704                        GTK_RBNODE_FLAG_SET (node->right, GTK_RBNODE_DESCENDANTS_INVALID))
6705                 {
6706                   node = node->right;
6707                 }
6708               else if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) ||
6709                        GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
6710                 {
6711                   break;
6712                 }
6713               else if (node->children != NULL)
6714                 {
6715                   tree = node->children;
6716                   node = tree->root;
6717                 }
6718               else
6719                 /* RBTree corruption!  All bad */
6720                 g_assert_not_reached ();
6721             }
6722           while (TRUE);
6723           path = _gtk_tree_view_find_path (tree_view, tree, node);
6724           gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
6725         }
6726
6727       validated_area = validate_row (tree_view, tree, node, &iter, path) ||
6728                        validated_area;
6729
6730       if (!tree_view->priv->fixed_height_check)
6731         {
6732           gint height;
6733
6734           height = gtk_tree_view_get_row_height (tree_view, node);
6735           if (prev_height < 0)
6736             prev_height = height;
6737           else if (prev_height != height)
6738             fixed_height = FALSE;
6739         }
6740
6741       i++;
6742     }
6743   while (g_timer_elapsed (timer, NULL) < GTK_TREE_VIEW_TIME_MS_PER_IDLE / 1000.);
6744
6745   if (!tree_view->priv->fixed_height_check)
6746    {
6747      if (fixed_height)
6748        _gtk_rbtree_set_fixed_height (tree_view->priv->tree, prev_height, FALSE);
6749
6750      tree_view->priv->fixed_height_check = 1;
6751    }
6752
6753  done:
6754   if (validated_area)
6755     {
6756       GtkRequisition requisition;
6757
6758       /* We temporarily guess a size, under the assumption that it will be the
6759        * same when we get our next size_allocate.  If we don't do this, we'll be
6760        * in an inconsistent state when we call top_row_to_dy. */
6761
6762       /* FIXME: This is called from size_request, for some reason it is not infinitely
6763        * recursing, we cannot call gtk_widget_get_preferred_size() here because that's
6764        * not allowed (from inside ->get_preferred_width/height() implementations, one
6765        * should call the vfuncs directly). However what is desired here is the full
6766        * size including any margins and limited by any alignment (i.e. after
6767        * GtkWidget:adjust_size_request() is called).
6768        *
6769        * Currently bypassing this but the real solution is to not update the scroll adjustments
6770        * untill we've recieved an allocation (never update scroll adjustments from size-requests).
6771        */
6772       gtk_tree_view_size_request (GTK_WIDGET (tree_view), &requisition, FALSE);
6773
6774       tree_view->priv->hadjustment->upper = MAX (tree_view->priv->hadjustment->upper, (gfloat)requisition.width);
6775       tree_view->priv->vadjustment->upper = MAX (tree_view->priv->vadjustment->upper, (gfloat)requisition.height);
6776       gtk_adjustment_changed (tree_view->priv->hadjustment);
6777       gtk_adjustment_changed (tree_view->priv->vadjustment);
6778
6779       if (queue_resize)
6780         gtk_widget_queue_resize (GTK_WIDGET (tree_view));
6781     }
6782
6783   if (path) gtk_tree_path_free (path);
6784   g_timer_destroy (timer);
6785
6786   return retval;
6787 }
6788
6789 static gboolean
6790 validate_rows (GtkTreeView *tree_view)
6791 {
6792   gboolean retval;
6793
6794   retval = do_validate_rows (tree_view, TRUE);
6795
6796   if (! retval && tree_view->priv->validate_rows_timer)
6797     {
6798       g_source_remove (tree_view->priv->validate_rows_timer);
6799       tree_view->priv->validate_rows_timer = 0;
6800     }
6801
6802   return retval;
6803 }
6804
6805 static gboolean
6806 validate_rows_handler (GtkTreeView *tree_view)
6807 {
6808   gboolean retval;
6809
6810   retval = do_validate_rows (tree_view, TRUE);
6811   if (! retval && tree_view->priv->validate_rows_timer)
6812     {
6813       g_source_remove (tree_view->priv->validate_rows_timer);
6814       tree_view->priv->validate_rows_timer = 0;
6815     }
6816
6817   return retval;
6818 }
6819
6820 static gboolean
6821 do_presize_handler (GtkTreeView *tree_view)
6822 {
6823   if (tree_view->priv->mark_rows_col_dirty)
6824     {
6825       if (tree_view->priv->tree)
6826         _gtk_rbtree_column_invalid (tree_view->priv->tree);
6827       tree_view->priv->mark_rows_col_dirty = FALSE;
6828     }
6829   validate_visible_area (tree_view);
6830   tree_view->priv->presize_handler_timer = 0;
6831
6832   if (tree_view->priv->fixed_height_mode)
6833     {
6834       GtkRequisition requisition;
6835
6836       gtk_widget_get_preferred_size (GTK_WIDGET (tree_view),
6837                                      &requisition, NULL);
6838
6839       tree_view->priv->hadjustment->upper = MAX (tree_view->priv->hadjustment->upper, (gfloat)requisition.width);
6840       tree_view->priv->vadjustment->upper = MAX (tree_view->priv->vadjustment->upper, (gfloat)requisition.height);
6841       gtk_adjustment_changed (tree_view->priv->hadjustment);
6842       gtk_adjustment_changed (tree_view->priv->vadjustment);
6843       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
6844     }
6845
6846   return FALSE;
6847 }
6848
6849 static gboolean
6850 presize_handler_callback (gpointer data)
6851 {
6852   do_presize_handler (GTK_TREE_VIEW (data));
6853
6854   return FALSE;
6855 }
6856
6857 static void
6858 install_presize_handler (GtkTreeView *tree_view)
6859 {
6860   if (! gtk_widget_get_realized (GTK_WIDGET (tree_view)))
6861     return;
6862
6863   if (! tree_view->priv->presize_handler_timer)
6864     {
6865       tree_view->priv->presize_handler_timer =
6866         gdk_threads_add_idle_full (GTK_PRIORITY_RESIZE - 2, presize_handler_callback, tree_view, NULL);
6867     }
6868   if (! tree_view->priv->validate_rows_timer)
6869     {
6870       tree_view->priv->validate_rows_timer =
6871         gdk_threads_add_idle_full (GTK_TREE_VIEW_PRIORITY_VALIDATE, (GSourceFunc) validate_rows_handler, tree_view, NULL);
6872     }
6873 }
6874
6875 static void
6876 gtk_tree_view_bin_process_updates (GtkTreeView *tree_view)
6877 {
6878   /* Prior to drawing, we make sure the visible area is validated. */
6879   if (tree_view->priv->presize_handler_timer)
6880     {
6881       g_source_remove (tree_view->priv->presize_handler_timer);
6882       tree_view->priv->presize_handler_timer = 0;
6883
6884       do_presize_handler (tree_view);
6885     }
6886
6887   gdk_window_process_updates (tree_view->priv->bin_window, TRUE);
6888 }
6889
6890 static gboolean
6891 scroll_sync_handler (GtkTreeView *tree_view)
6892 {
6893   if (tree_view->priv->height <= tree_view->priv->vadjustment->page_size)
6894     gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment), 0);
6895   else if (gtk_tree_row_reference_valid (tree_view->priv->top_row))
6896     gtk_tree_view_top_row_to_dy (tree_view);
6897   else
6898     gtk_tree_view_dy_to_top_row (tree_view);
6899
6900   tree_view->priv->scroll_sync_timer = 0;
6901
6902   return FALSE;
6903 }
6904
6905 static void
6906 install_scroll_sync_handler (GtkTreeView *tree_view)
6907 {
6908   if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
6909     return;
6910
6911   if (!tree_view->priv->scroll_sync_timer)
6912     {
6913       tree_view->priv->scroll_sync_timer =
6914         gdk_threads_add_idle_full (GTK_TREE_VIEW_PRIORITY_SCROLL_SYNC, (GSourceFunc) scroll_sync_handler, tree_view, NULL);
6915     }
6916 }
6917
6918 static void
6919 gtk_tree_view_set_top_row (GtkTreeView *tree_view,
6920                            GtkTreePath *path,
6921                            gint         offset)
6922 {
6923   gtk_tree_row_reference_free (tree_view->priv->top_row);
6924
6925   if (!path)
6926     {
6927       tree_view->priv->top_row = NULL;
6928       tree_view->priv->top_row_dy = 0;
6929     }
6930   else
6931     {
6932       tree_view->priv->top_row = gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view), tree_view->priv->model, path);
6933       tree_view->priv->top_row_dy = offset;
6934     }
6935 }
6936
6937 /* Always call this iff dy is in the visible range.  If the tree is empty, then
6938  * it's set to be NULL, and top_row_dy is 0;
6939  */
6940 static void
6941 gtk_tree_view_dy_to_top_row (GtkTreeView *tree_view)
6942 {
6943   gint offset;
6944   GtkTreePath *path;
6945   GtkRBTree *tree;
6946   GtkRBNode *node;
6947
6948   if (tree_view->priv->tree == NULL)
6949     {
6950       gtk_tree_view_set_top_row (tree_view, NULL, 0);
6951     }
6952   else
6953     {
6954       offset = _gtk_rbtree_find_offset (tree_view->priv->tree,
6955                                         tree_view->priv->dy,
6956                                         &tree, &node);
6957
6958       if (tree == NULL)
6959         {
6960           gtk_tree_view_set_top_row (tree_view, NULL, 0);
6961         }
6962       else
6963         {
6964           path = _gtk_tree_view_find_path (tree_view, tree, node);
6965           gtk_tree_view_set_top_row (tree_view, path, offset);
6966           gtk_tree_path_free (path);
6967         }
6968     }
6969 }
6970
6971 static void
6972 gtk_tree_view_top_row_to_dy (GtkTreeView *tree_view)
6973 {
6974   GtkTreePath *path;
6975   GtkRBTree *tree;
6976   GtkRBNode *node;
6977   int new_dy;
6978
6979   /* Avoid recursive calls */
6980   if (tree_view->priv->in_top_row_to_dy)
6981     return;
6982
6983   if (tree_view->priv->top_row)
6984     path = gtk_tree_row_reference_get_path (tree_view->priv->top_row);
6985   else
6986     path = NULL;
6987
6988   if (!path)
6989     tree = NULL;
6990   else
6991     _gtk_tree_view_find_node (tree_view, path, &tree, &node);
6992
6993   if (path)
6994     gtk_tree_path_free (path);
6995
6996   if (tree == NULL)
6997     {
6998       /* keep dy and set new toprow */
6999       gtk_tree_row_reference_free (tree_view->priv->top_row);
7000       tree_view->priv->top_row = NULL;
7001       tree_view->priv->top_row_dy = 0;
7002       /* DO NOT install the idle handler */
7003       gtk_tree_view_dy_to_top_row (tree_view);
7004       return;
7005     }
7006
7007   if (gtk_tree_view_get_row_height (tree_view, node)
7008       < tree_view->priv->top_row_dy)
7009     {
7010       /* new top row -- do NOT install the idle handler */
7011       gtk_tree_view_dy_to_top_row (tree_view);
7012       return;
7013     }
7014
7015   new_dy = _gtk_rbtree_node_find_offset (tree, node);
7016   new_dy += tree_view->priv->top_row_dy;
7017
7018   if (new_dy + tree_view->priv->vadjustment->page_size > tree_view->priv->height)
7019     new_dy = tree_view->priv->height - tree_view->priv->vadjustment->page_size;
7020
7021   new_dy = MAX (0, new_dy);
7022
7023   tree_view->priv->in_top_row_to_dy = TRUE;
7024   gtk_adjustment_set_value (tree_view->priv->vadjustment, (gdouble)new_dy);
7025   tree_view->priv->in_top_row_to_dy = FALSE;
7026 }
7027
7028
7029 void
7030 _gtk_tree_view_install_mark_rows_col_dirty (GtkTreeView *tree_view,
7031                                             gboolean     install_handler)
7032 {
7033   tree_view->priv->mark_rows_col_dirty = TRUE;
7034
7035   if (install_handler)
7036     install_presize_handler (tree_view);
7037 }
7038
7039 /*
7040  * This function works synchronously (due to the while (validate_rows...)
7041  * loop).
7042  *
7043  * There was a check for column_type != GTK_TREE_VIEW_COLUMN_AUTOSIZE
7044  * here. You now need to check that yourself.
7045  */
7046 void
7047 _gtk_tree_view_column_autosize (GtkTreeView *tree_view,
7048                                 GtkTreeViewColumn *column)
7049 {
7050   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
7051   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (column));
7052
7053   _gtk_tree_view_column_cell_set_dirty (column, FALSE);
7054
7055   do_presize_handler (tree_view);
7056   while (validate_rows (tree_view));
7057
7058   gtk_widget_queue_resize (GTK_WIDGET (tree_view));
7059 }
7060
7061 /* Drag-and-drop */
7062
7063 static void
7064 set_source_row (GdkDragContext *context,
7065                 GtkTreeModel   *model,
7066                 GtkTreePath    *source_row)
7067 {
7068   g_object_set_data_full (G_OBJECT (context),
7069                           I_("gtk-tree-view-source-row"),
7070                           source_row ? gtk_tree_row_reference_new (model, source_row) : NULL,
7071                           (GDestroyNotify) (source_row ? gtk_tree_row_reference_free : NULL));
7072 }
7073
7074 static GtkTreePath*
7075 get_source_row (GdkDragContext *context)
7076 {
7077   GtkTreeRowReference *ref =
7078     g_object_get_data (G_OBJECT (context), "gtk-tree-view-source-row");
7079
7080   if (ref)
7081     return gtk_tree_row_reference_get_path (ref);
7082   else
7083     return NULL;
7084 }
7085
7086 typedef struct
7087 {
7088   GtkTreeRowReference *dest_row;
7089   guint                path_down_mode   : 1;
7090   guint                empty_view_drop  : 1;
7091   guint                drop_append_mode : 1;
7092 }
7093 DestRow;
7094
7095 static void
7096 dest_row_free (gpointer data)
7097 {
7098   DestRow *dr = (DestRow *)data;
7099
7100   gtk_tree_row_reference_free (dr->dest_row);
7101   g_slice_free (DestRow, dr);
7102 }
7103
7104 static void
7105 set_dest_row (GdkDragContext *context,
7106               GtkTreeModel   *model,
7107               GtkTreePath    *dest_row,
7108               gboolean        path_down_mode,
7109               gboolean        empty_view_drop,
7110               gboolean        drop_append_mode)
7111 {
7112   DestRow *dr;
7113
7114   if (!dest_row)
7115     {
7116       g_object_set_data_full (G_OBJECT (context), I_("gtk-tree-view-dest-row"),
7117                               NULL, NULL);
7118       return;
7119     }
7120
7121   dr = g_slice_new (DestRow);
7122
7123   dr->dest_row = gtk_tree_row_reference_new (model, dest_row);
7124   dr->path_down_mode = path_down_mode != FALSE;
7125   dr->empty_view_drop = empty_view_drop != FALSE;
7126   dr->drop_append_mode = drop_append_mode != FALSE;
7127
7128   g_object_set_data_full (G_OBJECT (context), I_("gtk-tree-view-dest-row"),
7129                           dr, (GDestroyNotify) dest_row_free);
7130 }
7131
7132 static GtkTreePath*
7133 get_dest_row (GdkDragContext *context,
7134               gboolean       *path_down_mode)
7135 {
7136   DestRow *dr =
7137     g_object_get_data (G_OBJECT (context), "gtk-tree-view-dest-row");
7138
7139   if (dr)
7140     {
7141       GtkTreePath *path = NULL;
7142
7143       if (path_down_mode)
7144         *path_down_mode = dr->path_down_mode;
7145
7146       if (dr->dest_row)
7147         path = gtk_tree_row_reference_get_path (dr->dest_row);
7148       else if (dr->empty_view_drop)
7149         path = gtk_tree_path_new_from_indices (0, -1);
7150       else
7151         path = NULL;
7152
7153       if (path && dr->drop_append_mode)
7154         gtk_tree_path_next (path);
7155
7156       return path;
7157     }
7158   else
7159     return NULL;
7160 }
7161
7162 /* Get/set whether drag_motion requested the drag data and
7163  * drag_data_received should thus not actually insert the data,
7164  * since the data doesn't result from a drop.
7165  */
7166 static void
7167 set_status_pending (GdkDragContext *context,
7168                     GdkDragAction   suggested_action)
7169 {
7170   g_object_set_data (G_OBJECT (context),
7171                      I_("gtk-tree-view-status-pending"),
7172                      GINT_TO_POINTER (suggested_action));
7173 }
7174
7175 static GdkDragAction
7176 get_status_pending (GdkDragContext *context)
7177 {
7178   return GPOINTER_TO_INT (g_object_get_data (G_OBJECT (context),
7179                                              "gtk-tree-view-status-pending"));
7180 }
7181
7182 static TreeViewDragInfo*
7183 get_info (GtkTreeView *tree_view)
7184 {
7185   return g_object_get_data (G_OBJECT (tree_view), "gtk-tree-view-drag-info");
7186 }
7187
7188 static void
7189 destroy_info (TreeViewDragInfo *di)
7190 {
7191   g_slice_free (TreeViewDragInfo, di);
7192 }
7193
7194 static TreeViewDragInfo*
7195 ensure_info (GtkTreeView *tree_view)
7196 {
7197   TreeViewDragInfo *di;
7198
7199   di = get_info (tree_view);
7200
7201   if (di == NULL)
7202     {
7203       di = g_slice_new0 (TreeViewDragInfo);
7204
7205       g_object_set_data_full (G_OBJECT (tree_view),
7206                               I_("gtk-tree-view-drag-info"),
7207                               di,
7208                               (GDestroyNotify) destroy_info);
7209     }
7210
7211   return di;
7212 }
7213
7214 static void
7215 remove_info (GtkTreeView *tree_view)
7216 {
7217   g_object_set_data (G_OBJECT (tree_view), I_("gtk-tree-view-drag-info"), NULL);
7218 }
7219
7220 #if 0
7221 static gint
7222 drag_scan_timeout (gpointer data)
7223 {
7224   GtkTreeView *tree_view;
7225   gint x, y;
7226   GdkModifierType state;
7227   GtkTreePath *path = NULL;
7228   GtkTreeViewColumn *column = NULL;
7229   GdkRectangle visible_rect;
7230
7231   GDK_THREADS_ENTER ();
7232
7233   tree_view = GTK_TREE_VIEW (data);
7234
7235   gdk_window_get_pointer (tree_view->priv->bin_window,
7236                           &x, &y, &state);
7237
7238   gtk_tree_view_get_visible_rect (tree_view, &visible_rect);
7239
7240   /* See if we are near the edge. */
7241   if ((x - visible_rect.x) < SCROLL_EDGE_SIZE ||
7242       (visible_rect.x + visible_rect.width - x) < SCROLL_EDGE_SIZE ||
7243       (y - visible_rect.y) < SCROLL_EDGE_SIZE ||
7244       (visible_rect.y + visible_rect.height - y) < SCROLL_EDGE_SIZE)
7245     {
7246       gtk_tree_view_get_path_at_pos (tree_view,
7247                                      tree_view->priv->bin_window,
7248                                      x, y,
7249                                      &path,
7250                                      &column,
7251                                      NULL,
7252                                      NULL);
7253
7254       if (path != NULL)
7255         {
7256           gtk_tree_view_scroll_to_cell (tree_view,
7257                                         path,
7258                                         column,
7259                                         TRUE,
7260                                         0.5, 0.5);
7261
7262           gtk_tree_path_free (path);
7263         }
7264     }
7265
7266   GDK_THREADS_LEAVE ();
7267
7268   return TRUE;
7269 }
7270 #endif /* 0 */
7271
7272 static void
7273 add_scroll_timeout (GtkTreeView *tree_view)
7274 {
7275   if (tree_view->priv->scroll_timeout == 0)
7276     {
7277       tree_view->priv->scroll_timeout =
7278         gdk_threads_add_timeout (150, scroll_row_timeout, tree_view);
7279     }
7280 }
7281
7282 static void
7283 remove_scroll_timeout (GtkTreeView *tree_view)
7284 {
7285   if (tree_view->priv->scroll_timeout != 0)
7286     {
7287       g_source_remove (tree_view->priv->scroll_timeout);
7288       tree_view->priv->scroll_timeout = 0;
7289     }
7290 }
7291
7292 static gboolean
7293 check_model_dnd (GtkTreeModel *model,
7294                  GType         required_iface,
7295                  const gchar  *signal)
7296 {
7297   if (model == NULL || !G_TYPE_CHECK_INSTANCE_TYPE ((model), required_iface))
7298     {
7299       g_warning ("You must override the default '%s' handler "
7300                  "on GtkTreeView when using models that don't support "
7301                  "the %s interface and enabling drag-and-drop. The simplest way to do this "
7302                  "is to connect to '%s' and call "
7303                  "g_signal_stop_emission_by_name() in your signal handler to prevent "
7304                  "the default handler from running. Look at the source code "
7305                  "for the default handler in gtktreeview.c to get an idea what "
7306                  "your handler should do. (gtktreeview.c is in the GTK source "
7307                  "code.) If you're using GTK from a language other than C, "
7308                  "there may be a more natural way to override default handlers, e.g. via derivation.",
7309                  signal, g_type_name (required_iface), signal);
7310       return FALSE;
7311     }
7312   else
7313     return TRUE;
7314 }
7315
7316 static void
7317 remove_open_timeout (GtkTreeView *tree_view)
7318 {
7319   if (tree_view->priv->open_dest_timeout != 0)
7320     {
7321       g_source_remove (tree_view->priv->open_dest_timeout);
7322       tree_view->priv->open_dest_timeout = 0;
7323     }
7324 }
7325
7326
7327 static gint
7328 open_row_timeout (gpointer data)
7329 {
7330   GtkTreeView *tree_view = data;
7331   GtkTreePath *dest_path = NULL;
7332   GtkTreeViewDropPosition pos;
7333   gboolean result = FALSE;
7334
7335   gtk_tree_view_get_drag_dest_row (tree_view,
7336                                    &dest_path,
7337                                    &pos);
7338
7339   if (dest_path &&
7340       (pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER ||
7341        pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE))
7342     {
7343       gtk_tree_view_expand_row (tree_view, dest_path, FALSE);
7344       tree_view->priv->open_dest_timeout = 0;
7345
7346       gtk_tree_path_free (dest_path);
7347     }
7348   else
7349     {
7350       if (dest_path)
7351         gtk_tree_path_free (dest_path);
7352
7353       result = TRUE;
7354     }
7355
7356   return result;
7357 }
7358
7359 static gboolean
7360 scroll_row_timeout (gpointer data)
7361 {
7362   GtkTreeView *tree_view = data;
7363
7364   gtk_tree_view_vertical_autoscroll (tree_view);
7365
7366   if (tree_view->priv->rubber_band_status == RUBBER_BAND_ACTIVE)
7367     gtk_tree_view_update_rubber_band (tree_view);
7368
7369   return TRUE;
7370 }
7371
7372 /* Returns TRUE if event should not be propagated to parent widgets */
7373 static gboolean
7374 set_destination_row (GtkTreeView    *tree_view,
7375                      GdkDragContext *context,
7376                      /* coordinates relative to the widget */
7377                      gint            x,
7378                      gint            y,
7379                      GdkDragAction  *suggested_action,
7380                      GdkAtom        *target)
7381 {
7382   GtkTreePath *path = NULL;
7383   GtkTreeViewDropPosition pos;
7384   GtkTreeViewDropPosition old_pos;
7385   TreeViewDragInfo *di;
7386   GtkWidget *widget;
7387   GtkTreePath *old_dest_path = NULL;
7388   gboolean can_drop = FALSE;
7389
7390   *suggested_action = 0;
7391   *target = GDK_NONE;
7392
7393   widget = GTK_WIDGET (tree_view);
7394
7395   di = get_info (tree_view);
7396
7397   if (di == NULL || y - gtk_tree_view_get_effective_header_height (tree_view) < 0)
7398     {
7399       /* someone unset us as a drag dest, note that if
7400        * we return FALSE drag_leave isn't called
7401        */
7402
7403       gtk_tree_view_set_drag_dest_row (tree_view,
7404                                        NULL,
7405                                        GTK_TREE_VIEW_DROP_BEFORE);
7406
7407       remove_scroll_timeout (GTK_TREE_VIEW (widget));
7408       remove_open_timeout (GTK_TREE_VIEW (widget));
7409
7410       return FALSE; /* no longer a drop site */
7411     }
7412
7413   *target = gtk_drag_dest_find_target (widget, context,
7414                                        gtk_drag_dest_get_target_list (widget));
7415   if (*target == GDK_NONE)
7416     {
7417       return FALSE;
7418     }
7419
7420   if (!gtk_tree_view_get_dest_row_at_pos (tree_view,
7421                                           x, y,
7422                                           &path,
7423                                           &pos))
7424     {
7425       gint n_children;
7426       GtkTreeModel *model;
7427
7428       remove_open_timeout (tree_view);
7429
7430       /* the row got dropped on empty space, let's setup a special case
7431        */
7432
7433       if (path)
7434         gtk_tree_path_free (path);
7435
7436       model = gtk_tree_view_get_model (tree_view);
7437
7438       n_children = gtk_tree_model_iter_n_children (model, NULL);
7439       if (n_children)
7440         {
7441           pos = GTK_TREE_VIEW_DROP_AFTER;
7442           path = gtk_tree_path_new_from_indices (n_children - 1, -1);
7443         }
7444       else
7445         {
7446           pos = GTK_TREE_VIEW_DROP_BEFORE;
7447           path = gtk_tree_path_new_from_indices (0, -1);
7448         }
7449
7450       can_drop = TRUE;
7451
7452       goto out;
7453     }
7454
7455   g_assert (path);
7456
7457   /* If we left the current row's "open" zone, unset the timeout for
7458    * opening the row
7459    */
7460   gtk_tree_view_get_drag_dest_row (tree_view,
7461                                    &old_dest_path,
7462                                    &old_pos);
7463
7464   if (old_dest_path &&
7465       (gtk_tree_path_compare (path, old_dest_path) != 0 ||
7466        !(pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER ||
7467          pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE)))
7468     remove_open_timeout (tree_view);
7469
7470   if (old_dest_path)
7471     gtk_tree_path_free (old_dest_path);
7472
7473   if (TRUE /* FIXME if the location droppable predicate */)
7474     {
7475       can_drop = TRUE;
7476     }
7477
7478 out:
7479   if (can_drop)
7480     {
7481       GtkWidget *source_widget;
7482
7483       *suggested_action = gdk_drag_context_get_suggested_action (context);
7484       source_widget = gtk_drag_get_source_widget (context);
7485
7486       if (source_widget == widget)
7487         {
7488           /* Default to MOVE, unless the user has
7489            * pressed ctrl or shift to affect available actions
7490            */
7491           if ((gdk_drag_context_get_actions (context) & GDK_ACTION_MOVE) != 0)
7492             *suggested_action = GDK_ACTION_MOVE;
7493         }
7494
7495       gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
7496                                        path, pos);
7497     }
7498   else
7499     {
7500       /* can't drop here */
7501       remove_open_timeout (tree_view);
7502
7503       gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
7504                                        NULL,
7505                                        GTK_TREE_VIEW_DROP_BEFORE);
7506     }
7507
7508   if (path)
7509     gtk_tree_path_free (path);
7510
7511   return TRUE;
7512 }
7513
7514 static GtkTreePath*
7515 get_logical_dest_row (GtkTreeView *tree_view,
7516                       gboolean    *path_down_mode,
7517                       gboolean    *drop_append_mode)
7518 {
7519   /* adjust path to point to the row the drop goes in front of */
7520   GtkTreePath *path = NULL;
7521   GtkTreeViewDropPosition pos;
7522
7523   g_return_val_if_fail (path_down_mode != NULL, NULL);
7524   g_return_val_if_fail (drop_append_mode != NULL, NULL);
7525
7526   *path_down_mode = FALSE;
7527   *drop_append_mode = 0;
7528
7529   gtk_tree_view_get_drag_dest_row (tree_view, &path, &pos);
7530
7531   if (path == NULL)
7532     return NULL;
7533
7534   if (pos == GTK_TREE_VIEW_DROP_BEFORE)
7535     ; /* do nothing */
7536   else if (pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE ||
7537            pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER)
7538     *path_down_mode = TRUE;
7539   else
7540     {
7541       GtkTreeIter iter;
7542       GtkTreeModel *model = gtk_tree_view_get_model (tree_view);
7543
7544       g_assert (pos == GTK_TREE_VIEW_DROP_AFTER);
7545
7546       if (!gtk_tree_model_get_iter (model, &iter, path) ||
7547           !gtk_tree_model_iter_next (model, &iter))
7548         *drop_append_mode = 1;
7549       else
7550         {
7551           *drop_append_mode = 0;
7552           gtk_tree_path_next (path);
7553         }
7554     }
7555
7556   return path;
7557 }
7558
7559 static gboolean
7560 gtk_tree_view_maybe_begin_dragging_row (GtkTreeView      *tree_view,
7561                                         GdkEventMotion   *event)
7562 {
7563   GtkWidget *widget = GTK_WIDGET (tree_view);
7564   GdkDragContext *context;
7565   TreeViewDragInfo *di;
7566   GtkTreePath *path = NULL;
7567   gint button;
7568   gint cell_x, cell_y;
7569   GtkTreeModel *model;
7570   gboolean retval = FALSE;
7571
7572   di = get_info (tree_view);
7573
7574   if (di == NULL || !di->source_set)
7575     goto out;
7576
7577   if (tree_view->priv->pressed_button < 0)
7578     goto out;
7579
7580   if (!gtk_drag_check_threshold (widget,
7581                                  tree_view->priv->press_start_x,
7582                                  tree_view->priv->press_start_y,
7583                                  event->x, event->y))
7584     goto out;
7585
7586   model = gtk_tree_view_get_model (tree_view);
7587
7588   if (model == NULL)
7589     goto out;
7590
7591   button = tree_view->priv->pressed_button;
7592   tree_view->priv->pressed_button = -1;
7593
7594   gtk_tree_view_get_path_at_pos (tree_view,
7595                                  tree_view->priv->press_start_x,
7596                                  tree_view->priv->press_start_y,
7597                                  &path,
7598                                  NULL,
7599                                  &cell_x,
7600                                  &cell_y);
7601
7602   if (path == NULL)
7603     goto out;
7604
7605   if (!GTK_IS_TREE_DRAG_SOURCE (model) ||
7606       !gtk_tree_drag_source_row_draggable (GTK_TREE_DRAG_SOURCE (model),
7607                                            path))
7608     goto out;
7609
7610   if (!(GDK_BUTTON1_MASK << (button - 1) & di->start_button_mask))
7611     goto out;
7612
7613   /* Now we can begin the drag */
7614
7615   retval = TRUE;
7616
7617   context = gtk_drag_begin (widget,
7618                             gtk_drag_source_get_target_list (widget),
7619                             di->source_actions,
7620                             button,
7621                             (GdkEvent*)event);
7622
7623   set_source_row (context, model, path);
7624
7625  out:
7626   if (path)
7627     gtk_tree_path_free (path);
7628
7629   return retval;
7630 }
7631
7632
7633 static void
7634 gtk_tree_view_drag_begin (GtkWidget      *widget,
7635                           GdkDragContext *context)
7636 {
7637   GtkTreeView *tree_view;
7638   GtkTreePath *path = NULL;
7639   gint cell_x, cell_y;
7640   cairo_surface_t *row_pix;
7641   TreeViewDragInfo *di;
7642
7643   tree_view = GTK_TREE_VIEW (widget);
7644
7645   /* if the user uses a custom DND source impl, we don't set the icon here */
7646   di = get_info (tree_view);
7647
7648   if (di == NULL || !di->source_set)
7649     return;
7650
7651   gtk_tree_view_get_path_at_pos (tree_view,
7652                                  tree_view->priv->press_start_x,
7653                                  tree_view->priv->press_start_y,
7654                                  &path,
7655                                  NULL,
7656                                  &cell_x,
7657                                  &cell_y);
7658
7659   g_return_if_fail (path != NULL);
7660
7661   row_pix = gtk_tree_view_create_row_drag_icon (tree_view,
7662                                                 path);
7663   cairo_surface_set_device_offset (row_pix,
7664                                    /* the + 1 is for the black border in the icon */
7665                                    - (tree_view->priv->press_start_x + 1),
7666                                    - (cell_y + 1));
7667
7668   gtk_drag_set_icon_surface (context, row_pix);
7669
7670   cairo_surface_destroy (row_pix);
7671   gtk_tree_path_free (path);
7672 }
7673
7674 static void
7675 gtk_tree_view_drag_end (GtkWidget      *widget,
7676                         GdkDragContext *context)
7677 {
7678   /* do nothing */
7679 }
7680
7681 /* Default signal implementations for the drag signals */
7682 static void
7683 gtk_tree_view_drag_data_get (GtkWidget        *widget,
7684                              GdkDragContext   *context,
7685                              GtkSelectionData *selection_data,
7686                              guint             info,
7687                              guint             time)
7688 {
7689   GtkTreeView *tree_view;
7690   GtkTreeModel *model;
7691   TreeViewDragInfo *di;
7692   GtkTreePath *source_row;
7693
7694   tree_view = GTK_TREE_VIEW (widget);
7695
7696   model = gtk_tree_view_get_model (tree_view);
7697
7698   if (model == NULL)
7699     return;
7700
7701   di = get_info (GTK_TREE_VIEW (widget));
7702
7703   if (di == NULL)
7704     return;
7705
7706   source_row = get_source_row (context);
7707
7708   if (source_row == NULL)
7709     return;
7710
7711   /* We can implement the GTK_TREE_MODEL_ROW target generically for
7712    * any model; for DragSource models there are some other targets
7713    * we also support.
7714    */
7715
7716   if (GTK_IS_TREE_DRAG_SOURCE (model) &&
7717       gtk_tree_drag_source_drag_data_get (GTK_TREE_DRAG_SOURCE (model),
7718                                           source_row,
7719                                           selection_data))
7720     goto done;
7721
7722   /* If drag_data_get does nothing, try providing row data. */
7723   if (gtk_selection_data_get_target (selection_data) == gdk_atom_intern_static_string ("GTK_TREE_MODEL_ROW"))
7724     {
7725       gtk_tree_set_row_drag_data (selection_data,
7726                                   model,
7727                                   source_row);
7728     }
7729
7730  done:
7731   gtk_tree_path_free (source_row);
7732 }
7733
7734
7735 static void
7736 gtk_tree_view_drag_data_delete (GtkWidget      *widget,
7737                                 GdkDragContext *context)
7738 {
7739   TreeViewDragInfo *di;
7740   GtkTreeModel *model;
7741   GtkTreeView *tree_view;
7742   GtkTreePath *source_row;
7743
7744   tree_view = GTK_TREE_VIEW (widget);
7745   model = gtk_tree_view_get_model (tree_view);
7746
7747   if (!check_model_dnd (model, GTK_TYPE_TREE_DRAG_SOURCE, "drag_data_delete"))
7748     return;
7749
7750   di = get_info (tree_view);
7751
7752   if (di == NULL)
7753     return;
7754
7755   source_row = get_source_row (context);
7756
7757   if (source_row == NULL)
7758     return;
7759
7760   gtk_tree_drag_source_drag_data_delete (GTK_TREE_DRAG_SOURCE (model),
7761                                          source_row);
7762
7763   gtk_tree_path_free (source_row);
7764
7765   set_source_row (context, NULL, NULL);
7766 }
7767
7768 static void
7769 gtk_tree_view_drag_leave (GtkWidget      *widget,
7770                           GdkDragContext *context,
7771                           guint             time)
7772 {
7773   /* unset any highlight row */
7774   gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
7775                                    NULL,
7776                                    GTK_TREE_VIEW_DROP_BEFORE);
7777
7778   remove_scroll_timeout (GTK_TREE_VIEW (widget));
7779   remove_open_timeout (GTK_TREE_VIEW (widget));
7780 }
7781
7782
7783 static gboolean
7784 gtk_tree_view_drag_motion (GtkWidget        *widget,
7785                            GdkDragContext   *context,
7786                            /* coordinates relative to the widget */
7787                            gint              x,
7788                            gint              y,
7789                            guint             time)
7790 {
7791   gboolean empty;
7792   GtkTreePath *path = NULL;
7793   GtkTreeViewDropPosition pos;
7794   GtkTreeView *tree_view;
7795   GdkDragAction suggested_action = 0;
7796   GdkAtom target;
7797
7798   tree_view = GTK_TREE_VIEW (widget);
7799
7800   if (!set_destination_row (tree_view, context, x, y, &suggested_action, &target))
7801     return FALSE;
7802
7803   gtk_tree_view_get_drag_dest_row (tree_view, &path, &pos);
7804
7805   /* we only know this *after* set_desination_row */
7806   empty = tree_view->priv->empty_view_drop;
7807
7808   if (path == NULL && !empty)
7809     {
7810       /* Can't drop here. */
7811       gdk_drag_status (context, 0, time);
7812     }
7813   else
7814     {
7815       if (tree_view->priv->open_dest_timeout == 0 &&
7816           (pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER ||
7817            pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE))
7818         {
7819           tree_view->priv->open_dest_timeout =
7820             gdk_threads_add_timeout (AUTO_EXPAND_TIMEOUT, open_row_timeout, tree_view);
7821         }
7822       else
7823         {
7824           add_scroll_timeout (tree_view);
7825         }
7826
7827       if (target == gdk_atom_intern_static_string ("GTK_TREE_MODEL_ROW"))
7828         {
7829           /* Request data so we can use the source row when
7830            * determining whether to accept the drop
7831            */
7832           set_status_pending (context, suggested_action);
7833           gtk_drag_get_data (widget, context, target, time);
7834         }
7835       else
7836         {
7837           set_status_pending (context, 0);
7838           gdk_drag_status (context, suggested_action, time);
7839         }
7840     }
7841
7842   if (path)
7843     gtk_tree_path_free (path);
7844
7845   return TRUE;
7846 }
7847
7848
7849 static gboolean
7850 gtk_tree_view_drag_drop (GtkWidget        *widget,
7851                          GdkDragContext   *context,
7852                          /* coordinates relative to the widget */
7853                          gint              x,
7854                          gint              y,
7855                          guint             time)
7856 {
7857   GtkTreeView *tree_view;
7858   GtkTreePath *path;
7859   GdkDragAction suggested_action = 0;
7860   GdkAtom target = GDK_NONE;
7861   TreeViewDragInfo *di;
7862   GtkTreeModel *model;
7863   gboolean path_down_mode;
7864   gboolean drop_append_mode;
7865
7866   tree_view = GTK_TREE_VIEW (widget);
7867
7868   model = gtk_tree_view_get_model (tree_view);
7869
7870   remove_scroll_timeout (GTK_TREE_VIEW (widget));
7871   remove_open_timeout (GTK_TREE_VIEW (widget));
7872
7873   di = get_info (tree_view);
7874
7875   if (di == NULL)
7876     return FALSE;
7877
7878   if (!check_model_dnd (model, GTK_TYPE_TREE_DRAG_DEST, "drag_drop"))
7879     return FALSE;
7880
7881   if (!set_destination_row (tree_view, context, x, y, &suggested_action, &target))
7882     return FALSE;
7883
7884   path = get_logical_dest_row (tree_view, &path_down_mode, &drop_append_mode);
7885
7886   if (target != GDK_NONE && path != NULL)
7887     {
7888       /* in case a motion had requested drag data, change things so we
7889        * treat drag data receives as a drop.
7890        */
7891       set_status_pending (context, 0);
7892       set_dest_row (context, model, path,
7893                     path_down_mode, tree_view->priv->empty_view_drop,
7894                     drop_append_mode);
7895     }
7896
7897   if (path)
7898     gtk_tree_path_free (path);
7899
7900   /* Unset this thing */
7901   gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
7902                                    NULL,
7903                                    GTK_TREE_VIEW_DROP_BEFORE);
7904
7905   if (target != GDK_NONE)
7906     {
7907       gtk_drag_get_data (widget, context, target, time);
7908       return TRUE;
7909     }
7910   else
7911     return FALSE;
7912 }
7913
7914 static void
7915 gtk_tree_view_drag_data_received (GtkWidget        *widget,
7916                                   GdkDragContext   *context,
7917                                   /* coordinates relative to the widget */
7918                                   gint              x,
7919                                   gint              y,
7920                                   GtkSelectionData *selection_data,
7921                                   guint             info,
7922                                   guint             time)
7923 {
7924   GtkTreePath *path;
7925   TreeViewDragInfo *di;
7926   gboolean accepted = FALSE;
7927   GtkTreeModel *model;
7928   GtkTreeView *tree_view;
7929   GtkTreePath *dest_row;
7930   GdkDragAction suggested_action;
7931   gboolean path_down_mode;
7932   gboolean drop_append_mode;
7933
7934   tree_view = GTK_TREE_VIEW (widget);
7935
7936   model = gtk_tree_view_get_model (tree_view);
7937
7938   if (!check_model_dnd (model, GTK_TYPE_TREE_DRAG_DEST, "drag_data_received"))
7939     return;
7940
7941   di = get_info (tree_view);
7942
7943   if (di == NULL)
7944     return;
7945
7946   suggested_action = get_status_pending (context);
7947
7948   if (suggested_action)
7949     {
7950       /* We are getting this data due to a request in drag_motion,
7951        * rather than due to a request in drag_drop, so we are just
7952        * supposed to call drag_status, not actually paste in the
7953        * data.
7954        */
7955       path = get_logical_dest_row (tree_view, &path_down_mode,
7956                                    &drop_append_mode);
7957
7958       if (path == NULL)
7959         suggested_action = 0;
7960       else if (path_down_mode)
7961         gtk_tree_path_down (path);
7962
7963       if (suggested_action)
7964         {
7965           if (!gtk_tree_drag_dest_row_drop_possible (GTK_TREE_DRAG_DEST (model),
7966                                                      path,
7967                                                      selection_data))
7968             {
7969               if (path_down_mode)
7970                 {
7971                   path_down_mode = FALSE;
7972                   gtk_tree_path_up (path);
7973
7974                   if (!gtk_tree_drag_dest_row_drop_possible (GTK_TREE_DRAG_DEST (model),
7975                                                              path,
7976                                                              selection_data))
7977                     suggested_action = 0;
7978                 }
7979               else
7980                 suggested_action = 0;
7981             }
7982         }
7983
7984       gdk_drag_status (context, suggested_action, time);
7985
7986       if (path)
7987         gtk_tree_path_free (path);
7988
7989       /* If you can't drop, remove user drop indicator until the next motion */
7990       if (suggested_action == 0)
7991         gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
7992                                          NULL,
7993                                          GTK_TREE_VIEW_DROP_BEFORE);
7994
7995       return;
7996     }
7997
7998   dest_row = get_dest_row (context, &path_down_mode);
7999
8000   if (dest_row == NULL)
8001     return;
8002
8003   if (gtk_selection_data_get_length (selection_data) >= 0)
8004     {
8005       if (path_down_mode)
8006         {
8007           gtk_tree_path_down (dest_row);
8008           if (!gtk_tree_drag_dest_row_drop_possible (GTK_TREE_DRAG_DEST (model),
8009                                                      dest_row, selection_data))
8010             gtk_tree_path_up (dest_row);
8011         }
8012     }
8013
8014   if (gtk_selection_data_get_length (selection_data) >= 0)
8015     {
8016       if (gtk_tree_drag_dest_drag_data_received (GTK_TREE_DRAG_DEST (model),
8017                                                  dest_row,
8018                                                  selection_data))
8019         accepted = TRUE;
8020     }
8021
8022   gtk_drag_finish (context,
8023                    accepted,
8024                    (gdk_drag_context_get_selected_action (context) == GDK_ACTION_MOVE),
8025                    time);
8026
8027   if (gtk_tree_path_get_depth (dest_row) == 1
8028       && gtk_tree_path_get_indices (dest_row)[0] == 0)
8029     {
8030       /* special special case drag to "0", scroll to first item */
8031       if (!tree_view->priv->scroll_to_path)
8032         gtk_tree_view_scroll_to_cell (tree_view, dest_row, NULL, FALSE, 0.0, 0.0);
8033     }
8034
8035   gtk_tree_path_free (dest_row);
8036
8037   /* drop dest_row */
8038   set_dest_row (context, NULL, NULL, FALSE, FALSE, FALSE);
8039 }
8040
8041
8042
8043 /* GtkContainer Methods
8044  */
8045
8046
8047 static void
8048 gtk_tree_view_remove (GtkContainer *container,
8049                       GtkWidget    *widget)
8050 {
8051   GtkTreeView *tree_view = GTK_TREE_VIEW (container);
8052   GtkTreeViewChild *child = NULL;
8053   GList *tmp_list;
8054
8055   tmp_list = tree_view->priv->children;
8056   while (tmp_list)
8057     {
8058       child = tmp_list->data;
8059       if (child->widget == widget)
8060         {
8061           gtk_widget_unparent (widget);
8062
8063           tree_view->priv->children = g_list_remove_link (tree_view->priv->children, tmp_list);
8064           g_list_free_1 (tmp_list);
8065           g_slice_free (GtkTreeViewChild, child);
8066           return;
8067         }
8068
8069       tmp_list = tmp_list->next;
8070     }
8071
8072   tmp_list = tree_view->priv->columns;
8073
8074   while (tmp_list)
8075     {
8076       GtkTreeViewColumn *column;
8077       GtkWidget         *button;
8078
8079       column = tmp_list->data;
8080       button = gtk_tree_view_column_get_button (column);
8081
8082       if (button == widget)
8083         {
8084           gtk_widget_unparent (widget);
8085           return;
8086         }
8087       tmp_list = tmp_list->next;
8088     }
8089 }
8090
8091 static void
8092 gtk_tree_view_forall (GtkContainer *container,
8093                       gboolean      include_internals,
8094                       GtkCallback   callback,
8095                       gpointer      callback_data)
8096 {
8097   GtkTreeView *tree_view = GTK_TREE_VIEW (container);
8098   GtkTreeViewChild *child = NULL;
8099   GtkTreeViewColumn *column;
8100   GtkWidget *button;
8101   GList *tmp_list;
8102
8103   tmp_list = tree_view->priv->children;
8104   while (tmp_list)
8105     {
8106       child = tmp_list->data;
8107       tmp_list = tmp_list->next;
8108
8109       (* callback) (child->widget, callback_data);
8110     }
8111   if (include_internals == FALSE)
8112     return;
8113
8114   for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list = tmp_list->next)
8115     {
8116       column = tmp_list->data;
8117       button = gtk_tree_view_column_get_button (column);
8118
8119       if (button)
8120         (* callback) (button, callback_data);
8121     }
8122 }
8123
8124 /* Returns TRUE is any of the columns contains a cell that can-focus.
8125  * If this is not the case, a column-spanning focus rectangle will be
8126  * drawn.
8127  */
8128 static gboolean
8129 gtk_tree_view_has_can_focus_cell (GtkTreeView *tree_view)
8130 {
8131   GList *list;
8132
8133   for (list = tree_view->priv->columns; list; list = list->next)
8134     {
8135       GtkTreeViewColumn *column = list->data;
8136
8137       if (!gtk_tree_view_column_get_visible (column))
8138         continue;
8139       if (gtk_cell_area_is_activatable (gtk_cell_layout_get_area (GTK_CELL_LAYOUT (column))))
8140         return TRUE;
8141     }
8142
8143   return FALSE;
8144 }
8145
8146 static void
8147 column_sizing_notify (GObject    *object,
8148                       GParamSpec *pspec,
8149                       gpointer    data)
8150 {
8151   GtkTreeViewColumn *c = GTK_TREE_VIEW_COLUMN (object);
8152
8153   if (gtk_tree_view_column_get_sizing (c) != GTK_TREE_VIEW_COLUMN_FIXED)
8154     /* disable fixed height mode */
8155     g_object_set (data, "fixed-height-mode", FALSE, NULL);
8156 }
8157
8158 /**
8159  * gtk_tree_view_set_fixed_height_mode:
8160  * @tree_view: a #GtkTreeView
8161  * @enable: %TRUE to enable fixed height mode
8162  *
8163  * Enables or disables the fixed height mode of @tree_view.
8164  * Fixed height mode speeds up #GtkTreeView by assuming that all
8165  * rows have the same height.
8166  * Only enable this option if all rows are the same height and all
8167  * columns are of type %GTK_TREE_VIEW_COLUMN_FIXED.
8168  *
8169  * Since: 2.6
8170  **/
8171 void
8172 gtk_tree_view_set_fixed_height_mode (GtkTreeView *tree_view,
8173                                      gboolean     enable)
8174 {
8175   GList *l;
8176
8177   enable = enable != FALSE;
8178
8179   if (enable == tree_view->priv->fixed_height_mode)
8180     return;
8181
8182   if (!enable)
8183     {
8184       tree_view->priv->fixed_height_mode = 0;
8185       tree_view->priv->fixed_height = -1;
8186
8187       /* force a revalidation */
8188       install_presize_handler (tree_view);
8189     }
8190   else
8191     {
8192       /* make sure all columns are of type FIXED */
8193       for (l = tree_view->priv->columns; l; l = l->next)
8194         {
8195           GtkTreeViewColumn *c = l->data;
8196
8197           g_return_if_fail (gtk_tree_view_column_get_sizing (c) == GTK_TREE_VIEW_COLUMN_FIXED);
8198         }
8199
8200       /* yes, we really have to do this is in a separate loop */
8201       for (l = tree_view->priv->columns; l; l = l->next)
8202         g_signal_connect (l->data, "notify::sizing",
8203                           G_CALLBACK (column_sizing_notify), tree_view);
8204
8205       tree_view->priv->fixed_height_mode = 1;
8206       tree_view->priv->fixed_height = -1;
8207
8208       if (tree_view->priv->tree)
8209         initialize_fixed_height_mode (tree_view);
8210     }
8211
8212   g_object_notify (G_OBJECT (tree_view), "fixed-height-mode");
8213 }
8214
8215 /**
8216  * gtk_tree_view_get_fixed_height_mode:
8217  * @tree_view: a #GtkTreeView
8218  *
8219  * Returns whether fixed height mode is turned on for @tree_view.
8220  *
8221  * Return value: %TRUE if @tree_view is in fixed height mode
8222  *
8223  * Since: 2.6
8224  **/
8225 gboolean
8226 gtk_tree_view_get_fixed_height_mode (GtkTreeView *tree_view)
8227 {
8228   return tree_view->priv->fixed_height_mode;
8229 }
8230
8231 /* Returns TRUE if the focus is within the headers, after the focus operation is
8232  * done
8233  */
8234 static gboolean
8235 gtk_tree_view_header_focus (GtkTreeView      *tree_view,
8236                             GtkDirectionType  dir,
8237                             gboolean          clamp_column_visible)
8238 {
8239   GtkTreeViewColumn *column;
8240   GtkWidget *focus_child;
8241   GtkWidget *button;
8242   GList *last_column, *first_column;
8243   GList *tmp_list;
8244   gboolean rtl;
8245
8246   if (! tree_view->priv->headers_visible)
8247     return FALSE;
8248
8249   focus_child = gtk_container_get_focus_child (GTK_CONTAINER (tree_view));
8250
8251   first_column = tree_view->priv->columns;
8252   while (first_column)
8253     {
8254       column = GTK_TREE_VIEW_COLUMN (first_column->data);
8255       button = gtk_tree_view_column_get_button (column);
8256
8257       if (gtk_widget_get_can_focus (button) &&
8258           gtk_tree_view_column_get_visible (column) &&
8259           (gtk_tree_view_column_get_clickable (column) ||
8260            gtk_tree_view_column_get_reorderable (column)))
8261         break;
8262       first_column = first_column->next;
8263     }
8264
8265   /* No headers are visible, or are focusable.  We can't focus in or out.
8266    */
8267   if (first_column == NULL)
8268     return FALSE;
8269
8270   last_column = g_list_last (tree_view->priv->columns);
8271   while (last_column)
8272     {
8273       column = GTK_TREE_VIEW_COLUMN (last_column->data);
8274       button = gtk_tree_view_column_get_button (column);
8275
8276       if (gtk_widget_get_can_focus (button) &&
8277           gtk_tree_view_column_get_visible (column) &&
8278           (gtk_tree_view_column_get_clickable (column) ||
8279            gtk_tree_view_column_get_reorderable (column)))
8280         break;
8281       last_column = last_column->prev;
8282     }
8283
8284
8285   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
8286
8287   switch (dir)
8288     {
8289     case GTK_DIR_TAB_BACKWARD:
8290     case GTK_DIR_TAB_FORWARD:
8291     case GTK_DIR_UP:
8292     case GTK_DIR_DOWN:
8293       if (focus_child == NULL)
8294         {
8295           if (tree_view->priv->focus_column != NULL)
8296             button = gtk_tree_view_column_get_button (tree_view->priv->focus_column);
8297           else
8298             button = NULL;
8299
8300           if (button && gtk_widget_get_can_focus (button))
8301             focus_child = button;
8302           else
8303             focus_child = gtk_tree_view_column_get_button (GTK_TREE_VIEW_COLUMN (first_column->data));
8304
8305           gtk_widget_grab_focus (focus_child);
8306           break;
8307         }
8308       return FALSE;
8309
8310     case GTK_DIR_LEFT:
8311     case GTK_DIR_RIGHT:
8312       if (focus_child == NULL)
8313         {
8314           if (tree_view->priv->focus_column != NULL)
8315             focus_child = gtk_tree_view_column_get_button (tree_view->priv->focus_column);
8316           else if (dir == GTK_DIR_LEFT)
8317             focus_child = gtk_tree_view_column_get_button (GTK_TREE_VIEW_COLUMN (last_column->data));
8318           else
8319             focus_child = gtk_tree_view_column_get_button (GTK_TREE_VIEW_COLUMN (first_column->data));
8320
8321           gtk_widget_grab_focus (focus_child);
8322           break;
8323         }
8324
8325       if (gtk_widget_child_focus (focus_child, dir))
8326         {
8327           /* The focus moves inside the button. */
8328           /* This is probably a great example of bad UI */
8329           break;
8330         }
8331
8332       /* We need to move the focus among the row of buttons. */
8333       for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list = tmp_list->next)
8334         if (gtk_tree_view_column_get_button (GTK_TREE_VIEW_COLUMN (tmp_list->data)) == focus_child)
8335           break;
8336
8337       if ((tmp_list == first_column && dir == (rtl ? GTK_DIR_RIGHT : GTK_DIR_LEFT))
8338           || (tmp_list == last_column && dir == (rtl ? GTK_DIR_LEFT : GTK_DIR_RIGHT)))
8339         {
8340           gtk_widget_error_bell (GTK_WIDGET (tree_view));
8341           break;
8342         }
8343
8344       while (tmp_list)
8345         {
8346           GtkTreeViewColumn *column;
8347           GtkWidget         *button;
8348
8349           if (dir == (rtl ? GTK_DIR_LEFT : GTK_DIR_RIGHT))
8350             tmp_list = tmp_list->next;
8351           else
8352             tmp_list = tmp_list->prev;
8353
8354           if (tmp_list == NULL)
8355             {
8356               g_warning ("Internal button not found");
8357               break;
8358             }
8359           column = tmp_list->data;
8360           button = gtk_tree_view_column_get_button (column);
8361           if (button &&
8362               gtk_tree_view_column_get_visible (column) &&
8363               gtk_widget_get_can_focus (button))
8364             {
8365               focus_child = button;
8366               gtk_widget_grab_focus (button);
8367               break;
8368             }
8369         }
8370       break;
8371     default:
8372       g_assert_not_reached ();
8373       break;
8374     }
8375
8376   /* if focus child is non-null, we assume it's been set to the current focus child
8377    */
8378   if (focus_child)
8379     {
8380       for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list = tmp_list->next)
8381         if (gtk_tree_view_column_get_button (GTK_TREE_VIEW_COLUMN (tmp_list->data)) == focus_child)
8382           {
8383             tree_view->priv->focus_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
8384             break;
8385           }
8386
8387       if (clamp_column_visible)
8388         {
8389           gtk_tree_view_clamp_column_visible (tree_view,
8390                                               tree_view->priv->focus_column,
8391                                               FALSE);
8392         }
8393     }
8394
8395   return (focus_child != NULL);
8396 }
8397
8398 /* This function returns in 'path' the first focusable path, if the given path
8399  * is already focusable, it's the returned one.
8400  */
8401 static gboolean
8402 search_first_focusable_path (GtkTreeView  *tree_view,
8403                              GtkTreePath **path,
8404                              gboolean      search_forward,
8405                              GtkRBTree   **new_tree,
8406                              GtkRBNode   **new_node)
8407 {
8408   GtkRBTree *tree = NULL;
8409   GtkRBNode *node = NULL;
8410
8411   if (!path || !*path)
8412     return FALSE;
8413
8414   _gtk_tree_view_find_node (tree_view, *path, &tree, &node);
8415
8416   if (!tree || !node)
8417     return FALSE;
8418
8419   while (node && row_is_separator (tree_view, NULL, *path))
8420     {
8421       if (search_forward)
8422         _gtk_rbtree_next_full (tree, node, &tree, &node);
8423       else
8424         _gtk_rbtree_prev_full (tree, node, &tree, &node);
8425
8426       if (*path)
8427         gtk_tree_path_free (*path);
8428
8429       if (node)
8430         *path = _gtk_tree_view_find_path (tree_view, tree, node);
8431       else
8432         *path = NULL;
8433     }
8434
8435   if (new_tree)
8436     *new_tree = tree;
8437
8438   if (new_node)
8439     *new_node = node;
8440
8441   return (*path != NULL);
8442 }
8443
8444 static gint
8445 gtk_tree_view_focus (GtkWidget        *widget,
8446                      GtkDirectionType  direction)
8447 {
8448   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
8449   GtkContainer *container = GTK_CONTAINER (widget);
8450   GtkWidget *focus_child;
8451
8452   if (!gtk_widget_is_sensitive (widget) || !gtk_widget_get_can_focus (widget))
8453     return FALSE;
8454
8455   focus_child = gtk_container_get_focus_child (container);
8456
8457   gtk_tree_view_stop_editing (GTK_TREE_VIEW (widget), FALSE);
8458   /* Case 1.  Headers currently have focus. */
8459   if (focus_child)
8460     {
8461       switch (direction)
8462         {
8463         case GTK_DIR_LEFT:
8464         case GTK_DIR_RIGHT:
8465           gtk_tree_view_header_focus (tree_view, direction, TRUE);
8466           return TRUE;
8467         case GTK_DIR_TAB_BACKWARD:
8468         case GTK_DIR_UP:
8469           return FALSE;
8470         case GTK_DIR_TAB_FORWARD:
8471         case GTK_DIR_DOWN:
8472           gtk_widget_grab_focus (widget);
8473           return TRUE;
8474         default:
8475           g_assert_not_reached ();
8476           return FALSE;
8477         }
8478     }
8479
8480   /* Case 2. We don't have focus at all. */
8481   if (!gtk_widget_has_focus (widget))
8482     {
8483       gtk_widget_grab_focus (widget);
8484       return TRUE;
8485     }
8486
8487   /* Case 3. We have focus already. */
8488   if (direction == GTK_DIR_TAB_BACKWARD)
8489     return (gtk_tree_view_header_focus (tree_view, direction, FALSE));
8490   else if (direction == GTK_DIR_TAB_FORWARD)
8491     return FALSE;
8492
8493   /* Other directions caught by the keybindings */
8494   gtk_widget_grab_focus (widget);
8495   return TRUE;
8496 }
8497
8498 static void
8499 gtk_tree_view_grab_focus (GtkWidget *widget)
8500 {
8501   GTK_WIDGET_CLASS (gtk_tree_view_parent_class)->grab_focus (widget);
8502
8503   gtk_tree_view_focus_to_cursor (GTK_TREE_VIEW (widget));
8504 }
8505
8506 static void
8507 gtk_tree_view_style_set (GtkWidget *widget,
8508                          GtkStyle *previous_style)
8509 {
8510   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
8511   GtkStyle *style;
8512   GList *list;
8513   GtkTreeViewColumn *column;
8514
8515   if (gtk_widget_get_realized (widget))
8516     {
8517       style = gtk_widget_get_style (widget);
8518       gdk_window_set_background (tree_view->priv->bin_window,
8519                                  &style->base[gtk_widget_get_state (widget)]);
8520       gtk_style_set_background (style, tree_view->priv->header_window, GTK_STATE_NORMAL);
8521
8522       gtk_tree_view_set_grid_lines (tree_view, tree_view->priv->grid_lines);
8523       gtk_tree_view_set_enable_tree_lines (tree_view, tree_view->priv->tree_lines_enabled);
8524     }
8525
8526   gtk_widget_style_get (widget,
8527                         "expander-size", &tree_view->priv->expander_size,
8528                         NULL);
8529   tree_view->priv->expander_size += EXPANDER_EXTRA_PADDING;
8530
8531   for (list = tree_view->priv->columns; list; list = list->next)
8532     {
8533       column = list->data;
8534       _gtk_tree_view_column_cell_set_dirty (column, TRUE);
8535     }
8536
8537   tree_view->priv->fixed_height = -1;
8538   _gtk_rbtree_mark_invalid (tree_view->priv->tree);
8539
8540   gtk_widget_queue_resize (widget);
8541 }
8542
8543
8544 static void
8545 gtk_tree_view_set_focus_child (GtkContainer *container,
8546                                GtkWidget    *child)
8547 {
8548   GtkTreeView *tree_view = GTK_TREE_VIEW (container);
8549   GList *list;
8550
8551   for (list = tree_view->priv->columns; list; list = list->next)
8552     {
8553       if (gtk_tree_view_column_get_button (GTK_TREE_VIEW_COLUMN (list->data)) == child)
8554         {
8555           tree_view->priv->focus_column = GTK_TREE_VIEW_COLUMN (list->data);
8556           break;
8557         }
8558     }
8559
8560   GTK_CONTAINER_CLASS (gtk_tree_view_parent_class)->set_focus_child (container, child);
8561 }
8562
8563 static gboolean
8564 gtk_tree_view_real_move_cursor (GtkTreeView       *tree_view,
8565                                 GtkMovementStep    step,
8566                                 gint               count)
8567 {
8568   GdkModifierType state;
8569
8570   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
8571   g_return_val_if_fail (step == GTK_MOVEMENT_LOGICAL_POSITIONS ||
8572                         step == GTK_MOVEMENT_VISUAL_POSITIONS ||
8573                         step == GTK_MOVEMENT_DISPLAY_LINES ||
8574                         step == GTK_MOVEMENT_PAGES ||
8575                         step == GTK_MOVEMENT_BUFFER_ENDS, FALSE);
8576
8577   if (tree_view->priv->tree == NULL)
8578     return FALSE;
8579   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
8580     return FALSE;
8581
8582   gtk_tree_view_stop_editing (tree_view, FALSE);
8583   tree_view->priv->draw_keyfocus = TRUE;
8584   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
8585
8586   if (gtk_get_current_event_state (&state))
8587     {
8588       if ((state & GDK_CONTROL_MASK) == GDK_CONTROL_MASK)
8589         tree_view->priv->ctrl_pressed = TRUE;
8590       if ((state & GDK_SHIFT_MASK) == GDK_SHIFT_MASK)
8591         tree_view->priv->shift_pressed = TRUE;
8592     }
8593   /* else we assume not pressed */
8594
8595   switch (step)
8596     {
8597       /* currently we make no distinction.  When we go bi-di, we need to */
8598     case GTK_MOVEMENT_LOGICAL_POSITIONS:
8599     case GTK_MOVEMENT_VISUAL_POSITIONS:
8600       gtk_tree_view_move_cursor_left_right (tree_view, count);
8601       break;
8602     case GTK_MOVEMENT_DISPLAY_LINES:
8603       gtk_tree_view_move_cursor_up_down (tree_view, count);
8604       break;
8605     case GTK_MOVEMENT_PAGES:
8606       gtk_tree_view_move_cursor_page_up_down (tree_view, count);
8607       break;
8608     case GTK_MOVEMENT_BUFFER_ENDS:
8609       gtk_tree_view_move_cursor_start_end (tree_view, count);
8610       break;
8611     default:
8612       g_assert_not_reached ();
8613     }
8614
8615   tree_view->priv->ctrl_pressed = FALSE;
8616   tree_view->priv->shift_pressed = FALSE;
8617
8618   return TRUE;
8619 }
8620
8621 static void
8622 gtk_tree_view_put (GtkTreeView *tree_view,
8623                    GtkWidget   *child_widget,
8624                    /* in bin_window coordinates */
8625                    gint         x,
8626                    gint         y,
8627                    gint         width,
8628                    gint         height)
8629 {
8630   GtkTreeViewChild *child;
8631
8632   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
8633   g_return_if_fail (GTK_IS_WIDGET (child_widget));
8634
8635   child = g_slice_new (GtkTreeViewChild);
8636
8637   child->widget = child_widget;
8638   child->x = x;
8639   child->y = y;
8640   child->width = width;
8641   child->height = height;
8642
8643   tree_view->priv->children = g_list_append (tree_view->priv->children, child);
8644
8645   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
8646     gtk_widget_set_parent_window (child->widget, tree_view->priv->bin_window);
8647
8648   gtk_widget_set_parent (child_widget, GTK_WIDGET (tree_view));
8649 }
8650
8651 void
8652 _gtk_tree_view_child_move_resize (GtkTreeView *tree_view,
8653                                   GtkWidget   *widget,
8654                                   /* in tree coordinates */
8655                                   gint         x,
8656                                   gint         y,
8657                                   gint         width,
8658                                   gint         height)
8659 {
8660   GtkTreeViewChild *child = NULL;
8661   GList *list;
8662   GdkRectangle allocation;
8663
8664   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
8665   g_return_if_fail (GTK_IS_WIDGET (widget));
8666
8667   for (list = tree_view->priv->children; list; list = list->next)
8668     {
8669       if (((GtkTreeViewChild *)list->data)->widget == widget)
8670         {
8671           child = list->data;
8672           break;
8673         }
8674     }
8675   if (child == NULL)
8676     return;
8677
8678   allocation.x = child->x = x;
8679   allocation.y = child->y = y;
8680   allocation.width = child->width = width;
8681   allocation.height = child->height = height;
8682
8683   if (gtk_widget_get_realized (widget))
8684     gtk_widget_size_allocate (widget, &allocation);
8685 }
8686
8687
8688 /* TreeModel Callbacks
8689  */
8690
8691 static void
8692 gtk_tree_view_row_changed (GtkTreeModel *model,
8693                            GtkTreePath  *path,
8694                            GtkTreeIter  *iter,
8695                            gpointer      data)
8696 {
8697   GtkTreeView *tree_view = (GtkTreeView *)data;
8698   GtkRBTree *tree;
8699   GtkRBNode *node;
8700   gboolean free_path = FALSE;
8701   GList *list;
8702   GtkTreePath *cursor_path;
8703
8704   g_return_if_fail (path != NULL || iter != NULL);
8705
8706   if (tree_view->priv->cursor != NULL)
8707     cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
8708   else
8709     cursor_path = NULL;
8710
8711   if (tree_view->priv->edited_column &&
8712       (cursor_path == NULL || gtk_tree_path_compare (cursor_path, path) == 0))
8713     gtk_tree_view_stop_editing (tree_view, TRUE);
8714
8715   if (cursor_path != NULL)
8716     gtk_tree_path_free (cursor_path);
8717
8718   if (path == NULL)
8719     {
8720       path = gtk_tree_model_get_path (model, iter);
8721       free_path = TRUE;
8722     }
8723   else if (iter == NULL)
8724     gtk_tree_model_get_iter (model, iter, path);
8725
8726   if (_gtk_tree_view_find_node (tree_view,
8727                                 path,
8728                                 &tree,
8729                                 &node))
8730     /* We aren't actually showing the node */
8731     goto done;
8732
8733   if (tree == NULL)
8734     goto done;
8735
8736   if (tree_view->priv->fixed_height_mode
8737       && tree_view->priv->fixed_height >= 0)
8738     {
8739       _gtk_rbtree_node_set_height (tree, node, tree_view->priv->fixed_height);
8740       if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
8741         gtk_tree_view_node_queue_redraw (tree_view, tree, node);
8742     }
8743   else
8744     {
8745       _gtk_rbtree_node_mark_invalid (tree, node);
8746       for (list = tree_view->priv->columns; list; list = list->next)
8747         {
8748           GtkTreeViewColumn *column;
8749
8750           column = list->data;
8751           if (!gtk_tree_view_column_get_visible (column))
8752             continue;
8753
8754           if (gtk_tree_view_column_get_sizing (column) == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
8755             {
8756               _gtk_tree_view_column_cell_set_dirty (column, TRUE);
8757             }
8758         }
8759     }
8760
8761  done:
8762   if (!tree_view->priv->fixed_height_mode &&
8763       gtk_widget_get_realized (GTK_WIDGET (tree_view)))
8764     install_presize_handler (tree_view);
8765   if (free_path)
8766     gtk_tree_path_free (path);
8767 }
8768
8769 static void
8770 gtk_tree_view_row_inserted (GtkTreeModel *model,
8771                             GtkTreePath  *path,
8772                             GtkTreeIter  *iter,
8773                             gpointer      data)
8774 {
8775   GtkTreeView *tree_view = (GtkTreeView *) data;
8776   gint *indices;
8777   GtkRBTree *tmptree, *tree;
8778   GtkRBNode *tmpnode = NULL;
8779   gint depth;
8780   gint i = 0;
8781   gint height;
8782   gboolean free_path = FALSE;
8783   gboolean node_visible = TRUE;
8784
8785   g_return_if_fail (path != NULL || iter != NULL);
8786
8787   if (tree_view->priv->fixed_height_mode
8788       && tree_view->priv->fixed_height >= 0)
8789     height = tree_view->priv->fixed_height;
8790   else
8791     height = 0;
8792
8793   if (path == NULL)
8794     {
8795       path = gtk_tree_model_get_path (model, iter);
8796       free_path = TRUE;
8797     }
8798   else if (iter == NULL)
8799     gtk_tree_model_get_iter (model, iter, path);
8800
8801   if (tree_view->priv->tree == NULL)
8802     tree_view->priv->tree = _gtk_rbtree_new ();
8803
8804   tmptree = tree = tree_view->priv->tree;
8805
8806   /* Update all row-references */
8807   gtk_tree_row_reference_inserted (G_OBJECT (data), path);
8808   depth = gtk_tree_path_get_depth (path);
8809   indices = gtk_tree_path_get_indices (path);
8810
8811   /* First, find the parent tree */
8812   while (i < depth - 1)
8813     {
8814       if (tmptree == NULL)
8815         {
8816           /* We aren't showing the node */
8817           node_visible = FALSE;
8818           goto done;
8819         }
8820
8821       tmpnode = _gtk_rbtree_find_count (tmptree, indices[i] + 1);
8822       if (tmpnode == NULL)
8823         {
8824           g_warning ("A node was inserted with a parent that's not in the tree.\n" \
8825                      "This possibly means that a GtkTreeModel inserted a child node\n" \
8826                      "before the parent was inserted.");
8827           goto done;
8828         }
8829       else if (!GTK_RBNODE_FLAG_SET (tmpnode, GTK_RBNODE_IS_PARENT))
8830         {
8831           /* FIXME enforce correct behavior on model, probably */
8832           /* In theory, the model should have emitted has_child_toggled here.  We
8833            * try to catch it anyway, just to be safe, in case the model hasn't.
8834            */
8835           GtkTreePath *tmppath = _gtk_tree_view_find_path (tree_view,
8836                                                            tree,
8837                                                            tmpnode);
8838           gtk_tree_view_row_has_child_toggled (model, tmppath, NULL, data);
8839           gtk_tree_path_free (tmppath);
8840           goto done;
8841         }
8842
8843       tmptree = tmpnode->children;
8844       tree = tmptree;
8845       i++;
8846     }
8847
8848   if (tree == NULL)
8849     {
8850       node_visible = FALSE;
8851       goto done;
8852     }
8853
8854   /* ref the node */
8855   gtk_tree_model_ref_node (tree_view->priv->model, iter);
8856   if (indices[depth - 1] == 0)
8857     {
8858       tmpnode = _gtk_rbtree_find_count (tree, 1);
8859       tmpnode = _gtk_rbtree_insert_before (tree, tmpnode, height, FALSE);
8860     }
8861   else
8862     {
8863       tmpnode = _gtk_rbtree_find_count (tree, indices[depth - 1]);
8864       tmpnode = _gtk_rbtree_insert_after (tree, tmpnode, height, FALSE);
8865     }
8866
8867  done:
8868   if (height > 0)
8869     {
8870       if (tree)
8871         _gtk_rbtree_node_mark_valid (tree, tmpnode);
8872
8873       if (node_visible && node_is_visible (tree_view, tree, tmpnode))
8874         gtk_widget_queue_resize (GTK_WIDGET (tree_view));
8875       else
8876         gtk_widget_queue_resize_no_redraw (GTK_WIDGET (tree_view));
8877     }
8878   else
8879     install_presize_handler (tree_view);
8880   if (free_path)
8881     gtk_tree_path_free (path);
8882 }
8883
8884 static void
8885 gtk_tree_view_row_has_child_toggled (GtkTreeModel *model,
8886                                      GtkTreePath  *path,
8887                                      GtkTreeIter  *iter,
8888                                      gpointer      data)
8889 {
8890   GtkTreeView *tree_view = (GtkTreeView *)data;
8891   GtkTreeIter real_iter;
8892   gboolean has_child;
8893   GtkRBTree *tree;
8894   GtkRBNode *node;
8895   gboolean free_path = FALSE;
8896
8897   g_return_if_fail (path != NULL || iter != NULL);
8898
8899   if (iter)
8900     real_iter = *iter;
8901
8902   if (path == NULL)
8903     {
8904       path = gtk_tree_model_get_path (model, iter);
8905       free_path = TRUE;
8906     }
8907   else if (iter == NULL)
8908     gtk_tree_model_get_iter (model, &real_iter, path);
8909
8910   if (_gtk_tree_view_find_node (tree_view,
8911                                 path,
8912                                 &tree,
8913                                 &node))
8914     /* We aren't actually showing the node */
8915     goto done;
8916
8917   if (tree == NULL)
8918     goto done;
8919
8920   has_child = gtk_tree_model_iter_has_child (model, &real_iter);
8921   /* Sanity check.
8922    */
8923   if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT) == has_child)
8924     goto done;
8925
8926   if (has_child)
8927     GTK_RBNODE_SET_FLAG (node, GTK_RBNODE_IS_PARENT);
8928   else
8929     GTK_RBNODE_UNSET_FLAG (node, GTK_RBNODE_IS_PARENT);
8930
8931   if (has_child && tree_view->priv->is_list)
8932     {
8933       tree_view->priv->is_list = FALSE;
8934       if (tree_view->priv->show_expanders)
8935         {
8936           GList *list;
8937
8938           for (list = tree_view->priv->columns; list; list = list->next)
8939             if (gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (list->data)))
8940               {
8941                 _gtk_tree_view_column_cell_set_dirty (GTK_TREE_VIEW_COLUMN (list->data), TRUE);
8942                 break;
8943               }
8944         }
8945       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
8946     }
8947   else
8948     {
8949       _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
8950     }
8951
8952  done:
8953   if (free_path)
8954     gtk_tree_path_free (path);
8955 }
8956
8957 static void
8958 count_children_helper (GtkRBTree *tree,
8959                        GtkRBNode *node,
8960                        gpointer   data)
8961 {
8962   if (node->children)
8963     _gtk_rbtree_traverse (node->children, node->children->root, G_POST_ORDER, count_children_helper, data);
8964   (*((gint *)data))++;
8965 }
8966
8967 static void
8968 check_selection_helper (GtkRBTree *tree,
8969                         GtkRBNode *node,
8970                         gpointer   data)
8971 {
8972   gint *value = (gint *)data;
8973
8974   *value = GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED);
8975
8976   if (node->children && !*value)
8977     _gtk_rbtree_traverse (node->children, node->children->root, G_POST_ORDER, check_selection_helper, data);
8978 }
8979
8980 static void
8981 gtk_tree_view_row_deleted (GtkTreeModel *model,
8982                            GtkTreePath  *path,
8983                            gpointer      data)
8984 {
8985   GtkTreeView *tree_view = (GtkTreeView *)data;
8986   GtkRBTree *tree;
8987   GtkRBNode *node;
8988   GList *list;
8989   gint selection_changed = FALSE;
8990
8991   g_return_if_fail (path != NULL);
8992
8993   gtk_tree_row_reference_deleted (G_OBJECT (data), path);
8994
8995   if (_gtk_tree_view_find_node (tree_view, path, &tree, &node))
8996     return;
8997
8998   if (tree == NULL)
8999     return;
9000
9001   /* check if the selection has been changed */
9002   _gtk_rbtree_traverse (tree, node, G_POST_ORDER,
9003                         check_selection_helper, &selection_changed);
9004
9005   for (list = tree_view->priv->columns; list; list = list->next)
9006     if (gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (list->data)) &&
9007         gtk_tree_view_column_get_sizing (GTK_TREE_VIEW_COLUMN (list->data)) == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
9008       _gtk_tree_view_column_cell_set_dirty ((GtkTreeViewColumn *)list->data, TRUE);
9009
9010   /* Ensure we don't have a dangling pointer to a dead node */
9011   ensure_unprelighted (tree_view);
9012
9013   /* Cancel editting if we've started */
9014   gtk_tree_view_stop_editing (tree_view, TRUE);
9015
9016   /* If we have a node expanded/collapsed timeout, remove it */
9017   remove_expand_collapse_timeout (tree_view);
9018
9019   if (tree_view->priv->destroy_count_func)
9020     {
9021       gint child_count = 0;
9022       if (node->children)
9023         _gtk_rbtree_traverse (node->children, node->children->root, G_POST_ORDER, count_children_helper, &child_count);
9024       tree_view->priv->destroy_count_func (tree_view, path, child_count, tree_view->priv->destroy_count_data);
9025     }
9026
9027   if (tree->root->count == 1)
9028     {
9029       if (tree_view->priv->tree == tree)
9030         tree_view->priv->tree = NULL;
9031
9032       _gtk_rbtree_remove (tree);
9033     }
9034   else
9035     {
9036       _gtk_rbtree_remove_node (tree, node);
9037     }
9038
9039   if (! gtk_tree_row_reference_valid (tree_view->priv->top_row))
9040     {
9041       gtk_tree_row_reference_free (tree_view->priv->top_row);
9042       tree_view->priv->top_row = NULL;
9043     }
9044
9045   install_scroll_sync_handler (tree_view);
9046
9047   gtk_widget_queue_resize (GTK_WIDGET (tree_view));
9048
9049   if (selection_changed)
9050     g_signal_emit_by_name (tree_view->priv->selection, "changed");
9051 }
9052
9053 static void
9054 gtk_tree_view_rows_reordered (GtkTreeModel *model,
9055                               GtkTreePath  *parent,
9056                               GtkTreeIter  *iter,
9057                               gint         *new_order,
9058                               gpointer      data)
9059 {
9060   GtkTreeView *tree_view = GTK_TREE_VIEW (data);
9061   GtkRBTree *tree;
9062   GtkRBNode *node;
9063   gint len;
9064
9065   len = gtk_tree_model_iter_n_children (model, iter);
9066
9067   if (len < 2)
9068     return;
9069
9070   gtk_tree_row_reference_reordered (G_OBJECT (data),
9071                                     parent,
9072                                     iter,
9073                                     new_order);
9074
9075   if (_gtk_tree_view_find_node (tree_view,
9076                                 parent,
9077                                 &tree,
9078                                 &node))
9079     return;
9080
9081   /* We need to special case the parent path */
9082   if (tree == NULL)
9083     tree = tree_view->priv->tree;
9084   else
9085     tree = node->children;
9086
9087   if (tree == NULL)
9088     return;
9089
9090   if (tree_view->priv->edited_column)
9091     gtk_tree_view_stop_editing (tree_view, TRUE);
9092
9093   /* we need to be unprelighted */
9094   ensure_unprelighted (tree_view);
9095
9096   /* clear the timeout */
9097   cancel_arrow_animation (tree_view);
9098
9099   _gtk_rbtree_reorder (tree, new_order, len);
9100
9101   gtk_widget_queue_draw (GTK_WIDGET (tree_view));
9102
9103   gtk_tree_view_dy_to_top_row (tree_view);
9104 }
9105
9106
9107 /* Internal tree functions
9108  */
9109
9110
9111 static void
9112 gtk_tree_view_get_background_xrange (GtkTreeView       *tree_view,
9113                                      GtkRBTree         *tree,
9114                                      GtkTreeViewColumn *column,
9115                                      gint              *x1,
9116                                      gint              *x2)
9117 {
9118   GtkTreeViewColumn *tmp_column = NULL;
9119   gint total_width;
9120   GList *list;
9121   gboolean rtl;
9122
9123   if (x1)
9124     *x1 = 0;
9125
9126   if (x2)
9127     *x2 = 0;
9128
9129   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
9130
9131   total_width = 0;
9132   for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
9133        list;
9134        list = (rtl ? list->prev : list->next))
9135     {
9136       tmp_column = list->data;
9137
9138       if (tmp_column == column)
9139         break;
9140
9141       if (gtk_tree_view_column_get_visible (tmp_column))
9142         total_width += gtk_tree_view_column_get_width (tmp_column);
9143     }
9144
9145   if (tmp_column != column)
9146     {
9147       g_warning (G_STRLOC": passed-in column isn't in the tree");
9148       return;
9149     }
9150
9151   if (x1)
9152     *x1 = total_width;
9153
9154   if (x2)
9155     {
9156       if (gtk_tree_view_column_get_visible (column))
9157         *x2 = total_width + gtk_tree_view_column_get_width (column);
9158       else
9159         *x2 = total_width; /* width of 0 */
9160     }
9161 }
9162
9163 static void
9164 gtk_tree_view_get_arrow_xrange (GtkTreeView *tree_view,
9165                                 GtkRBTree   *tree,
9166                                 gint        *x1,
9167                                 gint        *x2)
9168 {
9169   gint x_offset = 0;
9170   GList *list;
9171   GtkTreeViewColumn *tmp_column = NULL;
9172   gint total_width;
9173   gboolean indent_expanders;
9174   gboolean rtl;
9175
9176   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
9177
9178   total_width = 0;
9179   for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
9180        list;
9181        list = (rtl ? list->prev : list->next))
9182     {
9183       tmp_column = list->data;
9184
9185       if (gtk_tree_view_is_expander_column (tree_view, tmp_column))
9186         {
9187           if (rtl)
9188             x_offset = total_width + gtk_tree_view_column_get_width (tmp_column) - tree_view->priv->expander_size;
9189           else
9190             x_offset = total_width;
9191           break;
9192         }
9193
9194       if (gtk_tree_view_column_get_visible (tmp_column))
9195         total_width += gtk_tree_view_column_get_width (tmp_column);
9196     }
9197
9198   gtk_widget_style_get (GTK_WIDGET (tree_view),
9199                         "indent-expanders", &indent_expanders,
9200                         NULL);
9201
9202   if (indent_expanders)
9203     {
9204       if (rtl)
9205         x_offset -= tree_view->priv->expander_size * _gtk_rbtree_get_depth (tree);
9206       else
9207         x_offset += tree_view->priv->expander_size * _gtk_rbtree_get_depth (tree);
9208     }
9209
9210   *x1 = x_offset;
9211
9212   if (tmp_column &&
9213       gtk_tree_view_column_get_visible (tmp_column))
9214     /* +1 because x2 isn't included in the range. */
9215     *x2 = *x1 + tree_view->priv->expander_size + 1;
9216   else
9217     *x2 = *x1;
9218 }
9219
9220 static void
9221 gtk_tree_view_build_tree (GtkTreeView *tree_view,
9222                           GtkRBTree   *tree,
9223                           GtkTreeIter *iter,
9224                           gint         depth,
9225                           gboolean     recurse)
9226 {
9227   GtkRBNode *temp = NULL;
9228   GtkTreePath *path = NULL;
9229
9230   do
9231     {
9232       gtk_tree_model_ref_node (tree_view->priv->model, iter);
9233       temp = _gtk_rbtree_insert_after (tree, temp, 0, FALSE);
9234
9235       if (tree_view->priv->fixed_height > 0)
9236         {
9237           if (GTK_RBNODE_FLAG_SET (temp, GTK_RBNODE_INVALID))
9238             {
9239               _gtk_rbtree_node_set_height (tree, temp, tree_view->priv->fixed_height);
9240               _gtk_rbtree_node_mark_valid (tree, temp);
9241             }
9242         }
9243
9244       if (tree_view->priv->is_list)
9245         continue;
9246
9247       if (recurse)
9248         {
9249           GtkTreeIter child;
9250
9251           if (!path)
9252             path = gtk_tree_model_get_path (tree_view->priv->model, iter);
9253           else
9254             gtk_tree_path_next (path);
9255
9256           if (gtk_tree_model_iter_children (tree_view->priv->model, &child, iter))
9257             {
9258               gboolean expand;
9259
9260               g_signal_emit (tree_view, tree_view_signals[TEST_EXPAND_ROW], 0, iter, path, &expand);
9261
9262               if (gtk_tree_model_iter_has_child (tree_view->priv->model, iter)
9263                   && !expand)
9264                 {
9265                   temp->children = _gtk_rbtree_new ();
9266                   temp->children->parent_tree = tree;
9267                   temp->children->parent_node = temp;
9268                   gtk_tree_view_build_tree (tree_view, temp->children, &child, depth + 1, recurse);
9269                 }
9270             }
9271         }
9272
9273       if (gtk_tree_model_iter_has_child (tree_view->priv->model, iter))
9274         {
9275           if ((temp->flags&GTK_RBNODE_IS_PARENT) != GTK_RBNODE_IS_PARENT)
9276             temp->flags ^= GTK_RBNODE_IS_PARENT;
9277         }
9278     }
9279   while (gtk_tree_model_iter_next (tree_view->priv->model, iter));
9280
9281   if (path)
9282     gtk_tree_path_free (path);
9283 }
9284
9285 /* Make sure the node is visible vertically */
9286 static void
9287 gtk_tree_view_clamp_node_visible (GtkTreeView *tree_view,
9288                                   GtkRBTree   *tree,
9289                                   GtkRBNode   *node)
9290 {
9291   gint node_dy, height;
9292   GtkTreePath *path = NULL;
9293
9294   if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
9295     return;
9296
9297   /* just return if the node is visible, avoiding a costly expose */
9298   node_dy = _gtk_rbtree_node_find_offset (tree, node);
9299   height = gtk_tree_view_get_row_height (tree_view, node);
9300   if (! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID)
9301       && node_dy >= tree_view->priv->vadjustment->value
9302       && node_dy + height <= (tree_view->priv->vadjustment->value
9303                               + tree_view->priv->vadjustment->page_size))
9304     return;
9305
9306   path = _gtk_tree_view_find_path (tree_view, tree, node);
9307   if (path)
9308     {
9309       /* We process updates because we want to clear old selected items when we scroll.
9310        * if this is removed, we get a "selection streak" at the bottom. */
9311       gtk_tree_view_bin_process_updates (tree_view);
9312
9313       gtk_tree_view_scroll_to_cell (tree_view, path, NULL, FALSE, 0.0, 0.0);
9314       gtk_tree_path_free (path);
9315     }
9316 }
9317
9318 static void
9319 gtk_tree_view_clamp_column_visible (GtkTreeView       *tree_view,
9320                                     GtkTreeViewColumn *column,
9321                                     gboolean           focus_to_cell)
9322 {
9323   GtkAllocation allocation;
9324   gint x, width;
9325
9326   if (column == NULL)
9327     return;
9328
9329   gtk_widget_get_allocation (gtk_tree_view_column_get_button (column), &allocation);
9330   x = allocation.x;
9331   width = allocation.width;
9332
9333   if (width > tree_view->priv->hadjustment->page_size)
9334     {
9335       /* The column is larger than the horizontal page size.  If the
9336        * column has cells which can be focussed individually, then we make
9337        * sure the cell which gets focus is fully visible (if even the
9338        * focus cell is bigger than the page size, we make sure the
9339        * left-hand side of the cell is visible).
9340        *
9341        * If the column does not have an activatable cell, we
9342        * make sure the left-hand side of the column is visible.
9343        */
9344
9345       if (focus_to_cell && gtk_tree_view_has_can_focus_cell (tree_view))
9346         {
9347           GtkCellArea *cell_area;
9348           GtkCellRenderer *focus_cell;
9349
9350           cell_area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (column));
9351           focus_cell = gtk_cell_area_get_focus_cell (cell_area);
9352
9353           if (gtk_tree_view_column_cell_get_position (column, focus_cell,
9354                                                       &x, &width))
9355             {
9356               if (width < tree_view->priv->hadjustment->page_size)
9357                 {
9358                   if (tree_view->priv->hadjustment->value + tree_view->priv->hadjustment->page_size < x + width)
9359                     gtk_adjustment_set_value (tree_view->priv->hadjustment,
9360                                               x + width - tree_view->priv->hadjustment->page_size);
9361                   else if (tree_view->priv->hadjustment->value > x)
9362                     gtk_adjustment_set_value (tree_view->priv->hadjustment, x);
9363                 }
9364             }
9365         }
9366
9367       gtk_adjustment_set_value (tree_view->priv->hadjustment, x);
9368     }
9369   else
9370     {
9371       if ((tree_view->priv->hadjustment->value + tree_view->priv->hadjustment->page_size) < (x + width))
9372           gtk_adjustment_set_value (tree_view->priv->hadjustment,
9373                                     x + width - tree_view->priv->hadjustment->page_size);
9374       else if (tree_view->priv->hadjustment->value > x)
9375         gtk_adjustment_set_value (tree_view->priv->hadjustment, x);
9376   }
9377 }
9378
9379 /* This function could be more efficient.  I'll optimize it if profiling seems
9380  * to imply that it is important */
9381 GtkTreePath *
9382 _gtk_tree_view_find_path (GtkTreeView *tree_view,
9383                           GtkRBTree   *tree,
9384                           GtkRBNode   *node)
9385 {
9386   GtkTreePath *path;
9387   GtkRBTree *tmp_tree;
9388   GtkRBNode *tmp_node, *last;
9389   gint count;
9390
9391   path = gtk_tree_path_new ();
9392
9393   g_return_val_if_fail (node != NULL, path);
9394   g_return_val_if_fail (node != tree->nil, path);
9395
9396   count = 1 + node->left->count;
9397
9398   last = node;
9399   tmp_node = node->parent;
9400   tmp_tree = tree;
9401   while (tmp_tree)
9402     {
9403       while (tmp_node != tmp_tree->nil)
9404         {
9405           if (tmp_node->right == last)
9406             count += 1 + tmp_node->left->count;
9407           last = tmp_node;
9408           tmp_node = tmp_node->parent;
9409         }
9410       gtk_tree_path_prepend_index (path, count - 1);
9411       last = tmp_tree->parent_node;
9412       tmp_tree = tmp_tree->parent_tree;
9413       if (last)
9414         {
9415           count = 1 + last->left->count;
9416           tmp_node = last->parent;
9417         }
9418     }
9419   return path;
9420 }
9421
9422 /* Returns TRUE if we ran out of tree before finding the path.  If the path is
9423  * invalid (ie. points to a node that's not in the tree), *tree and *node are
9424  * both set to NULL.
9425  */
9426 gboolean
9427 _gtk_tree_view_find_node (GtkTreeView  *tree_view,
9428                           GtkTreePath  *path,
9429                           GtkRBTree   **tree,
9430                           GtkRBNode   **node)
9431 {
9432   GtkRBNode *tmpnode = NULL;
9433   GtkRBTree *tmptree = tree_view->priv->tree;
9434   gint *indices = gtk_tree_path_get_indices (path);
9435   gint depth = gtk_tree_path_get_depth (path);
9436   gint i = 0;
9437
9438   *node = NULL;
9439   *tree = NULL;
9440
9441   if (depth == 0 || tmptree == NULL)
9442     return FALSE;
9443   do
9444     {
9445       tmpnode = _gtk_rbtree_find_count (tmptree, indices[i] + 1);
9446       ++i;
9447       if (tmpnode == NULL)
9448         {
9449           *tree = NULL;
9450           *node = NULL;
9451           return FALSE;
9452         }
9453       if (i >= depth)
9454         {
9455           *tree = tmptree;
9456           *node = tmpnode;
9457           return FALSE;
9458         }
9459       *tree = tmptree;
9460       *node = tmpnode;
9461       tmptree = tmpnode->children;
9462       if (tmptree == NULL)
9463         return TRUE;
9464     }
9465   while (1);
9466 }
9467
9468 static gboolean
9469 gtk_tree_view_is_expander_column (GtkTreeView       *tree_view,
9470                                   GtkTreeViewColumn *column)
9471 {
9472   GList *list;
9473
9474   if (tree_view->priv->is_list)
9475     return FALSE;
9476
9477   if (tree_view->priv->expander_column != NULL)
9478     {
9479       if (tree_view->priv->expander_column == column)
9480         return TRUE;
9481       return FALSE;
9482     }
9483   else
9484     {
9485       for (list = tree_view->priv->columns;
9486            list;
9487            list = list->next)
9488         if (gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (list->data)))
9489           break;
9490       if (list && list->data == column)
9491         return TRUE;
9492     }
9493   return FALSE;
9494 }
9495
9496 static inline gboolean
9497 gtk_tree_view_draw_expanders (GtkTreeView *tree_view)
9498 {
9499   if (!tree_view->priv->is_list && tree_view->priv->show_expanders)
9500     return TRUE;
9501   /* else */
9502   return FALSE;
9503 }
9504
9505 static void
9506 gtk_tree_view_add_move_binding (GtkBindingSet  *binding_set,
9507                                 guint           keyval,
9508                                 guint           modmask,
9509                                 gboolean        add_shifted_binding,
9510                                 GtkMovementStep step,
9511                                 gint            count)
9512 {
9513
9514   gtk_binding_entry_add_signal (binding_set, keyval, modmask,
9515                                 "move-cursor", 2,
9516                                 G_TYPE_ENUM, step,
9517                                 G_TYPE_INT, count);
9518
9519   if (add_shifted_binding)
9520     gtk_binding_entry_add_signal (binding_set, keyval, GDK_SHIFT_MASK,
9521                                   "move-cursor", 2,
9522                                   G_TYPE_ENUM, step,
9523                                   G_TYPE_INT, count);
9524
9525   if ((modmask & GDK_CONTROL_MASK) == GDK_CONTROL_MASK)
9526    return;
9527
9528   gtk_binding_entry_add_signal (binding_set, keyval, GDK_CONTROL_MASK | GDK_SHIFT_MASK,
9529                                 "move-cursor", 2,
9530                                 G_TYPE_ENUM, step,
9531                                 G_TYPE_INT, count);
9532
9533   gtk_binding_entry_add_signal (binding_set, keyval, GDK_CONTROL_MASK,
9534                                 "move-cursor", 2,
9535                                 G_TYPE_ENUM, step,
9536                                 G_TYPE_INT, count);
9537 }
9538
9539 static gint
9540 gtk_tree_view_unref_tree_helper (GtkTreeModel *model,
9541                                  GtkTreeIter  *iter,
9542                                  GtkRBTree    *tree,
9543                                  GtkRBNode    *node)
9544 {
9545   gint retval = FALSE;
9546   do
9547     {
9548       g_return_val_if_fail (node != NULL, FALSE);
9549
9550       if (node->children)
9551         {
9552           GtkTreeIter child;
9553           GtkRBTree *new_tree;
9554           GtkRBNode *new_node;
9555
9556           new_tree = node->children;
9557           new_node = new_tree->root;
9558
9559           while (new_node && new_node->left != new_tree->nil)
9560             new_node = new_node->left;
9561
9562           if (!gtk_tree_model_iter_children (model, &child, iter))
9563             return FALSE;
9564
9565           retval = retval || gtk_tree_view_unref_tree_helper (model, &child, new_tree, new_node);
9566         }
9567
9568       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
9569         retval = TRUE;
9570       gtk_tree_model_unref_node (model, iter);
9571       node = _gtk_rbtree_next (tree, node);
9572     }
9573   while (gtk_tree_model_iter_next (model, iter));
9574
9575   return retval;
9576 }
9577
9578 static gint
9579 gtk_tree_view_unref_and_check_selection_tree (GtkTreeView *tree_view,
9580                                               GtkRBTree   *tree)
9581 {
9582   GtkTreeIter iter;
9583   GtkTreePath *path;
9584   GtkRBNode *node;
9585   gint retval;
9586
9587   if (!tree)
9588     return FALSE;
9589
9590   node = tree->root;
9591   while (node && node->left != tree->nil)
9592     node = node->left;
9593
9594   g_return_val_if_fail (node != NULL, FALSE);
9595   path = _gtk_tree_view_find_path (tree_view, tree, node);
9596   gtk_tree_model_get_iter (GTK_TREE_MODEL (tree_view->priv->model),
9597                            &iter, path);
9598   retval = gtk_tree_view_unref_tree_helper (GTK_TREE_MODEL (tree_view->priv->model), &iter, tree, node);
9599   gtk_tree_path_free (path);
9600
9601   return retval;
9602 }
9603
9604 static void
9605 gtk_tree_view_set_column_drag_info (GtkTreeView       *tree_view,
9606                                     GtkTreeViewColumn *column)
9607 {
9608   GtkTreeViewColumn *left_column;
9609   GtkTreeViewColumn *cur_column = NULL;
9610   GtkTreeViewColumnReorder *reorder;
9611   gboolean rtl;
9612   GList *tmp_list;
9613   gint left;
9614
9615   /* We want to precalculate the motion list such that we know what column slots
9616    * are available.
9617    */
9618   left_column = NULL;
9619   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
9620
9621   /* First, identify all possible drop spots */
9622   if (rtl)
9623     tmp_list = g_list_last (tree_view->priv->columns);
9624   else
9625     tmp_list = g_list_first (tree_view->priv->columns);
9626
9627   while (tmp_list)
9628     {
9629       cur_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
9630       tmp_list = rtl?g_list_previous (tmp_list):g_list_next (tmp_list);
9631
9632       if (gtk_tree_view_column_get_visible (cur_column) == FALSE)
9633         continue;
9634
9635       /* If it's not the column moving and func tells us to skip over the column, we continue. */
9636       if (left_column != column && cur_column != column &&
9637           tree_view->priv->column_drop_func &&
9638           ! tree_view->priv->column_drop_func (tree_view, column, left_column, cur_column, tree_view->priv->column_drop_func_data))
9639         {
9640           left_column = cur_column;
9641           continue;
9642         }
9643       reorder = g_slice_new0 (GtkTreeViewColumnReorder);
9644       reorder->left_column = left_column;
9645       left_column = reorder->right_column = cur_column;
9646
9647       tree_view->priv->column_drag_info = g_list_append (tree_view->priv->column_drag_info, reorder);
9648     }
9649
9650   /* Add the last one */
9651   if (tree_view->priv->column_drop_func == NULL ||
9652       ((left_column != column) &&
9653        tree_view->priv->column_drop_func (tree_view, column, left_column, NULL, tree_view->priv->column_drop_func_data)))
9654     {
9655       reorder = g_slice_new0 (GtkTreeViewColumnReorder);
9656       reorder->left_column = left_column;
9657       reorder->right_column = NULL;
9658       tree_view->priv->column_drag_info = g_list_append (tree_view->priv->column_drag_info, reorder);
9659     }
9660
9661   /* We quickly check to see if it even makes sense to reorder columns. */
9662   /* If there is nothing that can be moved, then we return */
9663
9664   if (tree_view->priv->column_drag_info == NULL)
9665     return;
9666
9667   /* We know there are always 2 slots possbile, as you can always return column. */
9668   /* If that's all there is, return */
9669   if (tree_view->priv->column_drag_info->next == NULL ||
9670       (tree_view->priv->column_drag_info->next->next == NULL &&
9671        ((GtkTreeViewColumnReorder *)tree_view->priv->column_drag_info->data)->right_column == column &&
9672        ((GtkTreeViewColumnReorder *)tree_view->priv->column_drag_info->next->data)->left_column == column))
9673     {
9674       for (tmp_list = tree_view->priv->column_drag_info; tmp_list; tmp_list = tmp_list->next)
9675         g_slice_free (GtkTreeViewColumnReorder, tmp_list->data);
9676       g_list_free (tree_view->priv->column_drag_info);
9677       tree_view->priv->column_drag_info = NULL;
9678       return;
9679     }
9680   /* We fill in the ranges for the columns, now that we've isolated them */
9681   left = - TREE_VIEW_COLUMN_DRAG_DEAD_MULTIPLIER (tree_view);
9682
9683   for (tmp_list = tree_view->priv->column_drag_info; tmp_list; tmp_list = tmp_list->next)
9684     {
9685       reorder = (GtkTreeViewColumnReorder *) tmp_list->data;
9686
9687       reorder->left_align = left;
9688       if (tmp_list->next != NULL)
9689         {
9690           GtkAllocation right_allocation, left_allocation;
9691           GtkWidget    *left_button, *right_button;
9692
9693           g_assert (tmp_list->next->data);
9694
9695           right_button = gtk_tree_view_column_get_button (reorder->right_column);
9696           left_button  = gtk_tree_view_column_get_button
9697             (((GtkTreeViewColumnReorder *)tmp_list->next->data)->left_column);
9698
9699           gtk_widget_get_allocation (right_button, &right_allocation);
9700           gtk_widget_get_allocation (left_button, &left_allocation);
9701           left = reorder->right_align = (right_allocation.x + right_allocation.width + left_allocation.x) / 2;
9702         }
9703       else
9704         {
9705           reorder->right_align = gdk_window_get_width (tree_view->priv->header_window)
9706                                  + TREE_VIEW_COLUMN_DRAG_DEAD_MULTIPLIER (tree_view);
9707         }
9708     }
9709 }
9710
9711 void
9712 _gtk_tree_view_column_start_drag (GtkTreeView       *tree_view,
9713                                   GtkTreeViewColumn *column,
9714                                   GdkDevice         *device)
9715 {
9716   GdkEvent *send_event;
9717   GtkAllocation allocation;
9718   GtkAllocation button_allocation;
9719   GdkScreen *screen = gtk_widget_get_screen (GTK_WIDGET (tree_view));
9720   GtkWidget *button;
9721   GdkDevice *pointer, *keyboard;
9722
9723   g_return_if_fail (tree_view->priv->column_drag_info == NULL);
9724   g_return_if_fail (tree_view->priv->cur_reorder == NULL);
9725
9726   gtk_tree_view_set_column_drag_info (tree_view, column);
9727
9728   if (tree_view->priv->column_drag_info == NULL)
9729     return;
9730
9731   button = gtk_tree_view_column_get_button (column);
9732
9733   if (tree_view->priv->drag_window == NULL)
9734     {
9735       GdkWindowAttr attributes;
9736       guint attributes_mask;
9737
9738       gtk_widget_get_allocation (button, &button_allocation);
9739
9740       attributes.window_type = GDK_WINDOW_CHILD;
9741       attributes.wclass = GDK_INPUT_OUTPUT;
9742       attributes.x = button_allocation.x;
9743       attributes.y = 0;
9744       attributes.width = button_allocation.width;
9745       attributes.height = button_allocation.height;
9746       attributes.visual = gtk_widget_get_visual (GTK_WIDGET (tree_view));
9747       attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK;
9748       attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
9749
9750       tree_view->priv->drag_window = gdk_window_new (tree_view->priv->bin_window,
9751                                                      &attributes,
9752                                                      attributes_mask);
9753       gdk_window_set_user_data (tree_view->priv->drag_window, GTK_WIDGET (tree_view));
9754     }
9755
9756   if (gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD)
9757     {
9758       keyboard = device;
9759       pointer = gdk_device_get_associated_device (device);
9760     }
9761   else
9762     {
9763       pointer = device;
9764       keyboard = gdk_device_get_associated_device (device);
9765     }
9766
9767   gdk_device_ungrab (pointer, GDK_CURRENT_TIME);
9768   gdk_device_ungrab (keyboard, GDK_CURRENT_TIME);
9769
9770   gtk_grab_remove (button);
9771
9772   send_event = gdk_event_new (GDK_LEAVE_NOTIFY);
9773   send_event->crossing.send_event = TRUE;
9774   send_event->crossing.window = g_object_ref (gtk_button_get_event_window (GTK_BUTTON (button)));
9775   send_event->crossing.subwindow = NULL;
9776   send_event->crossing.detail = GDK_NOTIFY_ANCESTOR;
9777   send_event->crossing.time = GDK_CURRENT_TIME;
9778   gdk_event_set_device (send_event, device);
9779
9780   gtk_propagate_event (button, send_event);
9781   gdk_event_free (send_event);
9782
9783   send_event = gdk_event_new (GDK_BUTTON_RELEASE);
9784   send_event->button.window = g_object_ref (gdk_screen_get_root_window (screen));
9785   send_event->button.send_event = TRUE;
9786   send_event->button.time = GDK_CURRENT_TIME;
9787   send_event->button.x = -1;
9788   send_event->button.y = -1;
9789   send_event->button.axes = NULL;
9790   send_event->button.state = 0;
9791   send_event->button.button = 1;
9792   send_event->button.x_root = 0;
9793   send_event->button.y_root = 0;
9794   gdk_event_set_device (send_event, device);
9795
9796   gtk_propagate_event (button, send_event);
9797   gdk_event_free (send_event);
9798
9799   /* Kids, don't try this at home */
9800   g_object_ref (button);
9801   gtk_container_remove (GTK_CONTAINER (tree_view), button);
9802   gtk_widget_set_parent_window (button, tree_view->priv->drag_window);
9803   gtk_widget_set_parent (button, GTK_WIDGET (tree_view));
9804   g_object_unref (button);
9805
9806   gtk_widget_get_allocation (button, &button_allocation);
9807   tree_view->priv->drag_column_x = button_allocation.x;
9808   allocation = button_allocation;
9809   allocation.x = 0;
9810   gtk_widget_size_allocate (button, &allocation);
9811   gtk_widget_set_parent_window (button, tree_view->priv->drag_window);
9812
9813   tree_view->priv->drag_column = column;
9814   gdk_window_show (tree_view->priv->drag_window);
9815
9816   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
9817   while (gtk_events_pending ())
9818     gtk_main_iteration ();
9819
9820   tree_view->priv->in_column_drag = TRUE;
9821
9822   gdk_device_grab (pointer,
9823                    tree_view->priv->drag_window,
9824                    GDK_OWNERSHIP_NONE,
9825                    FALSE,
9826                    GDK_POINTER_MOTION_MASK|GDK_BUTTON_RELEASE_MASK,
9827                    NULL,
9828                    GDK_CURRENT_TIME);
9829   gdk_device_grab (keyboard,
9830                    tree_view->priv->drag_window,
9831                    GDK_OWNERSHIP_NONE,
9832                    FALSE,
9833                    GDK_KEY_PRESS_MASK|GDK_KEY_RELEASE_MASK,
9834                    NULL,
9835                    GDK_CURRENT_TIME);
9836 }
9837
9838 static void
9839 gtk_tree_view_queue_draw_arrow (GtkTreeView        *tree_view,
9840                                 GtkRBTree          *tree,
9841                                 GtkRBNode          *node)
9842 {
9843   GtkAllocation allocation;
9844   GdkRectangle rect;
9845
9846   if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
9847     return;
9848
9849   gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
9850   rect.x = 0;
9851   rect.width = MAX (tree_view->priv->expander_size, MAX (tree_view->priv->width, allocation.width));
9852
9853   rect.y = gtk_tree_view_get_row_y_offset (tree_view, tree, node);
9854   rect.height = gtk_tree_view_get_row_height (tree_view, node);
9855
9856   gdk_window_invalidate_rect (tree_view->priv->bin_window, &rect, TRUE);
9857 }
9858
9859 void
9860 _gtk_tree_view_queue_draw_node (GtkTreeView        *tree_view,
9861                                 GtkRBTree          *tree,
9862                                 GtkRBNode          *node,
9863                                 const GdkRectangle *clip_rect)
9864 {
9865   GtkAllocation allocation;
9866   GdkRectangle rect;
9867
9868   if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
9869     return;
9870
9871   gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
9872   rect.x = 0;
9873   rect.width = MAX (tree_view->priv->width, allocation.width);
9874
9875   rect.y = gtk_tree_view_get_row_y_offset (tree_view, tree, node);
9876   rect.height = gtk_tree_view_get_row_height (tree_view, node);
9877
9878   if (clip_rect)
9879     {
9880       GdkRectangle new_rect;
9881
9882       gdk_rectangle_intersect (clip_rect, &rect, &new_rect);
9883
9884       gdk_window_invalidate_rect (tree_view->priv->bin_window, &new_rect, TRUE);
9885     }
9886   else
9887     {
9888       gdk_window_invalidate_rect (tree_view->priv->bin_window, &rect, TRUE);
9889     }
9890 }
9891
9892 static inline gint
9893 gtk_tree_view_get_effective_header_height (GtkTreeView *tree_view)
9894 {
9895   if (tree_view->priv->headers_visible)
9896     return tree_view->priv->header_height;
9897   /* else */
9898   return 0;
9899 }
9900
9901 gint
9902 _gtk_tree_view_get_header_height (GtkTreeView *tree_view)
9903 {
9904   return tree_view->priv->header_height;
9905 }
9906
9907 void
9908 _gtk_tree_view_get_row_separator_func (GtkTreeView                 *tree_view,
9909                                        GtkTreeViewRowSeparatorFunc *func,
9910                                        gpointer                    *data)
9911 {
9912   *func = tree_view->priv->row_separator_func;
9913   *data = tree_view->priv->row_separator_data;
9914 }
9915
9916 GtkTreePath *
9917 _gtk_tree_view_get_anchor_path (GtkTreeView *tree_view)
9918 {
9919   if (tree_view->priv->anchor)
9920     return gtk_tree_row_reference_get_path (tree_view->priv->anchor);
9921
9922   return NULL;
9923 }
9924
9925 void
9926 _gtk_tree_view_set_anchor_path (GtkTreeView *tree_view,
9927                                 GtkTreePath *anchor_path)
9928 {
9929   if (tree_view->priv->anchor)
9930     {
9931       gtk_tree_row_reference_free (tree_view->priv->anchor);
9932       tree_view->priv->anchor = NULL;
9933     }
9934
9935   if (anchor_path && tree_view->priv->model)
9936     tree_view->priv->anchor =
9937       gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view),
9938                                         tree_view->priv->model, anchor_path);
9939 }
9940
9941 GtkRBTree *
9942 _gtk_tree_view_get_rbtree (GtkTreeView *tree_view)
9943 {
9944   return tree_view->priv->tree;
9945 }
9946
9947 GdkWindow *
9948 _gtk_tree_view_get_header_window (GtkTreeView *tree_view)
9949 {
9950   return tree_view->priv->header_window;
9951 }
9952
9953 void
9954 _gtk_tree_view_set_focus_column (GtkTreeView       *tree_view,
9955                                  GtkTreeViewColumn *column)
9956 {
9957   tree_view->priv->focus_column = column;
9958 }
9959
9960
9961 static void
9962 gtk_tree_view_queue_draw_path (GtkTreeView        *tree_view,
9963                                GtkTreePath        *path,
9964                                const GdkRectangle *clip_rect)
9965 {
9966   GtkRBTree *tree = NULL;
9967   GtkRBNode *node = NULL;
9968
9969   _gtk_tree_view_find_node (tree_view, path, &tree, &node);
9970
9971   if (tree)
9972     _gtk_tree_view_queue_draw_node (tree_view, tree, node, clip_rect);
9973 }
9974
9975 /* x and y are the mouse position
9976  */
9977 static void
9978 gtk_tree_view_draw_arrow (GtkTreeView *tree_view,
9979                           cairo_t     *cr,
9980                           GtkRBTree   *tree,
9981                           GtkRBNode   *node,
9982                           /* in bin_window coordinates */
9983                           gint         x,
9984                           gint         y)
9985 {
9986   GdkRectangle area;
9987   GtkStateType state;
9988   GtkWidget *widget;
9989   gint x_offset = 0;
9990   gint x2;
9991   gint vertical_separator;
9992   gint expander_size;
9993   GtkExpanderStyle expander_style;
9994
9995   widget = GTK_WIDGET (tree_view);
9996
9997   gtk_widget_style_get (widget,
9998                         "vertical-separator", &vertical_separator,
9999                         NULL);
10000   expander_size = tree_view->priv->expander_size - EXPANDER_EXTRA_PADDING;
10001
10002   if (! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT))
10003     return;
10004
10005   gtk_tree_view_get_arrow_xrange (tree_view, tree, &x_offset, &x2);
10006
10007   area.x = x_offset;
10008   area.y = gtk_tree_view_get_cell_area_y_offset (tree_view, tree, node,
10009                                                  vertical_separator);
10010   area.width = expander_size + 2;
10011   area.height = gtk_tree_view_get_cell_area_height (tree_view, node,
10012                                                     vertical_separator);
10013
10014   if (gtk_widget_get_state (widget) == GTK_STATE_INSENSITIVE)
10015     {
10016       state = GTK_STATE_INSENSITIVE;
10017     }
10018   else if (node == tree_view->priv->button_pressed_node)
10019     {
10020       if (x >= area.x && x <= (area.x + area.width) &&
10021           y >= area.y && y <= (area.y + area.height))
10022         state = GTK_STATE_ACTIVE;
10023       else
10024         state = GTK_STATE_NORMAL;
10025     }
10026   else
10027     {
10028       if (node == tree_view->priv->prelight_node &&
10029           tree_view->priv->arrow_prelit)
10030         state = GTK_STATE_PRELIGHT;
10031       else
10032         state = GTK_STATE_NORMAL;
10033     }
10034
10035   if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SEMI_EXPANDED))
10036     expander_style = GTK_EXPANDER_SEMI_EXPANDED;
10037   else if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SEMI_COLLAPSED))
10038     expander_style = GTK_EXPANDER_SEMI_COLLAPSED;
10039   else if (node->children != NULL)
10040     expander_style = GTK_EXPANDER_EXPANDED;
10041   else
10042     expander_style = GTK_EXPANDER_COLLAPSED;
10043
10044   gtk_paint_expander (gtk_widget_get_style (widget),
10045                       cr,
10046                       state,
10047                       widget,
10048                       "treeview",
10049                       area.x + area.width / 2,
10050                       area.y + area.height / 2,
10051                       expander_style);
10052 }
10053
10054 static void
10055 gtk_tree_view_focus_to_cursor (GtkTreeView *tree_view)
10056
10057 {
10058   GtkTreePath *cursor_path;
10059
10060   if ((tree_view->priv->tree == NULL) ||
10061       (! gtk_widget_get_realized (GTK_WIDGET (tree_view))))
10062     return;
10063
10064   cursor_path = NULL;
10065   if (tree_view->priv->cursor)
10066     cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
10067
10068   if (cursor_path == NULL)
10069     {
10070       /* Consult the selection before defaulting to the
10071        * first focusable element
10072        */
10073       GList *selected_rows;
10074       GtkTreeModel *model;
10075       GtkTreeSelection *selection;
10076
10077       selection = gtk_tree_view_get_selection (tree_view);
10078       selected_rows = gtk_tree_selection_get_selected_rows (selection, &model);
10079
10080       if (selected_rows)
10081         {
10082           cursor_path = gtk_tree_path_copy((const GtkTreePath *)(selected_rows->data));
10083           g_list_foreach (selected_rows, (GFunc)gtk_tree_path_free, NULL);
10084           g_list_free (selected_rows);
10085         }
10086       else
10087         {
10088           cursor_path = gtk_tree_path_new_first ();
10089           search_first_focusable_path (tree_view, &cursor_path,
10090                                        TRUE, NULL, NULL);
10091         }
10092
10093       gtk_tree_row_reference_free (tree_view->priv->cursor);
10094       tree_view->priv->cursor = NULL;
10095
10096       if (cursor_path)
10097         {
10098           if (gtk_tree_selection_get_mode (tree_view->priv->selection) == GTK_SELECTION_MULTIPLE)
10099             gtk_tree_view_real_set_cursor (tree_view, cursor_path, FALSE, FALSE);
10100           else
10101             gtk_tree_view_real_set_cursor (tree_view, cursor_path, TRUE, FALSE);
10102         }
10103     }
10104
10105   if (cursor_path)
10106     {
10107       tree_view->priv->draw_keyfocus = TRUE;
10108
10109       gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
10110       gtk_tree_path_free (cursor_path);
10111
10112       if (tree_view->priv->focus_column == NULL)
10113         {
10114           GList *list;
10115           for (list = tree_view->priv->columns; list; list = list->next)
10116             {
10117               if (gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (list->data)))
10118                 {
10119                   GtkCellArea *cell_area;
10120
10121                   tree_view->priv->focus_column = GTK_TREE_VIEW_COLUMN (list->data);
10122
10123                   /* This happens when the treeview initially grabs focus and there
10124                    * is no column in focus, here we explicitly focus into the first cell */
10125                   cell_area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (tree_view->priv->focus_column));
10126                   if (!gtk_cell_area_get_focus_cell (cell_area))
10127                     {
10128                       gboolean rtl;
10129
10130                       rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
10131                       gtk_cell_area_focus (cell_area,
10132                                            rtl ? GTK_DIR_LEFT : GTK_DIR_RIGHT);
10133                     }
10134
10135                   break;
10136                 }
10137             }
10138         }
10139     }
10140 }
10141
10142 static void
10143 gtk_tree_view_move_cursor_up_down (GtkTreeView *tree_view,
10144                                    gint         count)
10145 {
10146   gint selection_count;
10147   GtkRBTree *cursor_tree = NULL;
10148   GtkRBNode *cursor_node = NULL;
10149   GtkRBTree *new_cursor_tree = NULL;
10150   GtkRBNode *new_cursor_node = NULL;
10151   GtkTreePath *cursor_path = NULL;
10152   gboolean grab_focus = TRUE;
10153   gboolean selectable;
10154   GtkDirectionType direction;
10155   GtkCellArea *cell_area = NULL;
10156   GtkCellRenderer *last_focus_cell = NULL;
10157   GtkTreeIter iter;
10158
10159   if (! gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10160     return;
10161
10162   cursor_path = NULL;
10163   if (!gtk_tree_row_reference_valid (tree_view->priv->cursor))
10164     /* FIXME: we lost the cursor; should we get the first? */
10165     return;
10166
10167   cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
10168   _gtk_tree_view_find_node (tree_view, cursor_path,
10169                             &cursor_tree, &cursor_node);
10170
10171   if (cursor_tree == NULL)
10172     /* FIXME: we lost the cursor; should we get the first? */
10173     return;
10174
10175   direction = count < 0 ? GTK_DIR_UP : GTK_DIR_DOWN;
10176
10177   if (tree_view->priv->focus_column)
10178     cell_area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (tree_view->priv->focus_column));
10179
10180   /* If focus stays in the area for this row, then just return for this round */
10181   if (cell_area && (count == -1 || count == 1) &&
10182       gtk_tree_model_get_iter (tree_view->priv->model, &iter, cursor_path))
10183     {
10184       gtk_tree_view_column_cell_set_cell_data (tree_view->priv->focus_column,
10185                                                tree_view->priv->model,
10186                                                &iter,
10187                                                GTK_RBNODE_FLAG_SET (cursor_node, GTK_RBNODE_IS_PARENT),
10188                                                cursor_node->children?TRUE:FALSE);
10189
10190       /* Save the last cell that had focus, if we hit the end of the view we'll give
10191        * focus back to it. */
10192       last_focus_cell = gtk_cell_area_get_focus_cell (cell_area);
10193
10194       /* If focus stays in the area, no need to change the cursor row */
10195       if (gtk_cell_area_focus (cell_area, direction))
10196         return;
10197     }
10198
10199   selection_count = gtk_tree_selection_count_selected_rows (tree_view->priv->selection);
10200   selectable = _gtk_tree_selection_row_is_selectable (tree_view->priv->selection,
10201                                                       cursor_node,
10202                                                       cursor_path);
10203
10204   if (selection_count == 0
10205       && gtk_tree_selection_get_mode (tree_view->priv->selection) != GTK_SELECTION_NONE
10206       && !tree_view->priv->ctrl_pressed
10207       && selectable)
10208     {
10209       /* Don't move the cursor, but just select the current node */
10210       new_cursor_tree = cursor_tree;
10211       new_cursor_node = cursor_node;
10212     }
10213   else
10214     {
10215       if (count == -1)
10216         _gtk_rbtree_prev_full (cursor_tree, cursor_node,
10217                                &new_cursor_tree, &new_cursor_node);
10218       else
10219         _gtk_rbtree_next_full (cursor_tree, cursor_node,
10220                                &new_cursor_tree, &new_cursor_node);
10221     }
10222
10223   gtk_tree_path_free (cursor_path);
10224
10225   if (new_cursor_node)
10226     {
10227       cursor_path = _gtk_tree_view_find_path (tree_view,
10228                                               new_cursor_tree, new_cursor_node);
10229
10230       search_first_focusable_path (tree_view, &cursor_path,
10231                                    (count != -1),
10232                                    &new_cursor_tree,
10233                                    &new_cursor_node);
10234
10235       if (cursor_path)
10236         gtk_tree_path_free (cursor_path);
10237     }
10238
10239   /*
10240    * If the list has only one item and multi-selection is set then select
10241    * the row (if not yet selected).
10242    */
10243   if (gtk_tree_selection_get_mode (tree_view->priv->selection) == GTK_SELECTION_MULTIPLE &&
10244       new_cursor_node == NULL)
10245     {
10246       if (count == -1)
10247         _gtk_rbtree_next_full (cursor_tree, cursor_node,
10248                                &new_cursor_tree, &new_cursor_node);
10249       else
10250         _gtk_rbtree_prev_full (cursor_tree, cursor_node,
10251                                &new_cursor_tree, &new_cursor_node);
10252
10253       if (new_cursor_node == NULL
10254           && !GTK_RBNODE_FLAG_SET (cursor_node, GTK_RBNODE_IS_SELECTED))
10255         {
10256           new_cursor_node = cursor_node;
10257           new_cursor_tree = cursor_tree;
10258         }
10259       else
10260         {
10261           new_cursor_node = NULL;
10262         }
10263     }
10264
10265   if (new_cursor_node)
10266     {
10267       cursor_path = _gtk_tree_view_find_path (tree_view, new_cursor_tree, new_cursor_node);
10268       gtk_tree_view_real_set_cursor (tree_view, cursor_path, TRUE, TRUE);
10269       gtk_tree_path_free (cursor_path);
10270
10271       /* Give focus to the area in the new row */
10272       if (cell_area)
10273         gtk_cell_area_focus (cell_area, direction);
10274     }
10275   else
10276     {
10277       gtk_tree_view_clamp_node_visible (tree_view, cursor_tree, cursor_node);
10278
10279       if (!tree_view->priv->shift_pressed)
10280         {
10281           if (! gtk_widget_keynav_failed (GTK_WIDGET (tree_view),
10282                                           count < 0 ?
10283                                           GTK_DIR_UP : GTK_DIR_DOWN))
10284             {
10285               GtkWidget *toplevel = gtk_widget_get_toplevel (GTK_WIDGET (tree_view));
10286
10287               if (toplevel)
10288                 gtk_widget_child_focus (toplevel,
10289                                         count < 0 ?
10290                                         GTK_DIR_TAB_BACKWARD :
10291                                         GTK_DIR_TAB_FORWARD);
10292
10293               grab_focus = FALSE;
10294             }
10295         }
10296       else
10297         {
10298           gtk_widget_error_bell (GTK_WIDGET (tree_view));
10299         }
10300
10301       if (cell_area)
10302         gtk_cell_area_set_focus_cell (cell_area, last_focus_cell);
10303     }
10304
10305   if (grab_focus)
10306     gtk_widget_grab_focus (GTK_WIDGET (tree_view));
10307 }
10308
10309 static void
10310 gtk_tree_view_move_cursor_page_up_down (GtkTreeView *tree_view,
10311                                         gint         count)
10312 {
10313   GtkRBTree *cursor_tree = NULL;
10314   GtkRBNode *cursor_node = NULL;
10315   GtkTreePath *old_cursor_path = NULL;
10316   GtkTreePath *cursor_path = NULL;
10317   GtkRBTree *start_cursor_tree = NULL;
10318   GtkRBNode *start_cursor_node = NULL;
10319   gint y;
10320   gint window_y;
10321   gint vertical_separator;
10322
10323   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10324     return;
10325
10326   if (gtk_tree_row_reference_valid (tree_view->priv->cursor))
10327     old_cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
10328   else
10329     /* This is sorta weird.  Focus in should give us a cursor */
10330     return;
10331
10332   gtk_widget_style_get (GTK_WIDGET (tree_view), "vertical-separator", &vertical_separator, NULL);
10333   _gtk_tree_view_find_node (tree_view, old_cursor_path,
10334                             &cursor_tree, &cursor_node);
10335
10336   if (cursor_tree == NULL)
10337     {
10338       /* FIXME: we lost the cursor.  Should we try to get one? */
10339       gtk_tree_path_free (old_cursor_path);
10340       return;
10341     }
10342   g_return_if_fail (cursor_node != NULL);
10343
10344   y = _gtk_rbtree_node_find_offset (cursor_tree, cursor_node);
10345   window_y = RBTREE_Y_TO_TREE_WINDOW_Y (tree_view, y);
10346   y += tree_view->priv->cursor_offset;
10347   y += count * (int)tree_view->priv->vadjustment->page_increment;
10348   y = CLAMP (y, (gint)tree_view->priv->vadjustment->lower,  (gint)tree_view->priv->vadjustment->upper - vertical_separator);
10349
10350   if (y >= tree_view->priv->height)
10351     y = tree_view->priv->height - 1;
10352
10353   tree_view->priv->cursor_offset =
10354     _gtk_rbtree_find_offset (tree_view->priv->tree, y,
10355                              &cursor_tree, &cursor_node);
10356
10357   if (cursor_tree == NULL)
10358     {
10359       /* FIXME: we lost the cursor.  Should we try to get one? */
10360       gtk_tree_path_free (old_cursor_path);
10361       return;
10362     }
10363
10364   if (tree_view->priv->cursor_offset
10365       > gtk_tree_view_get_row_height (tree_view, cursor_node))
10366     {
10367       _gtk_rbtree_next_full (cursor_tree, cursor_node,
10368                              &cursor_tree, &cursor_node);
10369       tree_view->priv->cursor_offset -= gtk_tree_view_get_row_height (tree_view, cursor_node);
10370     }
10371
10372   y -= tree_view->priv->cursor_offset;
10373   cursor_path = _gtk_tree_view_find_path (tree_view, cursor_tree, cursor_node);
10374
10375   start_cursor_tree = cursor_tree;
10376   start_cursor_node = cursor_node;
10377
10378   if (! search_first_focusable_path (tree_view, &cursor_path,
10379                                      (count != -1),
10380                                      &cursor_tree, &cursor_node))
10381     {
10382       /* It looks like we reached the end of the view without finding
10383        * a focusable row.  We will step backwards to find the last
10384        * focusable row.
10385        */
10386       cursor_tree = start_cursor_tree;
10387       cursor_node = start_cursor_node;
10388       cursor_path = _gtk_tree_view_find_path (tree_view, cursor_tree, cursor_node);
10389
10390       search_first_focusable_path (tree_view, &cursor_path,
10391                                    (count == -1),
10392                                    &cursor_tree, &cursor_node);
10393     }
10394
10395   if (!cursor_path)
10396     goto cleanup;
10397
10398   /* update y */
10399   y = _gtk_rbtree_node_find_offset (cursor_tree, cursor_node);
10400
10401   gtk_tree_view_real_set_cursor (tree_view, cursor_path, TRUE, FALSE);
10402
10403   y -= window_y;
10404   gtk_tree_view_scroll_to_point (tree_view, -1, y);
10405   gtk_tree_view_clamp_node_visible (tree_view, cursor_tree, cursor_node);
10406   _gtk_tree_view_queue_draw_node (tree_view, cursor_tree, cursor_node, NULL);
10407
10408   if (!gtk_tree_path_compare (old_cursor_path, cursor_path))
10409     gtk_widget_error_bell (GTK_WIDGET (tree_view));
10410
10411   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
10412
10413 cleanup:
10414   gtk_tree_path_free (old_cursor_path);
10415   gtk_tree_path_free (cursor_path);
10416 }
10417
10418 static void
10419 gtk_tree_view_move_cursor_left_right (GtkTreeView *tree_view,
10420                                       gint         count)
10421 {
10422   GtkRBTree *cursor_tree = NULL;
10423   GtkRBNode *cursor_node = NULL;
10424   GtkTreePath *cursor_path = NULL;
10425   GtkTreeViewColumn *column;
10426   GtkTreeIter iter;
10427   GList *list;
10428   gboolean found_column = FALSE;
10429   gboolean rtl;
10430   GtkDirectionType direction;
10431   GtkCellArea     *cell_area;
10432   GtkCellRenderer *last_focus_cell = NULL;
10433   GtkCellArea     *last_focus_area = NULL;
10434
10435   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
10436
10437   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10438     return;
10439
10440   if (gtk_tree_row_reference_valid (tree_view->priv->cursor))
10441     cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
10442   else
10443     return;
10444
10445   _gtk_tree_view_find_node (tree_view, cursor_path, &cursor_tree, &cursor_node);
10446   if (cursor_tree == NULL)
10447     return;
10448   if (gtk_tree_model_get_iter (tree_view->priv->model, &iter, cursor_path) == FALSE)
10449     {
10450       gtk_tree_path_free (cursor_path);
10451       return;
10452     }
10453   gtk_tree_path_free (cursor_path);
10454
10455   list = rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns);
10456   if (tree_view->priv->focus_column)
10457     {
10458       /* Save the cell/area we are moving focus from, if moving the cursor
10459        * by one step hits the end we'll set focus back here */
10460       last_focus_area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (tree_view->priv->focus_column));
10461       last_focus_cell = gtk_cell_area_get_focus_cell (last_focus_area);
10462
10463       for (; list; list = (rtl ? list->prev : list->next))
10464         {
10465           if (list->data == tree_view->priv->focus_column)
10466             break;
10467         }
10468     }
10469
10470   direction = count > 0 ? GTK_DIR_RIGHT : GTK_DIR_LEFT;
10471
10472   while (list)
10473     {
10474       column = list->data;
10475       if (gtk_tree_view_column_get_visible (column) == FALSE)
10476         goto loop_end;
10477
10478       gtk_tree_view_column_cell_set_cell_data (column,
10479                                                tree_view->priv->model,
10480                                                &iter,
10481                                                GTK_RBNODE_FLAG_SET (cursor_node, GTK_RBNODE_IS_PARENT),
10482                                                cursor_node->children?TRUE:FALSE);
10483
10484       cell_area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (column));
10485       if (gtk_cell_area_focus (cell_area, direction))
10486         {
10487           tree_view->priv->focus_column = column;
10488           found_column = TRUE;
10489           break;
10490         }
10491
10492     loop_end:
10493       if (count == 1)
10494         list = rtl ? list->prev : list->next;
10495       else
10496         list = rtl ? list->next : list->prev;
10497     }
10498
10499   if (found_column)
10500     {
10501       if (!gtk_tree_view_has_can_focus_cell (tree_view))
10502         _gtk_tree_view_queue_draw_node (tree_view,
10503                                         cursor_tree,
10504                                         cursor_node,
10505                                         NULL);
10506       g_signal_emit (tree_view, tree_view_signals[CURSOR_CHANGED], 0);
10507       gtk_widget_grab_focus (GTK_WIDGET (tree_view));
10508     }
10509   else
10510     {
10511       gtk_widget_error_bell (GTK_WIDGET (tree_view));
10512
10513       if (last_focus_area)
10514         gtk_cell_area_set_focus_cell (last_focus_area, last_focus_cell);
10515     }
10516
10517   gtk_tree_view_clamp_column_visible (tree_view,
10518                                       tree_view->priv->focus_column, TRUE);
10519 }
10520
10521 static void
10522 gtk_tree_view_move_cursor_start_end (GtkTreeView *tree_view,
10523                                      gint         count)
10524 {
10525   GtkRBTree *cursor_tree;
10526   GtkRBNode *cursor_node;
10527   GtkTreePath *path;
10528   GtkTreePath *old_path;
10529
10530   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10531     return;
10532
10533   g_return_if_fail (tree_view->priv->tree != NULL);
10534
10535   gtk_tree_view_get_cursor (tree_view, &old_path, NULL);
10536
10537   cursor_tree = tree_view->priv->tree;
10538   cursor_node = cursor_tree->root;
10539
10540   if (count == -1)
10541     {
10542       while (cursor_node && cursor_node->left != cursor_tree->nil)
10543         cursor_node = cursor_node->left;
10544
10545       /* Now go forward to find the first focusable row. */
10546       path = _gtk_tree_view_find_path (tree_view, cursor_tree, cursor_node);
10547       search_first_focusable_path (tree_view, &path,
10548                                    TRUE, &cursor_tree, &cursor_node);
10549     }
10550   else
10551     {
10552       do
10553         {
10554           while (cursor_node && cursor_node->right != cursor_tree->nil)
10555             cursor_node = cursor_node->right;
10556           if (cursor_node->children == NULL)
10557             break;
10558
10559           cursor_tree = cursor_node->children;
10560           cursor_node = cursor_tree->root;
10561         }
10562       while (1);
10563
10564       /* Now go backwards to find last focusable row. */
10565       path = _gtk_tree_view_find_path (tree_view, cursor_tree, cursor_node);
10566       search_first_focusable_path (tree_view, &path,
10567                                    FALSE, &cursor_tree, &cursor_node);
10568     }
10569
10570   if (!path)
10571     goto cleanup;
10572
10573   if (gtk_tree_path_compare (old_path, path))
10574     {
10575       gtk_tree_view_real_set_cursor (tree_view, path, TRUE, TRUE);
10576       gtk_widget_grab_focus (GTK_WIDGET (tree_view));
10577     }
10578   else
10579     {
10580       gtk_widget_error_bell (GTK_WIDGET (tree_view));
10581     }
10582
10583 cleanup:
10584   gtk_tree_path_free (old_path);
10585   gtk_tree_path_free (path);
10586 }
10587
10588 static gboolean
10589 gtk_tree_view_real_select_all (GtkTreeView *tree_view)
10590 {
10591   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10592     return FALSE;
10593
10594   if (gtk_tree_selection_get_mode (tree_view->priv->selection) != GTK_SELECTION_MULTIPLE)
10595     return FALSE;
10596
10597   gtk_tree_selection_select_all (tree_view->priv->selection);
10598
10599   return TRUE;
10600 }
10601
10602 static gboolean
10603 gtk_tree_view_real_unselect_all (GtkTreeView *tree_view)
10604 {
10605   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10606     return FALSE;
10607
10608   if (gtk_tree_selection_get_mode (tree_view->priv->selection) != GTK_SELECTION_MULTIPLE)
10609     return FALSE;
10610
10611   gtk_tree_selection_unselect_all (tree_view->priv->selection);
10612
10613   return TRUE;
10614 }
10615
10616 static gboolean
10617 gtk_tree_view_real_select_cursor_row (GtkTreeView *tree_view,
10618                                       gboolean     start_editing)
10619 {
10620   GtkRBTree *new_tree = NULL;
10621   GtkRBNode *new_node = NULL;
10622   GtkRBTree *cursor_tree = NULL;
10623   GtkRBNode *cursor_node = NULL;
10624   GtkTreePath *cursor_path = NULL;
10625   GtkTreeSelectMode mode = 0;
10626
10627   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10628     return FALSE;
10629
10630   if (tree_view->priv->cursor)
10631     cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
10632
10633   if (cursor_path == NULL)
10634     return FALSE;
10635
10636   _gtk_tree_view_find_node (tree_view, cursor_path,
10637                             &cursor_tree, &cursor_node);
10638
10639   if (cursor_tree == NULL)
10640     {
10641       gtk_tree_path_free (cursor_path);
10642       return FALSE;
10643     }
10644
10645   if (!tree_view->priv->shift_pressed && start_editing &&
10646       tree_view->priv->focus_column)
10647     {
10648       if (gtk_tree_view_start_editing (tree_view, cursor_path, FALSE))
10649         {
10650           gtk_tree_path_free (cursor_path);
10651           return TRUE;
10652         }
10653     }
10654
10655   if (tree_view->priv->ctrl_pressed)
10656     mode |= GTK_TREE_SELECT_MODE_TOGGLE;
10657   if (tree_view->priv->shift_pressed)
10658     mode |= GTK_TREE_SELECT_MODE_EXTEND;
10659
10660   _gtk_tree_selection_internal_select_node (tree_view->priv->selection,
10661                                             cursor_node,
10662                                             cursor_tree,
10663                                             cursor_path,
10664                                             mode,
10665                                             FALSE);
10666
10667   /* We bail out if the original (tree, node) don't exist anymore after
10668    * handling the selection-changed callback.  We do return TRUE because
10669    * the key press has been handled at this point.
10670    */
10671   _gtk_tree_view_find_node (tree_view, cursor_path, &new_tree, &new_node);
10672
10673   if (cursor_tree != new_tree || cursor_node != new_node)
10674     return FALSE;
10675
10676   gtk_tree_view_clamp_node_visible (tree_view, cursor_tree, cursor_node);
10677
10678   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
10679   _gtk_tree_view_queue_draw_node (tree_view, cursor_tree, cursor_node, NULL);
10680
10681   if (!tree_view->priv->shift_pressed)
10682     gtk_tree_view_row_activated (tree_view, cursor_path,
10683                                  tree_view->priv->focus_column);
10684
10685   gtk_tree_path_free (cursor_path);
10686
10687   return TRUE;
10688 }
10689
10690 static gboolean
10691 gtk_tree_view_real_toggle_cursor_row (GtkTreeView *tree_view)
10692 {
10693   GtkRBTree *new_tree = NULL;
10694   GtkRBNode *new_node = NULL;
10695   GtkRBTree *cursor_tree = NULL;
10696   GtkRBNode *cursor_node = NULL;
10697   GtkTreePath *cursor_path = NULL;
10698
10699   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10700     return FALSE;
10701
10702   cursor_path = NULL;
10703   if (tree_view->priv->cursor)
10704     cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
10705
10706   if (cursor_path == NULL)
10707     return FALSE;
10708
10709   _gtk_tree_view_find_node (tree_view, cursor_path,
10710                             &cursor_tree, &cursor_node);
10711   if (cursor_tree == NULL)
10712     {
10713       gtk_tree_path_free (cursor_path);
10714       return FALSE;
10715     }
10716
10717   _gtk_tree_selection_internal_select_node (tree_view->priv->selection,
10718                                             cursor_node,
10719                                             cursor_tree,
10720                                             cursor_path,
10721                                             GTK_TREE_SELECT_MODE_TOGGLE,
10722                                             FALSE);
10723
10724   /* We bail out if the original (tree, node) don't exist anymore after
10725    * handling the selection-changed callback.  We do return TRUE because
10726    * the key press has been handled at this point.
10727    */
10728   _gtk_tree_view_find_node (tree_view, cursor_path, &new_tree, &new_node);
10729
10730   if (cursor_tree != new_tree || cursor_node != new_node)
10731     return FALSE;
10732
10733   gtk_tree_view_clamp_node_visible (tree_view, cursor_tree, cursor_node);
10734
10735   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
10736   gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
10737   gtk_tree_path_free (cursor_path);
10738
10739   return TRUE;
10740 }
10741
10742 static gboolean
10743 gtk_tree_view_real_expand_collapse_cursor_row (GtkTreeView *tree_view,
10744                                                gboolean     logical,
10745                                                gboolean     expand,
10746                                                gboolean     open_all)
10747 {
10748   GtkTreePath *cursor_path = NULL;
10749   GtkRBTree *tree;
10750   GtkRBNode *node;
10751
10752   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10753     return FALSE;
10754
10755   cursor_path = NULL;
10756   if (tree_view->priv->cursor)
10757     cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
10758
10759   if (cursor_path == NULL)
10760     return FALSE;
10761
10762   if (_gtk_tree_view_find_node (tree_view, cursor_path, &tree, &node))
10763     return FALSE;
10764
10765   /* Don't handle the event if we aren't an expander */
10766   if (!((node->flags & GTK_RBNODE_IS_PARENT) == GTK_RBNODE_IS_PARENT))
10767     return FALSE;
10768
10769   if (!logical
10770       && gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL)
10771     expand = !expand;
10772
10773   if (expand)
10774     gtk_tree_view_real_expand_row (tree_view, cursor_path, tree, node, open_all, TRUE);
10775   else
10776     gtk_tree_view_real_collapse_row (tree_view, cursor_path, tree, node, TRUE);
10777
10778   gtk_tree_path_free (cursor_path);
10779
10780   return TRUE;
10781 }
10782
10783 static gboolean
10784 gtk_tree_view_real_select_cursor_parent (GtkTreeView *tree_view)
10785 {
10786   GtkRBTree *cursor_tree = NULL;
10787   GtkRBNode *cursor_node = NULL;
10788   GtkTreePath *cursor_path = NULL;
10789   GdkModifierType state;
10790
10791   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10792     goto out;
10793
10794   cursor_path = NULL;
10795   if (tree_view->priv->cursor)
10796     cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
10797
10798   if (cursor_path == NULL)
10799     goto out;
10800
10801   _gtk_tree_view_find_node (tree_view, cursor_path,
10802                             &cursor_tree, &cursor_node);
10803   if (cursor_tree == NULL)
10804     {
10805       gtk_tree_path_free (cursor_path);
10806       goto out;
10807     }
10808
10809   if (cursor_tree->parent_node)
10810     {
10811       gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
10812       cursor_node = cursor_tree->parent_node;
10813       cursor_tree = cursor_tree->parent_tree;
10814
10815       gtk_tree_path_up (cursor_path);
10816
10817       if (gtk_get_current_event_state (&state))
10818         {
10819           if ((state & GDK_CONTROL_MASK) == GDK_CONTROL_MASK)
10820             tree_view->priv->ctrl_pressed = TRUE;
10821         }
10822
10823       gtk_tree_view_real_set_cursor (tree_view, cursor_path, TRUE, FALSE);
10824       gtk_tree_view_clamp_node_visible (tree_view, cursor_tree, cursor_node);
10825
10826       gtk_widget_grab_focus (GTK_WIDGET (tree_view));
10827       gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
10828       gtk_tree_path_free (cursor_path);
10829
10830       tree_view->priv->ctrl_pressed = FALSE;
10831
10832       return TRUE;
10833     }
10834
10835  out:
10836
10837   tree_view->priv->search_entry_avoid_unhandled_binding = TRUE;
10838   return FALSE;
10839 }
10840
10841 static gboolean
10842 gtk_tree_view_search_entry_flush_timeout (GtkTreeView *tree_view)
10843 {
10844   gtk_tree_view_search_dialog_hide (tree_view->priv->search_window, tree_view, NULL);
10845   tree_view->priv->typeselect_flush_timeout = 0;
10846
10847   return FALSE;
10848 }
10849
10850 /* Cut and paste from gtkwindow.c */
10851 static void
10852 send_focus_change (GtkWidget *widget,
10853                    GdkDevice *device,
10854                    gboolean   in)
10855 {
10856   GdkDeviceManager *device_manager;
10857   GList *devices, *d;
10858
10859   device_manager = gdk_display_get_device_manager (gtk_widget_get_display (widget));
10860   devices = gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_MASTER);
10861   devices = g_list_concat (devices, gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_SLAVE));
10862   devices = g_list_concat (devices, gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_FLOATING));
10863
10864   for (d = devices; d; d = d->next)
10865     {
10866       GdkDevice *dev = d->data;
10867       GdkEvent *fevent;
10868       GdkWindow *window;
10869
10870       if (gdk_device_get_source (dev) != GDK_SOURCE_KEYBOARD)
10871         continue;
10872
10873       window = gtk_widget_get_window (widget);
10874
10875       /* Skip non-master keyboards that haven't
10876        * selected for events from this window
10877        */
10878       if (gdk_device_get_device_type (dev) != GDK_DEVICE_TYPE_MASTER &&
10879           !gdk_window_get_device_events (window, dev))
10880         continue;
10881
10882       fevent = gdk_event_new (GDK_FOCUS_CHANGE);
10883
10884       fevent->focus_change.type = GDK_FOCUS_CHANGE;
10885       fevent->focus_change.window = g_object_ref (window);
10886       fevent->focus_change.in = in;
10887       gdk_event_set_device (fevent, device);
10888
10889       gtk_widget_send_focus_change (widget, fevent);
10890
10891       gdk_event_free (fevent);
10892     }
10893 }
10894
10895 static void
10896 gtk_tree_view_ensure_interactive_directory (GtkTreeView *tree_view)
10897 {
10898   GtkWidget *frame, *vbox, *toplevel;
10899   GdkScreen *screen;
10900
10901   if (tree_view->priv->search_custom_entry_set)
10902     return;
10903
10904   toplevel = gtk_widget_get_toplevel (GTK_WIDGET (tree_view));
10905   screen = gtk_widget_get_screen (GTK_WIDGET (tree_view));
10906
10907    if (tree_view->priv->search_window != NULL)
10908      {
10909        if (gtk_window_has_group (GTK_WINDOW (toplevel)))
10910          gtk_window_group_add_window (gtk_window_get_group (GTK_WINDOW (toplevel)),
10911                                       GTK_WINDOW (tree_view->priv->search_window));
10912        else if (gtk_window_has_group (GTK_WINDOW (tree_view->priv->search_window)))
10913          gtk_window_group_remove_window (gtk_window_get_group (GTK_WINDOW (tree_view->priv->search_window)),
10914                                          GTK_WINDOW (tree_view->priv->search_window));
10915
10916        gtk_window_set_screen (GTK_WINDOW (tree_view->priv->search_window), screen);
10917
10918        return;
10919      }
10920
10921   tree_view->priv->search_window = gtk_window_new (GTK_WINDOW_POPUP);
10922   gtk_window_set_screen (GTK_WINDOW (tree_view->priv->search_window), screen);
10923
10924   if (gtk_window_has_group (GTK_WINDOW (toplevel)))
10925     gtk_window_group_add_window (gtk_window_get_group (GTK_WINDOW (toplevel)),
10926                                  GTK_WINDOW (tree_view->priv->search_window));
10927
10928   gtk_window_set_type_hint (GTK_WINDOW (tree_view->priv->search_window),
10929                             GDK_WINDOW_TYPE_HINT_UTILITY);
10930   gtk_window_set_modal (GTK_WINDOW (tree_view->priv->search_window), TRUE);
10931   g_signal_connect (tree_view->priv->search_window, "delete-event",
10932                     G_CALLBACK (gtk_tree_view_search_delete_event),
10933                     tree_view);
10934   g_signal_connect (tree_view->priv->search_window, "key-press-event",
10935                     G_CALLBACK (gtk_tree_view_search_key_press_event),
10936                     tree_view);
10937   g_signal_connect (tree_view->priv->search_window, "button-press-event",
10938                     G_CALLBACK (gtk_tree_view_search_button_press_event),
10939                     tree_view);
10940   g_signal_connect (tree_view->priv->search_window, "scroll-event",
10941                     G_CALLBACK (gtk_tree_view_search_scroll_event),
10942                     tree_view);
10943
10944   frame = gtk_frame_new (NULL);
10945   gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
10946   gtk_widget_show (frame);
10947   gtk_container_add (GTK_CONTAINER (tree_view->priv->search_window), frame);
10948
10949   vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
10950   gtk_widget_show (vbox);
10951   gtk_container_add (GTK_CONTAINER (frame), vbox);
10952   gtk_container_set_border_width (GTK_CONTAINER (vbox), 3);
10953
10954   /* add entry */
10955   tree_view->priv->search_entry = gtk_entry_new ();
10956   gtk_widget_show (tree_view->priv->search_entry);
10957   g_signal_connect (tree_view->priv->search_entry, "populate-popup",
10958                     G_CALLBACK (gtk_tree_view_search_disable_popdown),
10959                     tree_view);
10960   g_signal_connect (tree_view->priv->search_entry,
10961                     "activate", G_CALLBACK (gtk_tree_view_search_activate),
10962                     tree_view);
10963
10964   g_signal_connect (_gtk_entry_get_im_context (GTK_ENTRY (tree_view->priv->search_entry)),
10965                     "preedit-changed",
10966                     G_CALLBACK (gtk_tree_view_search_preedit_changed),
10967                     tree_view);
10968
10969   gtk_container_add (GTK_CONTAINER (vbox),
10970                      tree_view->priv->search_entry);
10971
10972   gtk_widget_realize (tree_view->priv->search_entry);
10973 }
10974
10975 /* Pops up the interactive search entry.  If keybinding is TRUE then the user
10976  * started this by typing the start_interactive_search keybinding.  Otherwise, it came from
10977  */
10978 static gboolean
10979 gtk_tree_view_real_start_interactive_search (GtkTreeView *tree_view,
10980                                              GdkDevice   *device,
10981                                              gboolean     keybinding)
10982 {
10983   /* We only start interactive search if we have focus or the columns
10984    * have focus.  If one of our children have focus, we don't want to
10985    * start the search.
10986    */
10987   GList *list;
10988   gboolean found_focus = FALSE;
10989   GtkWidgetClass *entry_parent_class;
10990
10991   if (!tree_view->priv->enable_search && !keybinding)
10992     return FALSE;
10993
10994   if (tree_view->priv->search_custom_entry_set)
10995     return FALSE;
10996
10997   if (tree_view->priv->search_window != NULL &&
10998       gtk_widget_get_visible (tree_view->priv->search_window))
10999     return TRUE;
11000
11001   for (list = tree_view->priv->columns; list; list = list->next)
11002     {
11003       GtkTreeViewColumn *column;
11004       GtkWidget         *button;
11005
11006       column = list->data;
11007       if (!gtk_tree_view_column_get_visible (column))
11008         continue;
11009
11010       button = gtk_tree_view_column_get_button (column);
11011       if (gtk_widget_has_focus (button))
11012         {
11013           found_focus = TRUE;
11014           break;
11015         }
11016     }
11017
11018   if (gtk_widget_has_focus (GTK_WIDGET (tree_view)))
11019     found_focus = TRUE;
11020
11021   if (!found_focus)
11022     return FALSE;
11023
11024   if (tree_view->priv->search_column < 0)
11025     return FALSE;
11026
11027   gtk_tree_view_ensure_interactive_directory (tree_view);
11028
11029   if (keybinding)
11030     gtk_entry_set_text (GTK_ENTRY (tree_view->priv->search_entry), "");
11031
11032   /* done, show it */
11033   tree_view->priv->search_position_func (tree_view, tree_view->priv->search_window, tree_view->priv->search_position_user_data);
11034   gtk_widget_show (tree_view->priv->search_window);
11035   if (tree_view->priv->search_entry_changed_id == 0)
11036     {
11037       tree_view->priv->search_entry_changed_id =
11038         g_signal_connect (tree_view->priv->search_entry, "changed",
11039                           G_CALLBACK (gtk_tree_view_search_init),
11040                           tree_view);
11041     }
11042
11043   tree_view->priv->typeselect_flush_timeout =
11044     gdk_threads_add_timeout (GTK_TREE_VIEW_SEARCH_DIALOG_TIMEOUT,
11045                    (GSourceFunc) gtk_tree_view_search_entry_flush_timeout,
11046                    tree_view);
11047
11048   /* Grab focus will select all the text.  We don't want that to happen, so we
11049    * call the parent instance and bypass the selection change.  This is probably
11050    * really non-kosher. */
11051   entry_parent_class = g_type_class_peek_parent (GTK_ENTRY_GET_CLASS (tree_view->priv->search_entry));
11052   (entry_parent_class->grab_focus) (tree_view->priv->search_entry);
11053
11054   /* send focus-in event */
11055   send_focus_change (tree_view->priv->search_entry, device, TRUE);
11056
11057   /* search first matching iter */
11058   gtk_tree_view_search_init (tree_view->priv->search_entry, tree_view);
11059
11060   return TRUE;
11061 }
11062
11063 static gboolean
11064 gtk_tree_view_start_interactive_search (GtkTreeView *tree_view)
11065 {
11066   return gtk_tree_view_real_start_interactive_search (tree_view,
11067                                                       gtk_get_current_event_device (),
11068                                                       TRUE);
11069 }
11070
11071 /* this function returns the new width of the column being resized given
11072  * the column and x position of the cursor; the x cursor position is passed
11073  * in as a pointer and automagicly corrected if it's beyond min/max limits
11074  */
11075 static gint
11076 gtk_tree_view_new_column_width (GtkTreeView *tree_view,
11077                                 gint       i,
11078                                 gint      *x)
11079 {
11080   GtkAllocation allocation;
11081   GtkTreeViewColumn *column;
11082   GtkRequisition button_req;
11083   gint max_width, min_width;
11084   gint width;
11085   gboolean rtl;
11086
11087   /* first translate the x position from widget->window
11088    * to clist->clist_window
11089    */
11090   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
11091   column = g_list_nth (tree_view->priv->columns, i)->data;
11092   gtk_widget_get_allocation (gtk_tree_view_column_get_button (column), &allocation);
11093   width = rtl ? (allocation.x + allocation.width - *x) : (*x - allocation.x);
11094
11095   /* Clamp down the value */
11096   min_width = gtk_tree_view_column_get_min_width (column);
11097   if (min_width == -1)
11098     {
11099       gtk_widget_get_preferred_size (gtk_tree_view_column_get_button (column), &button_req, NULL);
11100       width = MAX (button_req.width, width);
11101     }
11102   else
11103     width = MAX (min_width, width);
11104
11105   max_width = gtk_tree_view_column_get_max_width (column);
11106   if (max_width != -1)
11107     width = MIN (width, max_width);
11108
11109   *x = rtl ? (allocation.x + allocation.width - width) : (allocation.x + width);
11110
11111   return width;
11112 }
11113
11114
11115 /* FIXME this adjust_allocation is a big cut-and-paste from
11116  * GtkCList, needs to be some "official" way to do this
11117  * factored out.
11118  */
11119 typedef struct
11120 {
11121   GdkWindow *window;
11122   int dx;
11123   int dy;
11124 } ScrollData;
11125
11126 /* The window to which widget->window is relative */
11127 #define ALLOCATION_WINDOW(widget)               \
11128    (!gtk_widget_get_has_window (widget) ?                   \
11129     gtk_widget_get_window (widget) :                        \
11130     gdk_window_get_parent (gtk_widget_get_window (widget)))
11131
11132 static void
11133 adjust_allocation_recurse (GtkWidget *widget,
11134                            gpointer   data)
11135 {
11136   GtkAllocation allocation;
11137   ScrollData *scroll_data = data;
11138
11139   /* Need to really size allocate instead of just poking
11140    * into widget->allocation if the widget is not realized.
11141    * FIXME someone figure out why this was.
11142    */
11143   gtk_widget_get_allocation (widget, &allocation);
11144   if (!gtk_widget_get_realized (widget))
11145     {
11146       if (gtk_widget_get_visible (widget))
11147         {
11148           GdkRectangle tmp_rectangle = allocation;
11149           tmp_rectangle.x += scroll_data->dx;
11150           tmp_rectangle.y += scroll_data->dy;
11151
11152           gtk_widget_size_allocate (widget, &tmp_rectangle);
11153         }
11154     }
11155   else
11156     {
11157       if (ALLOCATION_WINDOW (widget) == scroll_data->window)
11158         {
11159           allocation.x += scroll_data->dx;
11160           allocation.y += scroll_data->dy;
11161           gtk_widget_set_allocation (widget, &allocation);
11162
11163           if (GTK_IS_CONTAINER (widget))
11164             gtk_container_forall (GTK_CONTAINER (widget),
11165                                   adjust_allocation_recurse,
11166                                   data);
11167         }
11168     }
11169 }
11170
11171 static void
11172 adjust_allocation (GtkWidget *widget,
11173                    int        dx,
11174                    int        dy)
11175 {
11176   ScrollData scroll_data;
11177
11178   if (gtk_widget_get_realized (widget))
11179     scroll_data.window = ALLOCATION_WINDOW (widget);
11180   else
11181     scroll_data.window = NULL;
11182
11183   scroll_data.dx = dx;
11184   scroll_data.dy = dy;
11185
11186   adjust_allocation_recurse (widget, &scroll_data);
11187 }
11188
11189 /* Callbacks */
11190 static void
11191 gtk_tree_view_adjustment_changed (GtkAdjustment *adjustment,
11192                                   GtkTreeView   *tree_view)
11193 {
11194   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
11195     {
11196       gint dy;
11197
11198       gdk_window_move (tree_view->priv->bin_window,
11199                        - tree_view->priv->hadjustment->value,
11200                        gtk_tree_view_get_effective_header_height (tree_view));
11201       gdk_window_move (tree_view->priv->header_window,
11202                        - tree_view->priv->hadjustment->value,
11203                        0);
11204       dy = tree_view->priv->dy - (int) tree_view->priv->vadjustment->value;
11205       if (dy)
11206         {
11207           update_prelight (tree_view,
11208                            tree_view->priv->event_last_x,
11209                            tree_view->priv->event_last_y - dy);
11210
11211           if (tree_view->priv->edited_column)
11212             {
11213               GList *list;
11214               GtkTreeViewChild *child = NULL;
11215               GtkCellEditable *edit_widget;
11216               GtkCellArea *area;
11217
11218               area        = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (tree_view->priv->edited_column));
11219               edit_widget = gtk_cell_area_get_edit_widget (area);
11220               if (GTK_IS_WIDGET (edit_widget))
11221                 {
11222                   adjust_allocation (GTK_WIDGET (edit_widget), 0, dy);
11223
11224                   for (list = tree_view->priv->children; list; list = list->next)
11225                     {
11226                       child = (GtkTreeViewChild *)list->data;
11227                       if (child->widget == GTK_WIDGET (edit_widget))
11228                         {
11229                           child->y += dy;
11230                           break;
11231                         }
11232                     }
11233                 }
11234             }
11235         }
11236       gdk_window_scroll (tree_view->priv->bin_window, 0, dy);
11237
11238       if (tree_view->priv->dy != (int) tree_view->priv->vadjustment->value)
11239         {
11240           /* update our dy and top_row */
11241           tree_view->priv->dy = (int) tree_view->priv->vadjustment->value;
11242
11243           if (!tree_view->priv->in_top_row_to_dy)
11244             gtk_tree_view_dy_to_top_row (tree_view);
11245         }
11246
11247       gdk_window_process_updates (tree_view->priv->header_window, TRUE);
11248       gtk_tree_view_bin_process_updates (tree_view);
11249     }
11250 }
11251
11252 \f
11253
11254 /* Public methods
11255  */
11256
11257 /**
11258  * gtk_tree_view_new:
11259  *
11260  * Creates a new #GtkTreeView widget.
11261  *
11262  * Return value: A newly created #GtkTreeView widget.
11263  **/
11264 GtkWidget *
11265 gtk_tree_view_new (void)
11266 {
11267   return g_object_new (GTK_TYPE_TREE_VIEW, NULL);
11268 }
11269
11270 /**
11271  * gtk_tree_view_new_with_model:
11272  * @model: the model.
11273  *
11274  * Creates a new #GtkTreeView widget with the model initialized to @model.
11275  *
11276  * Return value: A newly created #GtkTreeView widget.
11277  **/
11278 GtkWidget *
11279 gtk_tree_view_new_with_model (GtkTreeModel *model)
11280 {
11281   return g_object_new (GTK_TYPE_TREE_VIEW, "model", model, NULL);
11282 }
11283
11284 /* Public Accessors
11285  */
11286
11287 /**
11288  * gtk_tree_view_get_model:
11289  * @tree_view: a #GtkTreeView
11290  *
11291  * Returns the model the #GtkTreeView is based on.  Returns %NULL if the
11292  * model is unset.
11293  *
11294  * Return value: (transfer none): A #GtkTreeModel, or %NULL if none is currently being used.
11295  **/
11296 GtkTreeModel *
11297 gtk_tree_view_get_model (GtkTreeView *tree_view)
11298 {
11299   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
11300
11301   return tree_view->priv->model;
11302 }
11303
11304 /**
11305  * gtk_tree_view_set_model:
11306  * @tree_view: A #GtkTreeNode.
11307  * @model: (allow-none): The model.
11308  *
11309  * Sets the model for a #GtkTreeView.  If the @tree_view already has a model
11310  * set, it will remove it before setting the new model.  If @model is %NULL,
11311  * then it will unset the old model.
11312  **/
11313 void
11314 gtk_tree_view_set_model (GtkTreeView  *tree_view,
11315                          GtkTreeModel *model)
11316 {
11317   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11318   g_return_if_fail (model == NULL || GTK_IS_TREE_MODEL (model));
11319
11320   if (model == tree_view->priv->model)
11321     return;
11322
11323   if (tree_view->priv->scroll_to_path)
11324     {
11325       gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
11326       tree_view->priv->scroll_to_path = NULL;
11327     }
11328
11329   if (tree_view->priv->model)
11330     {
11331       GList *tmplist = tree_view->priv->columns;
11332
11333       gtk_tree_view_unref_and_check_selection_tree (tree_view, tree_view->priv->tree);
11334       gtk_tree_view_stop_editing (tree_view, TRUE);
11335
11336       remove_expand_collapse_timeout (tree_view);
11337
11338       g_signal_handlers_disconnect_by_func (tree_view->priv->model,
11339                                             gtk_tree_view_row_changed,
11340                                             tree_view);
11341       g_signal_handlers_disconnect_by_func (tree_view->priv->model,
11342                                             gtk_tree_view_row_inserted,
11343                                             tree_view);
11344       g_signal_handlers_disconnect_by_func (tree_view->priv->model,
11345                                             gtk_tree_view_row_has_child_toggled,
11346                                             tree_view);
11347       g_signal_handlers_disconnect_by_func (tree_view->priv->model,
11348                                             gtk_tree_view_row_deleted,
11349                                             tree_view);
11350       g_signal_handlers_disconnect_by_func (tree_view->priv->model,
11351                                             gtk_tree_view_rows_reordered,
11352                                             tree_view);
11353
11354       for (; tmplist; tmplist = tmplist->next)
11355         _gtk_tree_view_column_unset_model (tmplist->data,
11356                                            tree_view->priv->model);
11357
11358       if (tree_view->priv->tree)
11359         gtk_tree_view_free_rbtree (tree_view);
11360
11361       gtk_tree_row_reference_free (tree_view->priv->drag_dest_row);
11362       tree_view->priv->drag_dest_row = NULL;
11363       gtk_tree_row_reference_free (tree_view->priv->cursor);
11364       tree_view->priv->cursor = NULL;
11365       gtk_tree_row_reference_free (tree_view->priv->anchor);
11366       tree_view->priv->anchor = NULL;
11367       gtk_tree_row_reference_free (tree_view->priv->top_row);
11368       tree_view->priv->top_row = NULL;
11369       gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
11370       tree_view->priv->scroll_to_path = NULL;
11371
11372       tree_view->priv->scroll_to_column = NULL;
11373
11374       g_object_unref (tree_view->priv->model);
11375
11376       tree_view->priv->search_column = -1;
11377       tree_view->priv->fixed_height_check = 0;
11378       tree_view->priv->fixed_height = -1;
11379       tree_view->priv->dy = tree_view->priv->top_row_dy = 0;
11380       tree_view->priv->last_button_x = -1;
11381       tree_view->priv->last_button_y = -1;
11382     }
11383
11384   tree_view->priv->model = model;
11385
11386   if (tree_view->priv->model)
11387     {
11388       gint i;
11389       GtkTreePath *path;
11390       GtkTreeIter iter;
11391       GtkTreeModelFlags flags;
11392
11393       if (tree_view->priv->search_column == -1)
11394         {
11395           for (i = 0; i < gtk_tree_model_get_n_columns (model); i++)
11396             {
11397               GType type = gtk_tree_model_get_column_type (model, i);
11398
11399               if (g_value_type_transformable (type, G_TYPE_STRING))
11400                 {
11401                   tree_view->priv->search_column = i;
11402                   break;
11403                 }
11404             }
11405         }
11406
11407       g_object_ref (tree_view->priv->model);
11408       g_signal_connect (tree_view->priv->model,
11409                         "row-changed",
11410                         G_CALLBACK (gtk_tree_view_row_changed),
11411                         tree_view);
11412       g_signal_connect (tree_view->priv->model,
11413                         "row-inserted",
11414                         G_CALLBACK (gtk_tree_view_row_inserted),
11415                         tree_view);
11416       g_signal_connect (tree_view->priv->model,
11417                         "row-has-child-toggled",
11418                         G_CALLBACK (gtk_tree_view_row_has_child_toggled),
11419                         tree_view);
11420       g_signal_connect (tree_view->priv->model,
11421                         "row-deleted",
11422                         G_CALLBACK (gtk_tree_view_row_deleted),
11423                         tree_view);
11424       g_signal_connect (tree_view->priv->model,
11425                         "rows-reordered",
11426                         G_CALLBACK (gtk_tree_view_rows_reordered),
11427                         tree_view);
11428
11429       flags = gtk_tree_model_get_flags (tree_view->priv->model);
11430       if ((flags & GTK_TREE_MODEL_LIST_ONLY) == GTK_TREE_MODEL_LIST_ONLY)
11431         tree_view->priv->is_list = TRUE;
11432       else
11433         tree_view->priv->is_list = FALSE;
11434
11435       path = gtk_tree_path_new_first ();
11436       if (gtk_tree_model_get_iter (tree_view->priv->model, &iter, path))
11437         {
11438           tree_view->priv->tree = _gtk_rbtree_new ();
11439           gtk_tree_view_build_tree (tree_view, tree_view->priv->tree, &iter, 1, FALSE);
11440         }
11441       gtk_tree_path_free (path);
11442
11443       /*  FIXME: do I need to do this? gtk_tree_view_create_buttons (tree_view); */
11444       install_presize_handler (tree_view);
11445     }
11446
11447   g_object_notify (G_OBJECT (tree_view), "model");
11448
11449   if (tree_view->priv->selection)
11450   _gtk_tree_selection_emit_changed (tree_view->priv->selection);
11451
11452   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
11453     gtk_widget_queue_resize (GTK_WIDGET (tree_view));
11454 }
11455
11456 /**
11457  * gtk_tree_view_get_selection:
11458  * @tree_view: A #GtkTreeView.
11459  *
11460  * Gets the #GtkTreeSelection associated with @tree_view.
11461  *
11462  * Return value: (transfer none): A #GtkTreeSelection object.
11463  **/
11464 GtkTreeSelection *
11465 gtk_tree_view_get_selection (GtkTreeView *tree_view)
11466 {
11467   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
11468
11469   return tree_view->priv->selection;
11470 }
11471
11472 /**
11473  * gtk_tree_view_get_hadjustment:
11474  * @tree_view: A #GtkTreeView
11475  *
11476  * Gets the #GtkAdjustment currently being used for the horizontal aspect.
11477  *
11478  * Return value: (transfer none): A #GtkAdjustment object, or %NULL
11479  *     if none is currently being used.
11480  *
11481  * Deprecated: 3.0: Use gtk_scrollable_get_hadjustment()
11482  **/
11483 GtkAdjustment *
11484 gtk_tree_view_get_hadjustment (GtkTreeView *tree_view)
11485 {
11486   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
11487
11488   return tree_view->priv->hadjustment;
11489 }
11490
11491 /**
11492  * gtk_tree_view_set_hadjustment:
11493  * @tree_view: A #GtkTreeView
11494  * @adjustment: (allow-none): The #GtkAdjustment to set, or %NULL
11495  *
11496  * Sets the #GtkAdjustment for the current horizontal aspect.
11497  *
11498  * Deprecated: 3.0: Use gtk_scrollable_set_hadjustment()
11499  **/
11500 void
11501 gtk_tree_view_set_hadjustment (GtkTreeView   *tree_view,
11502                                GtkAdjustment *adjustment)
11503 {
11504   GtkTreeViewPrivate *priv = tree_view->priv;
11505
11506   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11507   g_return_if_fail (adjustment == NULL || GTK_IS_ADJUSTMENT (adjustment));
11508
11509   if (adjustment && priv->hadjustment == adjustment)
11510     return;
11511
11512   if (priv->hadjustment != NULL)
11513     {
11514       g_signal_handlers_disconnect_by_func (priv->hadjustment,
11515                                             gtk_tree_view_adjustment_changed,
11516                                             tree_view);
11517       g_object_unref (priv->hadjustment);
11518     }
11519
11520   if (adjustment == NULL)
11521     adjustment = gtk_adjustment_new (0.0, 0.0, 0.0,
11522                                      0.0, 0.0, 0.0);
11523
11524   g_signal_connect (adjustment, "value-changed",
11525                     G_CALLBACK (gtk_tree_view_adjustment_changed), tree_view);
11526   priv->hadjustment = g_object_ref_sink (adjustment);
11527   /* FIXME: Adjustment should probably be populated here with fresh values, but
11528    * internal details are too complicated for me to decipher right now.
11529    */
11530   gtk_tree_view_adjustment_changed (NULL, tree_view);
11531
11532   g_object_notify (G_OBJECT (tree_view), "hadjustment");
11533 }
11534
11535 /**
11536  * gtk_tree_view_get_vadjustment:
11537  * @tree_view: A #GtkTreeView
11538  *
11539  * Gets the #GtkAdjustment currently being used for the vertical aspect.
11540  *
11541  * Return value: (transfer none): A #GtkAdjustment object, or %NULL
11542  *     if none is currently being used.
11543  *
11544  * Deprecated: 3.0: Use gtk_scrollable_get_vadjustment()
11545  **/
11546 GtkAdjustment *
11547 gtk_tree_view_get_vadjustment (GtkTreeView *tree_view)
11548 {
11549   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
11550
11551   return tree_view->priv->vadjustment;
11552 }
11553
11554 /**
11555  * gtk_tree_view_set_vadjustment:
11556  * @tree_view: A #GtkTreeView
11557  * @adjustment: (allow-none): The #GtkAdjustment to set, or %NULL
11558  *
11559  * Sets the #GtkAdjustment for the current vertical aspect.
11560  *
11561  * Deprecated: 3.0: Use gtk_scrollable_set_vadjustment()
11562  **/
11563 void
11564 gtk_tree_view_set_vadjustment (GtkTreeView   *tree_view,
11565                                GtkAdjustment *adjustment)
11566 {
11567   GtkTreeViewPrivate *priv = tree_view->priv;
11568
11569   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11570   g_return_if_fail (adjustment == NULL || GTK_IS_ADJUSTMENT (adjustment));
11571
11572   if (adjustment && priv->vadjustment == adjustment)
11573     return;
11574
11575   if (priv->vadjustment != NULL)
11576     {
11577       g_signal_handlers_disconnect_by_func (priv->vadjustment,
11578                                             gtk_tree_view_adjustment_changed,
11579                                             tree_view);
11580       g_object_unref (priv->vadjustment);
11581     }
11582
11583   if (adjustment == NULL)
11584     adjustment = gtk_adjustment_new (0.0, 0.0, 0.0,
11585                                      0.0, 0.0, 0.0);
11586
11587   g_signal_connect (adjustment, "value-changed",
11588                     G_CALLBACK (gtk_tree_view_adjustment_changed), tree_view);
11589   priv->vadjustment = g_object_ref_sink (adjustment);
11590   /* FIXME: Adjustment should probably be populated here with fresh values, but
11591    * internal details are too complicated for me to decipher right now.
11592    */
11593   gtk_tree_view_adjustment_changed (NULL, tree_view);
11594   g_object_notify (G_OBJECT (tree_view), "vadjustment");
11595 }
11596
11597 /* Column and header operations */
11598
11599 /**
11600  * gtk_tree_view_get_headers_visible:
11601  * @tree_view: A #GtkTreeView.
11602  *
11603  * Returns %TRUE if the headers on the @tree_view are visible.
11604  *
11605  * Return value: Whether the headers are visible or not.
11606  **/
11607 gboolean
11608 gtk_tree_view_get_headers_visible (GtkTreeView *tree_view)
11609 {
11610   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
11611
11612   return tree_view->priv->headers_visible;
11613 }
11614
11615 /**
11616  * gtk_tree_view_set_headers_visible:
11617  * @tree_view: A #GtkTreeView.
11618  * @headers_visible: %TRUE if the headers are visible
11619  *
11620  * Sets the visibility state of the headers.
11621  **/
11622 void
11623 gtk_tree_view_set_headers_visible (GtkTreeView *tree_view,
11624                                    gboolean     headers_visible)
11625 {
11626   gint x, y;
11627   GList *list;
11628   GtkTreeViewColumn *column;
11629   GtkAllocation allocation;
11630   GtkWidget *button;
11631
11632   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11633
11634   headers_visible = !! headers_visible;
11635
11636   if (tree_view->priv->headers_visible == headers_visible)
11637     return;
11638
11639   tree_view->priv->headers_visible = headers_visible == TRUE;
11640
11641   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
11642     {
11643       gdk_window_get_position (tree_view->priv->bin_window, &x, &y);
11644       if (headers_visible)
11645         {
11646           gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
11647           gdk_window_move_resize (tree_view->priv->bin_window,
11648                                   x, y  + gtk_tree_view_get_effective_header_height (tree_view),
11649                                   tree_view->priv->width, allocation.height -  + gtk_tree_view_get_effective_header_height (tree_view));
11650
11651           if (gtk_widget_get_mapped (GTK_WIDGET (tree_view)))
11652             gtk_tree_view_map_buttons (tree_view);
11653         }
11654       else
11655         {
11656           gdk_window_move_resize (tree_view->priv->bin_window, x, y, tree_view->priv->width, tree_view->priv->height);
11657
11658           for (list = tree_view->priv->columns; list; list = list->next)
11659             {
11660               column = list->data;
11661               button = gtk_tree_view_column_get_button (column);
11662
11663               gtk_widget_hide (button);
11664               gtk_widget_unmap (button);
11665             }
11666           gdk_window_hide (tree_view->priv->header_window);
11667         }
11668     }
11669
11670   gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
11671   tree_view->priv->vadjustment->page_size = allocation.height - gtk_tree_view_get_effective_header_height (tree_view);
11672   tree_view->priv->vadjustment->page_increment = (allocation.height - gtk_tree_view_get_effective_header_height (tree_view)) / 2;
11673   tree_view->priv->vadjustment->lower = 0;
11674   tree_view->priv->vadjustment->upper = tree_view->priv->height;
11675   gtk_adjustment_changed (tree_view->priv->vadjustment);
11676
11677   gtk_widget_queue_resize (GTK_WIDGET (tree_view));
11678
11679   g_object_notify (G_OBJECT (tree_view), "headers-visible");
11680 }
11681
11682 /**
11683  * gtk_tree_view_columns_autosize:
11684  * @tree_view: A #GtkTreeView.
11685  *
11686  * Resizes all columns to their optimal width. Only works after the
11687  * treeview has been realized.
11688  **/
11689 void
11690 gtk_tree_view_columns_autosize (GtkTreeView *tree_view)
11691 {
11692   gboolean dirty = FALSE;
11693   GList *list;
11694   GtkTreeViewColumn *column;
11695
11696   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11697
11698   for (list = tree_view->priv->columns; list; list = list->next)
11699     {
11700       column = list->data;
11701       if (gtk_tree_view_column_get_sizing (column) == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
11702         continue;
11703       _gtk_tree_view_column_cell_set_dirty (column, TRUE);
11704       dirty = TRUE;
11705     }
11706
11707   if (dirty)
11708     gtk_widget_queue_resize (GTK_WIDGET (tree_view));
11709 }
11710
11711 /**
11712  * gtk_tree_view_set_headers_clickable:
11713  * @tree_view: A #GtkTreeView.
11714  * @setting: %TRUE if the columns are clickable.
11715  *
11716  * Allow the column title buttons to be clicked.
11717  **/
11718 void
11719 gtk_tree_view_set_headers_clickable (GtkTreeView *tree_view,
11720                                      gboolean   setting)
11721 {
11722   GList *list;
11723
11724   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11725
11726   for (list = tree_view->priv->columns; list; list = list->next)
11727     gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (list->data), setting);
11728
11729   g_object_notify (G_OBJECT (tree_view), "headers-clickable");
11730 }
11731
11732
11733 /**
11734  * gtk_tree_view_get_headers_clickable:
11735  * @tree_view: A #GtkTreeView.
11736  *
11737  * Returns whether all header columns are clickable.
11738  *
11739  * Return value: %TRUE if all header columns are clickable, otherwise %FALSE
11740  *
11741  * Since: 2.10
11742  **/
11743 gboolean
11744 gtk_tree_view_get_headers_clickable (GtkTreeView *tree_view)
11745 {
11746   GList *list;
11747
11748   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
11749
11750   for (list = tree_view->priv->columns; list; list = list->next)
11751     if (!gtk_tree_view_column_get_clickable (GTK_TREE_VIEW_COLUMN (list->data)))
11752       return FALSE;
11753
11754   return TRUE;
11755 }
11756
11757 /**
11758  * gtk_tree_view_set_rules_hint
11759  * @tree_view: a #GtkTreeView
11760  * @setting: %TRUE if the tree requires reading across rows
11761  *
11762  * This function tells GTK+ that the user interface for your
11763  * application requires users to read across tree rows and associate
11764  * cells with one another. By default, GTK+ will then render the tree
11765  * with alternating row colors. Do <emphasis>not</emphasis> use it
11766  * just because you prefer the appearance of the ruled tree; that's a
11767  * question for the theme. Some themes will draw tree rows in
11768  * alternating colors even when rules are turned off, and users who
11769  * prefer that appearance all the time can choose those themes. You
11770  * should call this function only as a <emphasis>semantic</emphasis>
11771  * hint to the theme engine that your tree makes alternating colors
11772  * useful from a functional standpoint (since it has lots of columns,
11773  * generally).
11774  *
11775  **/
11776 void
11777 gtk_tree_view_set_rules_hint (GtkTreeView  *tree_view,
11778                               gboolean      setting)
11779 {
11780   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11781
11782   setting = setting != FALSE;
11783
11784   if (tree_view->priv->has_rules != setting)
11785     {
11786       tree_view->priv->has_rules = setting;
11787       gtk_widget_queue_draw (GTK_WIDGET (tree_view));
11788     }
11789
11790   g_object_notify (G_OBJECT (tree_view), "rules-hint");
11791 }
11792
11793 /**
11794  * gtk_tree_view_get_rules_hint
11795  * @tree_view: a #GtkTreeView
11796  *
11797  * Gets the setting set by gtk_tree_view_set_rules_hint().
11798  *
11799  * Return value: %TRUE if rules are useful for the user of this tree
11800  **/
11801 gboolean
11802 gtk_tree_view_get_rules_hint (GtkTreeView  *tree_view)
11803 {
11804   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
11805
11806   return tree_view->priv->has_rules;
11807 }
11808
11809 /* Public Column functions
11810  */
11811
11812 /**
11813  * gtk_tree_view_append_column:
11814  * @tree_view: A #GtkTreeView.
11815  * @column: The #GtkTreeViewColumn to add.
11816  *
11817  * Appends @column to the list of columns. If @tree_view has "fixed_height"
11818  * mode enabled, then @column must have its "sizing" property set to be
11819  * GTK_TREE_VIEW_COLUMN_FIXED.
11820  *
11821  * Return value: The number of columns in @tree_view after appending.
11822  **/
11823 gint
11824 gtk_tree_view_append_column (GtkTreeView       *tree_view,
11825                              GtkTreeViewColumn *column)
11826 {
11827   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
11828   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (column), -1);
11829   g_return_val_if_fail (gtk_tree_view_column_get_tree_view (column) == NULL, -1);
11830
11831   return gtk_tree_view_insert_column (tree_view, column, -1);
11832 }
11833
11834
11835 /**
11836  * gtk_tree_view_remove_column:
11837  * @tree_view: A #GtkTreeView.
11838  * @column: The #GtkTreeViewColumn to remove.
11839  *
11840  * Removes @column from @tree_view.
11841  *
11842  * Return value: The number of columns in @tree_view after removing.
11843  **/
11844 gint
11845 gtk_tree_view_remove_column (GtkTreeView       *tree_view,
11846                              GtkTreeViewColumn *column)
11847 {
11848   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
11849   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (column), -1);
11850   g_return_val_if_fail (gtk_tree_view_column_get_tree_view (column) == GTK_WIDGET (tree_view), -1);
11851
11852   if (tree_view->priv->focus_column == column)
11853     tree_view->priv->focus_column = NULL;
11854
11855   if (tree_view->priv->edited_column == column)
11856     {
11857       gtk_tree_view_stop_editing (tree_view, TRUE);
11858
11859       /* no need to, but just to be sure ... */
11860       tree_view->priv->edited_column = NULL;
11861     }
11862
11863   if (tree_view->priv->expander_column == column)
11864     tree_view->priv->expander_column = NULL;
11865
11866   g_signal_handlers_disconnect_by_func (column,
11867                                         G_CALLBACK (column_sizing_notify),
11868                                         tree_view);
11869
11870   _gtk_tree_view_column_unset_tree_view (column);
11871
11872   tree_view->priv->columns = g_list_remove (tree_view->priv->columns, column);
11873   tree_view->priv->n_columns--;
11874
11875   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
11876     {
11877       GList *list;
11878
11879       _gtk_tree_view_column_unrealize_button (column);
11880       for (list = tree_view->priv->columns; list; list = list->next)
11881         {
11882           GtkTreeViewColumn *tmp_column;
11883
11884           tmp_column = GTK_TREE_VIEW_COLUMN (list->data);
11885           if (gtk_tree_view_column_get_visible (tmp_column))
11886             _gtk_tree_view_column_cell_set_dirty (tmp_column, TRUE);
11887         }
11888
11889       if (tree_view->priv->n_columns == 0 &&
11890           gtk_tree_view_get_headers_visible (tree_view))
11891         gdk_window_hide (tree_view->priv->header_window);
11892
11893       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
11894     }
11895
11896   g_object_unref (column);
11897   g_signal_emit (tree_view, tree_view_signals[COLUMNS_CHANGED], 0);
11898
11899   return tree_view->priv->n_columns;
11900 }
11901
11902 /**
11903  * gtk_tree_view_insert_column:
11904  * @tree_view: A #GtkTreeView.
11905  * @column: The #GtkTreeViewColumn to be inserted.
11906  * @position: The position to insert @column in.
11907  *
11908  * This inserts the @column into the @tree_view at @position.  If @position is
11909  * -1, then the column is inserted at the end. If @tree_view has
11910  * "fixed_height" mode enabled, then @column must have its "sizing" property
11911  * set to be GTK_TREE_VIEW_COLUMN_FIXED.
11912  *
11913  * Return value: The number of columns in @tree_view after insertion.
11914  **/
11915 gint
11916 gtk_tree_view_insert_column (GtkTreeView       *tree_view,
11917                              GtkTreeViewColumn *column,
11918                              gint               position)
11919 {
11920   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
11921   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (column), -1);
11922   g_return_val_if_fail (gtk_tree_view_column_get_tree_view (column) == NULL, -1);
11923
11924   if (tree_view->priv->fixed_height_mode)
11925     g_return_val_if_fail (gtk_tree_view_column_get_sizing (column)
11926                           == GTK_TREE_VIEW_COLUMN_FIXED, -1);
11927
11928   g_object_ref_sink (column);
11929
11930   if (tree_view->priv->n_columns == 0 &&
11931       gtk_widget_get_realized (GTK_WIDGET (tree_view)) &&
11932       gtk_tree_view_get_headers_visible (tree_view))
11933     {
11934       gdk_window_show (tree_view->priv->header_window);
11935     }
11936
11937   g_signal_connect (column, "notify::sizing",
11938                     G_CALLBACK (column_sizing_notify), tree_view);
11939
11940   tree_view->priv->columns = g_list_insert (tree_view->priv->columns,
11941                                             column, position);
11942   tree_view->priv->n_columns++;
11943
11944   _gtk_tree_view_column_set_tree_view (column, tree_view);
11945
11946   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
11947     {
11948       GList *list;
11949
11950       _gtk_tree_view_column_realize_button (column);
11951
11952       for (list = tree_view->priv->columns; list; list = list->next)
11953         {
11954           column = GTK_TREE_VIEW_COLUMN (list->data);
11955           if (gtk_tree_view_column_get_visible (column))
11956             _gtk_tree_view_column_cell_set_dirty (column, TRUE);
11957         }
11958       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
11959     }
11960
11961   g_signal_emit (tree_view, tree_view_signals[COLUMNS_CHANGED], 0);
11962
11963   return tree_view->priv->n_columns;
11964 }
11965
11966 /**
11967  * gtk_tree_view_insert_column_with_attributes:
11968  * @tree_view: A #GtkTreeView
11969  * @position: The position to insert the new column in.
11970  * @title: The title to set the header to.
11971  * @cell: The #GtkCellRenderer.
11972  * @Varargs: A %NULL-terminated list of attributes.
11973  *
11974  * Creates a new #GtkTreeViewColumn and inserts it into the @tree_view at
11975  * @position.  If @position is -1, then the newly created column is inserted at
11976  * the end.  The column is initialized with the attributes given. If @tree_view
11977  * has "fixed_height" mode enabled, then the new column will have its sizing
11978  * property set to be GTK_TREE_VIEW_COLUMN_FIXED.
11979  *
11980  * Return value: The number of columns in @tree_view after insertion.
11981  **/
11982 gint
11983 gtk_tree_view_insert_column_with_attributes (GtkTreeView     *tree_view,
11984                                              gint             position,
11985                                              const gchar     *title,
11986                                              GtkCellRenderer *cell,
11987                                              ...)
11988 {
11989   GtkTreeViewColumn *column;
11990   gchar *attribute;
11991   va_list args;
11992   gint column_id;
11993
11994   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
11995
11996   column = gtk_tree_view_column_new ();
11997   if (tree_view->priv->fixed_height_mode)
11998     gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED);
11999
12000   gtk_tree_view_column_set_title (column, title);
12001   gtk_tree_view_column_pack_start (column, cell, TRUE);
12002
12003   va_start (args, cell);
12004
12005   attribute = va_arg (args, gchar *);
12006
12007   while (attribute != NULL)
12008     {
12009       column_id = va_arg (args, gint);
12010       gtk_tree_view_column_add_attribute (column, cell, attribute, column_id);
12011       attribute = va_arg (args, gchar *);
12012     }
12013
12014   va_end (args);
12015
12016   gtk_tree_view_insert_column (tree_view, column, position);
12017
12018   return tree_view->priv->n_columns;
12019 }
12020
12021 /**
12022  * gtk_tree_view_insert_column_with_data_func:
12023  * @tree_view: a #GtkTreeView
12024  * @position: Position to insert, -1 for append
12025  * @title: column title
12026  * @cell: cell renderer for column
12027  * @func: function to set attributes of cell renderer
12028  * @data: data for @func
12029  * @dnotify: destroy notifier for @data
12030  *
12031  * Convenience function that inserts a new column into the #GtkTreeView
12032  * with the given cell renderer and a #GtkCellDataFunc to set cell renderer
12033  * attributes (normally using data from the model). See also
12034  * gtk_tree_view_column_set_cell_data_func(), gtk_tree_view_column_pack_start().
12035  * If @tree_view has "fixed_height" mode enabled, then the new column will have its
12036  * "sizing" property set to be GTK_TREE_VIEW_COLUMN_FIXED.
12037  *
12038  * Return value: number of columns in the tree view post-insert
12039  **/
12040 gint
12041 gtk_tree_view_insert_column_with_data_func  (GtkTreeView               *tree_view,
12042                                              gint                       position,
12043                                              const gchar               *title,
12044                                              GtkCellRenderer           *cell,
12045                                              GtkTreeCellDataFunc        func,
12046                                              gpointer                   data,
12047                                              GDestroyNotify             dnotify)
12048 {
12049   GtkTreeViewColumn *column;
12050
12051   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
12052
12053   column = gtk_tree_view_column_new ();
12054   if (tree_view->priv->fixed_height_mode)
12055     gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED);
12056
12057   gtk_tree_view_column_set_title (column, title);
12058   gtk_tree_view_column_pack_start (column, cell, TRUE);
12059   gtk_tree_view_column_set_cell_data_func (column, cell, func, data, dnotify);
12060
12061   gtk_tree_view_insert_column (tree_view, column, position);
12062
12063   return tree_view->priv->n_columns;
12064 }
12065
12066 /**
12067  * gtk_tree_view_get_column:
12068  * @tree_view: A #GtkTreeView.
12069  * @n: The position of the column, counting from 0.
12070  *
12071  * Gets the #GtkTreeViewColumn at the given position in the #tree_view.
12072  *
12073  * Return value: (transfer none): The #GtkTreeViewColumn, or %NULL if the
12074  *     position is outside the range of columns.
12075  **/
12076 GtkTreeViewColumn *
12077 gtk_tree_view_get_column (GtkTreeView *tree_view,
12078                           gint         n)
12079 {
12080   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
12081
12082   if (n < 0 || n >= tree_view->priv->n_columns)
12083     return NULL;
12084
12085   if (tree_view->priv->columns == NULL)
12086     return NULL;
12087
12088   return GTK_TREE_VIEW_COLUMN (g_list_nth (tree_view->priv->columns, n)->data);
12089 }
12090
12091 /**
12092  * gtk_tree_view_get_columns:
12093  * @tree_view: A #GtkTreeView
12094  *
12095  * Returns a #GList of all the #GtkTreeViewColumn s currently in @tree_view.
12096  * The returned list must be freed with g_list_free ().
12097  *
12098  * Return value: (element-type GtkTreeViewColumn) (transfer container): A list of #GtkTreeViewColumn s
12099  **/
12100 GList *
12101 gtk_tree_view_get_columns (GtkTreeView *tree_view)
12102 {
12103   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
12104
12105   return g_list_copy (tree_view->priv->columns);
12106 }
12107
12108 /**
12109  * gtk_tree_view_move_column_after:
12110  * @tree_view: A #GtkTreeView
12111  * @column: The #GtkTreeViewColumn to be moved.
12112  * @base_column: (allow-none): The #GtkTreeViewColumn to be moved relative to, or %NULL.
12113  *
12114  * Moves @column to be after to @base_column.  If @base_column is %NULL, then
12115  * @column is placed in the first position.
12116  **/
12117 void
12118 gtk_tree_view_move_column_after (GtkTreeView       *tree_view,
12119                                  GtkTreeViewColumn *column,
12120                                  GtkTreeViewColumn *base_column)
12121 {
12122   GList *column_list_el, *base_el = NULL;
12123
12124   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12125
12126   column_list_el = g_list_find (tree_view->priv->columns, column);
12127   g_return_if_fail (column_list_el != NULL);
12128
12129   if (base_column)
12130     {
12131       base_el = g_list_find (tree_view->priv->columns, base_column);
12132       g_return_if_fail (base_el != NULL);
12133     }
12134
12135   if (column_list_el->prev == base_el)
12136     return;
12137
12138   tree_view->priv->columns = g_list_remove_link (tree_view->priv->columns, column_list_el);
12139   if (base_el == NULL)
12140     {
12141       column_list_el->prev = NULL;
12142       column_list_el->next = tree_view->priv->columns;
12143       if (column_list_el->next)
12144         column_list_el->next->prev = column_list_el;
12145       tree_view->priv->columns = column_list_el;
12146     }
12147   else
12148     {
12149       column_list_el->prev = base_el;
12150       column_list_el->next = base_el->next;
12151       if (column_list_el->next)
12152         column_list_el->next->prev = column_list_el;
12153       base_el->next = column_list_el;
12154     }
12155
12156   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
12157     {
12158       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
12159       gtk_tree_view_size_allocate_columns (GTK_WIDGET (tree_view), NULL);
12160     }
12161
12162   g_signal_emit (tree_view, tree_view_signals[COLUMNS_CHANGED], 0);
12163 }
12164
12165 /**
12166  * gtk_tree_view_set_expander_column:
12167  * @tree_view: A #GtkTreeView
12168  * @column: %NULL, or the column to draw the expander arrow at.
12169  *
12170  * Sets the column to draw the expander arrow at. It must be in @tree_view.
12171  * If @column is %NULL, then the expander arrow is always at the first
12172  * visible column.
12173  *
12174  * If you do not want expander arrow to appear in your tree, set the
12175  * expander column to a hidden column.
12176  **/
12177 void
12178 gtk_tree_view_set_expander_column (GtkTreeView       *tree_view,
12179                                    GtkTreeViewColumn *column)
12180 {
12181   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12182   g_return_if_fail (column == NULL || GTK_IS_TREE_VIEW_COLUMN (column));
12183
12184   if (tree_view->priv->expander_column != column)
12185     {
12186       GList *list;
12187
12188       if (column)
12189         {
12190           /* Confirm that column is in tree_view */
12191           for (list = tree_view->priv->columns; list; list = list->next)
12192             if (list->data == column)
12193               break;
12194           g_return_if_fail (list != NULL);
12195         }
12196
12197       tree_view->priv->expander_column = column;
12198       g_object_notify (G_OBJECT (tree_view), "expander-column");
12199     }
12200 }
12201
12202 /**
12203  * gtk_tree_view_get_expander_column:
12204  * @tree_view: A #GtkTreeView
12205  *
12206  * Returns the column that is the current expander column.
12207  * This column has the expander arrow drawn next to it.
12208  *
12209  * Return value: (transfer none): The expander column.
12210  **/
12211 GtkTreeViewColumn *
12212 gtk_tree_view_get_expander_column (GtkTreeView *tree_view)
12213 {
12214   GList *list;
12215
12216   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
12217
12218   for (list = tree_view->priv->columns; list; list = list->next)
12219     if (gtk_tree_view_is_expander_column (tree_view, GTK_TREE_VIEW_COLUMN (list->data)))
12220       return (GtkTreeViewColumn *) list->data;
12221   return NULL;
12222 }
12223
12224
12225 /**
12226  * gtk_tree_view_set_column_drag_function:
12227  * @tree_view: A #GtkTreeView.
12228  * @func: (allow-none): A function to determine which columns are reorderable, or %NULL.
12229  * @user_data: (allow-none): User data to be passed to @func, or %NULL
12230  * @destroy: (allow-none): Destroy notifier for @user_data, or %NULL
12231  *
12232  * Sets a user function for determining where a column may be dropped when
12233  * dragged.  This function is called on every column pair in turn at the
12234  * beginning of a column drag to determine where a drop can take place.  The
12235  * arguments passed to @func are: the @tree_view, the #GtkTreeViewColumn being
12236  * dragged, the two #GtkTreeViewColumn s determining the drop spot, and
12237  * @user_data.  If either of the #GtkTreeViewColumn arguments for the drop spot
12238  * are %NULL, then they indicate an edge.  If @func is set to be %NULL, then
12239  * @tree_view reverts to the default behavior of allowing all columns to be
12240  * dropped everywhere.
12241  **/
12242 void
12243 gtk_tree_view_set_column_drag_function (GtkTreeView               *tree_view,
12244                                         GtkTreeViewColumnDropFunc  func,
12245                                         gpointer                   user_data,
12246                                         GDestroyNotify             destroy)
12247 {
12248   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12249
12250   if (tree_view->priv->column_drop_func_data_destroy)
12251     tree_view->priv->column_drop_func_data_destroy (tree_view->priv->column_drop_func_data);
12252
12253   tree_view->priv->column_drop_func = func;
12254   tree_view->priv->column_drop_func_data = user_data;
12255   tree_view->priv->column_drop_func_data_destroy = destroy;
12256 }
12257
12258 /**
12259  * gtk_tree_view_scroll_to_point:
12260  * @tree_view: a #GtkTreeView
12261  * @tree_x: X coordinate of new top-left pixel of visible area, or -1
12262  * @tree_y: Y coordinate of new top-left pixel of visible area, or -1
12263  *
12264  * Scrolls the tree view such that the top-left corner of the visible
12265  * area is @tree_x, @tree_y, where @tree_x and @tree_y are specified
12266  * in tree coordinates.  The @tree_view must be realized before
12267  * this function is called.  If it isn't, you probably want to be
12268  * using gtk_tree_view_scroll_to_cell().
12269  *
12270  * If either @tree_x or @tree_y are -1, then that direction isn't scrolled.
12271  **/
12272 void
12273 gtk_tree_view_scroll_to_point (GtkTreeView *tree_view,
12274                                gint         tree_x,
12275                                gint         tree_y)
12276 {
12277   GtkAdjustment *hadj;
12278   GtkAdjustment *vadj;
12279
12280   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12281   g_return_if_fail (gtk_widget_get_realized (GTK_WIDGET (tree_view)));
12282
12283   hadj = tree_view->priv->hadjustment;
12284   vadj = tree_view->priv->vadjustment;
12285
12286   if (tree_x != -1)
12287     gtk_adjustment_set_value (hadj, tree_x);
12288   if (tree_y != -1)
12289     gtk_adjustment_set_value (vadj, tree_y);
12290 }
12291
12292 /**
12293  * gtk_tree_view_scroll_to_cell:
12294  * @tree_view: A #GtkTreeView.
12295  * @path: (allow-none): The path of the row to move to, or %NULL.
12296  * @column: (allow-none): The #GtkTreeViewColumn to move horizontally to, or %NULL.
12297  * @use_align: whether to use alignment arguments, or %FALSE.
12298  * @row_align: The vertical alignment of the row specified by @path.
12299  * @col_align: The horizontal alignment of the column specified by @column.
12300  *
12301  * Moves the alignments of @tree_view to the position specified by @column and
12302  * @path.  If @column is %NULL, then no horizontal scrolling occurs.  Likewise,
12303  * if @path is %NULL no vertical scrolling occurs.  At a minimum, one of @column
12304  * or @path need to be non-%NULL.  @row_align determines where the row is
12305  * placed, and @col_align determines where @column is placed.  Both are expected
12306  * to be between 0.0 and 1.0. 0.0 means left/top alignment, 1.0 means
12307  * right/bottom alignment, 0.5 means center.
12308  *
12309  * If @use_align is %FALSE, then the alignment arguments are ignored, and the
12310  * tree does the minimum amount of work to scroll the cell onto the screen.
12311  * This means that the cell will be scrolled to the edge closest to its current
12312  * position.  If the cell is currently visible on the screen, nothing is done.
12313  *
12314  * This function only works if the model is set, and @path is a valid row on the
12315  * model.  If the model changes before the @tree_view is realized, the centered
12316  * path will be modified to reflect this change.
12317  **/
12318 void
12319 gtk_tree_view_scroll_to_cell (GtkTreeView       *tree_view,
12320                               GtkTreePath       *path,
12321                               GtkTreeViewColumn *column,
12322                               gboolean           use_align,
12323                               gfloat             row_align,
12324                               gfloat             col_align)
12325 {
12326   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12327   g_return_if_fail (tree_view->priv->model != NULL);
12328   g_return_if_fail (tree_view->priv->tree != NULL);
12329   g_return_if_fail (row_align >= 0.0 && row_align <= 1.0);
12330   g_return_if_fail (col_align >= 0.0 && col_align <= 1.0);
12331   g_return_if_fail (path != NULL || column != NULL);
12332
12333 #if 0
12334   g_print ("gtk_tree_view_scroll_to_cell:\npath: %s\ncolumn: %s\nuse_align: %d\nrow_align: %f\ncol_align: %f\n",
12335            gtk_tree_path_to_string (path), column?"non-null":"null", use_align, row_align, col_align);
12336 #endif
12337   row_align = CLAMP (row_align, 0.0, 1.0);
12338   col_align = CLAMP (col_align, 0.0, 1.0);
12339
12340
12341   /* Note: Despite the benefits that come from having one code path for the
12342    * scrolling code, we short-circuit validate_visible_area's immplementation as
12343    * it is much slower than just going to the point.
12344    */
12345   if (!gtk_widget_get_visible (GTK_WIDGET (tree_view)) ||
12346       !gtk_widget_get_realized (GTK_WIDGET (tree_view)) ||
12347       _gtk_widget_get_alloc_needed (GTK_WIDGET (tree_view)) ||
12348       GTK_RBNODE_FLAG_SET (tree_view->priv->tree->root, GTK_RBNODE_DESCENDANTS_INVALID))
12349     {
12350       if (tree_view->priv->scroll_to_path)
12351         gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
12352
12353       tree_view->priv->scroll_to_path = NULL;
12354       tree_view->priv->scroll_to_column = NULL;
12355
12356       if (path)
12357         tree_view->priv->scroll_to_path = gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view), tree_view->priv->model, path);
12358       if (column)
12359         tree_view->priv->scroll_to_column = column;
12360       tree_view->priv->scroll_to_use_align = use_align;
12361       tree_view->priv->scroll_to_row_align = row_align;
12362       tree_view->priv->scroll_to_col_align = col_align;
12363
12364       install_presize_handler (tree_view);
12365     }
12366   else
12367     {
12368       GdkRectangle cell_rect;
12369       GdkRectangle vis_rect;
12370       gint dest_x, dest_y;
12371
12372       gtk_tree_view_get_background_area (tree_view, path, column, &cell_rect);
12373       gtk_tree_view_get_visible_rect (tree_view, &vis_rect);
12374
12375       cell_rect.y = TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, cell_rect.y);
12376
12377       dest_x = vis_rect.x;
12378       dest_y = vis_rect.y;
12379
12380       if (column)
12381         {
12382           if (use_align)
12383             {
12384               dest_x = cell_rect.x - ((vis_rect.width - cell_rect.width) * col_align);
12385             }
12386           else
12387             {
12388               if (cell_rect.x < vis_rect.x)
12389                 dest_x = cell_rect.x;
12390               if (cell_rect.x + cell_rect.width > vis_rect.x + vis_rect.width)
12391                 dest_x = cell_rect.x + cell_rect.width - vis_rect.width;
12392             }
12393         }
12394
12395       if (path)
12396         {
12397           if (use_align)
12398             {
12399               dest_y = cell_rect.y - ((vis_rect.height - cell_rect.height) * row_align);
12400               dest_y = MAX (dest_y, 0);
12401             }
12402           else
12403             {
12404               if (cell_rect.y < vis_rect.y)
12405                 dest_y = cell_rect.y;
12406               if (cell_rect.y + cell_rect.height > vis_rect.y + vis_rect.height)
12407                 dest_y = cell_rect.y + cell_rect.height - vis_rect.height;
12408             }
12409         }
12410
12411       gtk_tree_view_scroll_to_point (tree_view, dest_x, dest_y);
12412     }
12413 }
12414
12415 /**
12416  * gtk_tree_view_row_activated:
12417  * @tree_view: A #GtkTreeView
12418  * @path: The #GtkTreePath to be activated.
12419  * @column: The #GtkTreeViewColumn to be activated.
12420  *
12421  * Activates the cell determined by @path and @column.
12422  **/
12423 void
12424 gtk_tree_view_row_activated (GtkTreeView       *tree_view,
12425                              GtkTreePath       *path,
12426                              GtkTreeViewColumn *column)
12427 {
12428   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12429
12430   g_signal_emit (tree_view, tree_view_signals[ROW_ACTIVATED], 0, path, column);
12431 }
12432
12433
12434 static void
12435 gtk_tree_view_expand_all_emission_helper (GtkRBTree *tree,
12436                                           GtkRBNode *node,
12437                                           gpointer   data)
12438 {
12439   GtkTreeView *tree_view = data;
12440
12441   if ((node->flags & GTK_RBNODE_IS_PARENT) == GTK_RBNODE_IS_PARENT &&
12442       node->children)
12443     {
12444       GtkTreePath *path;
12445       GtkTreeIter iter;
12446
12447       path = _gtk_tree_view_find_path (tree_view, tree, node);
12448       gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
12449
12450       g_signal_emit (tree_view, tree_view_signals[ROW_EXPANDED], 0, &iter, path);
12451
12452       gtk_tree_path_free (path);
12453     }
12454
12455   if (node->children)
12456     _gtk_rbtree_traverse (node->children,
12457                           node->children->root,
12458                           G_PRE_ORDER,
12459                           gtk_tree_view_expand_all_emission_helper,
12460                           tree_view);
12461 }
12462
12463 /**
12464  * gtk_tree_view_expand_all:
12465  * @tree_view: A #GtkTreeView.
12466  *
12467  * Recursively expands all nodes in the @tree_view.
12468  **/
12469 void
12470 gtk_tree_view_expand_all (GtkTreeView *tree_view)
12471 {
12472   GtkTreePath *path;
12473   GtkRBTree *tree;
12474   GtkRBNode *node;
12475
12476   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12477
12478   if (tree_view->priv->tree == NULL)
12479     return;
12480
12481   path = gtk_tree_path_new_first ();
12482   _gtk_tree_view_find_node (tree_view, path, &tree, &node);
12483
12484   while (node)
12485     {
12486       gtk_tree_view_real_expand_row (tree_view, path, tree, node, TRUE, FALSE);
12487       node = _gtk_rbtree_next (tree, node);
12488       gtk_tree_path_next (path);
12489   }
12490
12491   gtk_tree_path_free (path);
12492 }
12493
12494 /* Timeout to animate the expander during expands and collapses */
12495 static gboolean
12496 expand_collapse_timeout (gpointer data)
12497 {
12498   return do_expand_collapse (data);
12499 }
12500
12501 static void
12502 add_expand_collapse_timeout (GtkTreeView *tree_view,
12503                              GtkRBTree   *tree,
12504                              GtkRBNode   *node,
12505                              gboolean     expand)
12506 {
12507   if (tree_view->priv->expand_collapse_timeout != 0)
12508     return;
12509
12510   tree_view->priv->expand_collapse_timeout =
12511       gdk_threads_add_timeout (50, expand_collapse_timeout, tree_view);
12512   tree_view->priv->expanded_collapsed_tree = tree;
12513   tree_view->priv->expanded_collapsed_node = node;
12514
12515   if (expand)
12516     GTK_RBNODE_SET_FLAG (node, GTK_RBNODE_IS_SEMI_COLLAPSED);
12517   else
12518     GTK_RBNODE_SET_FLAG (node, GTK_RBNODE_IS_SEMI_EXPANDED);
12519 }
12520
12521 static void
12522 remove_expand_collapse_timeout (GtkTreeView *tree_view)
12523 {
12524   if (tree_view->priv->expand_collapse_timeout)
12525     {
12526       g_source_remove (tree_view->priv->expand_collapse_timeout);
12527       tree_view->priv->expand_collapse_timeout = 0;
12528     }
12529
12530   if (tree_view->priv->expanded_collapsed_node != NULL)
12531     {
12532       GTK_RBNODE_UNSET_FLAG (tree_view->priv->expanded_collapsed_node, GTK_RBNODE_IS_SEMI_EXPANDED);
12533       GTK_RBNODE_UNSET_FLAG (tree_view->priv->expanded_collapsed_node, GTK_RBNODE_IS_SEMI_COLLAPSED);
12534
12535       tree_view->priv->expanded_collapsed_node = NULL;
12536     }
12537 }
12538
12539 static void
12540 cancel_arrow_animation (GtkTreeView *tree_view)
12541 {
12542   if (tree_view->priv->expand_collapse_timeout)
12543     {
12544       while (do_expand_collapse (tree_view));
12545
12546       remove_expand_collapse_timeout (tree_view);
12547     }
12548 }
12549
12550 static gboolean
12551 do_expand_collapse (GtkTreeView *tree_view)
12552 {
12553   GtkRBNode *node;
12554   GtkRBTree *tree;
12555   gboolean expanding;
12556   gboolean redraw;
12557
12558   redraw = FALSE;
12559   expanding = TRUE;
12560
12561   node = tree_view->priv->expanded_collapsed_node;
12562   tree = tree_view->priv->expanded_collapsed_tree;
12563
12564   if (node->children == NULL)
12565     expanding = FALSE;
12566
12567   if (expanding)
12568     {
12569       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SEMI_COLLAPSED))
12570         {
12571           GTK_RBNODE_UNSET_FLAG (node, GTK_RBNODE_IS_SEMI_COLLAPSED);
12572           GTK_RBNODE_SET_FLAG (node, GTK_RBNODE_IS_SEMI_EXPANDED);
12573
12574           redraw = TRUE;
12575
12576         }
12577       else if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SEMI_EXPANDED))
12578         {
12579           GTK_RBNODE_UNSET_FLAG (node, GTK_RBNODE_IS_SEMI_EXPANDED);
12580
12581           redraw = TRUE;
12582         }
12583     }
12584   else
12585     {
12586       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SEMI_EXPANDED))
12587         {
12588           GTK_RBNODE_UNSET_FLAG (node, GTK_RBNODE_IS_SEMI_EXPANDED);
12589           GTK_RBNODE_SET_FLAG (node, GTK_RBNODE_IS_SEMI_COLLAPSED);
12590
12591           redraw = TRUE;
12592         }
12593       else if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SEMI_COLLAPSED))
12594         {
12595           GTK_RBNODE_UNSET_FLAG (node, GTK_RBNODE_IS_SEMI_COLLAPSED);
12596
12597           redraw = TRUE;
12598
12599         }
12600     }
12601
12602   if (redraw)
12603     {
12604       gtk_tree_view_queue_draw_arrow (tree_view, tree, node);
12605
12606       return TRUE;
12607     }
12608
12609   return FALSE;
12610 }
12611
12612 /**
12613  * gtk_tree_view_collapse_all:
12614  * @tree_view: A #GtkTreeView.
12615  *
12616  * Recursively collapses all visible, expanded nodes in @tree_view.
12617  **/
12618 void
12619 gtk_tree_view_collapse_all (GtkTreeView *tree_view)
12620 {
12621   GtkRBTree *tree;
12622   GtkRBNode *node;
12623   GtkTreePath *path;
12624   gint *indices;
12625
12626   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12627
12628   if (tree_view->priv->tree == NULL)
12629     return;
12630
12631   path = gtk_tree_path_new ();
12632   gtk_tree_path_down (path);
12633   indices = gtk_tree_path_get_indices (path);
12634
12635   tree = tree_view->priv->tree;
12636   node = tree->root;
12637   while (node && node->left != tree->nil)
12638     node = node->left;
12639
12640   while (node)
12641     {
12642       if (node->children)
12643         gtk_tree_view_real_collapse_row (tree_view, path, tree, node, FALSE);
12644       indices[0]++;
12645       node = _gtk_rbtree_next (tree, node);
12646     }
12647
12648   gtk_tree_path_free (path);
12649 }
12650
12651 /**
12652  * gtk_tree_view_expand_to_path:
12653  * @tree_view: A #GtkTreeView.
12654  * @path: path to a row.
12655  *
12656  * Expands the row at @path. This will also expand all parent rows of
12657  * @path as necessary.
12658  *
12659  * Since: 2.2
12660  **/
12661 void
12662 gtk_tree_view_expand_to_path (GtkTreeView *tree_view,
12663                               GtkTreePath *path)
12664 {
12665   gint i, depth;
12666   gint *indices;
12667   GtkTreePath *tmp;
12668
12669   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12670   g_return_if_fail (path != NULL);
12671
12672   depth = gtk_tree_path_get_depth (path);
12673   indices = gtk_tree_path_get_indices (path);
12674
12675   tmp = gtk_tree_path_new ();
12676   g_return_if_fail (tmp != NULL);
12677
12678   for (i = 0; i < depth; i++)
12679     {
12680       gtk_tree_path_append_index (tmp, indices[i]);
12681       gtk_tree_view_expand_row (tree_view, tmp, FALSE);
12682     }
12683
12684   gtk_tree_path_free (tmp);
12685 }
12686
12687 /* FIXME the bool return values for expand_row and collapse_row are
12688  * not analagous; they should be TRUE if the row had children and
12689  * was not already in the requested state.
12690  */
12691
12692
12693 static gboolean
12694 gtk_tree_view_real_expand_row (GtkTreeView *tree_view,
12695                                GtkTreePath *path,
12696                                GtkRBTree   *tree,
12697                                GtkRBNode   *node,
12698                                gboolean     open_all,
12699                                gboolean     animate)
12700 {
12701   GtkTreeIter iter;
12702   GtkTreeIter temp;
12703   gboolean expand;
12704
12705   if (animate)
12706     g_object_get (gtk_widget_get_settings (GTK_WIDGET (tree_view)),
12707                   "gtk-enable-animations", &animate,
12708                   NULL);
12709
12710   remove_auto_expand_timeout (tree_view);
12711
12712   if (node->children && !open_all)
12713     return FALSE;
12714
12715   if (! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT))
12716     return FALSE;
12717
12718   gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
12719   if (! gtk_tree_model_iter_has_child (tree_view->priv->model, &iter))
12720     return FALSE;
12721
12722
12723    if (node->children && open_all)
12724     {
12725       gboolean retval = FALSE;
12726       GtkTreePath *tmp_path = gtk_tree_path_copy (path);
12727
12728       gtk_tree_path_append_index (tmp_path, 0);
12729       tree = node->children;
12730       node = tree->root;
12731       while (node->left != tree->nil)
12732         node = node->left;
12733       /* try to expand the children */
12734       do
12735         {
12736          gboolean t;
12737          t = gtk_tree_view_real_expand_row (tree_view, tmp_path, tree, node,
12738                                             TRUE, animate);
12739          if (t)
12740            retval = TRUE;
12741
12742          gtk_tree_path_next (tmp_path);
12743          node = _gtk_rbtree_next (tree, node);
12744        }
12745       while (node != NULL);
12746
12747       gtk_tree_path_free (tmp_path);
12748
12749       return retval;
12750     }
12751
12752   g_signal_emit (tree_view, tree_view_signals[TEST_EXPAND_ROW], 0, &iter, path, &expand);
12753
12754   if (!gtk_tree_model_iter_has_child (tree_view->priv->model, &iter))
12755     return FALSE;
12756
12757   if (expand)
12758     return FALSE;
12759
12760   node->children = _gtk_rbtree_new ();
12761   node->children->parent_tree = tree;
12762   node->children->parent_node = node;
12763
12764   gtk_tree_model_iter_children (tree_view->priv->model, &temp, &iter);
12765
12766   gtk_tree_view_build_tree (tree_view,
12767                             node->children,
12768                             &temp,
12769                             gtk_tree_path_get_depth (path) + 1,
12770                             open_all);
12771
12772   remove_expand_collapse_timeout (tree_view);
12773
12774   if (animate)
12775     add_expand_collapse_timeout (tree_view, tree, node, TRUE);
12776
12777   install_presize_handler (tree_view);
12778
12779   g_signal_emit (tree_view, tree_view_signals[ROW_EXPANDED], 0, &iter, path);
12780   if (open_all && node->children)
12781     {
12782       _gtk_rbtree_traverse (node->children,
12783                             node->children->root,
12784                             G_PRE_ORDER,
12785                             gtk_tree_view_expand_all_emission_helper,
12786                             tree_view);
12787     }
12788   return TRUE;
12789 }
12790
12791
12792 /**
12793  * gtk_tree_view_expand_row:
12794  * @tree_view: a #GtkTreeView
12795  * @path: path to a row
12796  * @open_all: whether to recursively expand, or just expand immediate children
12797  *
12798  * Opens the row so its children are visible.
12799  *
12800  * Return value: %TRUE if the row existed and had children
12801  **/
12802 gboolean
12803 gtk_tree_view_expand_row (GtkTreeView *tree_view,
12804                           GtkTreePath *path,
12805                           gboolean     open_all)
12806 {
12807   GtkRBTree *tree;
12808   GtkRBNode *node;
12809
12810   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
12811   g_return_val_if_fail (tree_view->priv->model != NULL, FALSE);
12812   g_return_val_if_fail (path != NULL, FALSE);
12813
12814   if (_gtk_tree_view_find_node (tree_view,
12815                                 path,
12816                                 &tree,
12817                                 &node))
12818     return FALSE;
12819
12820   if (tree != NULL)
12821     return gtk_tree_view_real_expand_row (tree_view, path, tree, node, open_all, FALSE);
12822   else
12823     return FALSE;
12824 }
12825
12826 static gboolean
12827 gtk_tree_view_real_collapse_row (GtkTreeView *tree_view,
12828                                  GtkTreePath *path,
12829                                  GtkRBTree   *tree,
12830                                  GtkRBNode   *node,
12831                                  gboolean     animate)
12832 {
12833   GtkTreeIter iter;
12834   GtkTreeIter children;
12835   gboolean collapse;
12836   gint x, y;
12837   GList *list;
12838   GdkWindow *child, *parent;
12839
12840   if (animate)
12841     g_object_get (gtk_widget_get_settings (GTK_WIDGET (tree_view)),
12842                   "gtk-enable-animations", &animate,
12843                   NULL);
12844
12845   remove_auto_expand_timeout (tree_view);
12846
12847   if (node->children == NULL)
12848     return FALSE;
12849
12850   gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
12851
12852   g_signal_emit (tree_view, tree_view_signals[TEST_COLLAPSE_ROW], 0, &iter, path, &collapse);
12853
12854   if (collapse)
12855     return FALSE;
12856
12857   /* if the prelighted node is a child of us, we want to unprelight it.  We have
12858    * a chance to prelight the correct node below */
12859
12860   if (tree_view->priv->prelight_tree)
12861     {
12862       GtkRBTree *parent_tree;
12863       GtkRBNode *parent_node;
12864
12865       parent_tree = tree_view->priv->prelight_tree->parent_tree;
12866       parent_node = tree_view->priv->prelight_tree->parent_node;
12867       while (parent_tree)
12868         {
12869           if (parent_tree == tree && parent_node == node)
12870             {
12871               ensure_unprelighted (tree_view);
12872               break;
12873             }
12874           parent_node = parent_tree->parent_node;
12875           parent_tree = parent_tree->parent_tree;
12876         }
12877     }
12878
12879   TREE_VIEW_INTERNAL_ASSERT (gtk_tree_model_iter_children (tree_view->priv->model, &children, &iter), FALSE);
12880
12881   for (list = tree_view->priv->columns; list; list = list->next)
12882     {
12883       GtkTreeViewColumn *column = list->data;
12884
12885       if (gtk_tree_view_column_get_visible (column) == FALSE)
12886         continue;
12887       if (gtk_tree_view_column_get_sizing (column) == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
12888         _gtk_tree_view_column_cell_set_dirty (column, TRUE);
12889     }
12890
12891   if (tree_view->priv->destroy_count_func)
12892     {
12893       GtkTreePath *child_path;
12894       gint child_count = 0;
12895       child_path = gtk_tree_path_copy (path);
12896       gtk_tree_path_down (child_path);
12897       if (node->children)
12898         _gtk_rbtree_traverse (node->children, node->children->root, G_POST_ORDER, count_children_helper, &child_count);
12899       tree_view->priv->destroy_count_func (tree_view, child_path, child_count, tree_view->priv->destroy_count_data);
12900       gtk_tree_path_free (child_path);
12901     }
12902
12903   if (gtk_tree_row_reference_valid (tree_view->priv->cursor))
12904     {
12905       GtkTreePath *cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
12906
12907       if (gtk_tree_path_is_ancestor (path, cursor_path))
12908         {
12909           gtk_tree_row_reference_free (tree_view->priv->cursor);
12910           tree_view->priv->cursor = gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view),
12911                                                                       tree_view->priv->model,
12912                                                                       path);
12913         }
12914       gtk_tree_path_free (cursor_path);
12915     }
12916
12917   if (gtk_tree_row_reference_valid (tree_view->priv->anchor))
12918     {
12919       GtkTreePath *anchor_path = gtk_tree_row_reference_get_path (tree_view->priv->anchor);
12920       if (gtk_tree_path_is_ancestor (path, anchor_path))
12921         {
12922           gtk_tree_row_reference_free (tree_view->priv->anchor);
12923           tree_view->priv->anchor = NULL;
12924         }
12925       gtk_tree_path_free (anchor_path);
12926     }
12927
12928   /* Stop a pending double click */
12929   tree_view->priv->last_button_x = -1;
12930   tree_view->priv->last_button_y = -1;
12931
12932   remove_expand_collapse_timeout (tree_view);
12933
12934   if (gtk_tree_view_unref_and_check_selection_tree (tree_view, node->children))
12935     {
12936       _gtk_rbtree_remove (node->children);
12937       g_signal_emit_by_name (tree_view->priv->selection, "changed");
12938     }
12939   else
12940     _gtk_rbtree_remove (node->children);
12941
12942   if (animate)
12943     add_expand_collapse_timeout (tree_view, tree, node, FALSE);
12944
12945   if (gtk_widget_get_mapped (GTK_WIDGET (tree_view)))
12946     {
12947       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
12948     }
12949
12950   g_signal_emit (tree_view, tree_view_signals[ROW_COLLAPSED], 0, &iter, path);
12951
12952   if (gtk_widget_get_mapped (GTK_WIDGET (tree_view)))
12953     {
12954       /* now that we've collapsed all rows, we want to try to set the prelight
12955        * again. To do this, we fake a motion event and send it to ourselves. */
12956
12957       child = tree_view->priv->bin_window;
12958       parent = gdk_window_get_parent (child);
12959
12960       if (gdk_window_get_pointer (parent, &x, &y, NULL) == child)
12961         {
12962           GdkEventMotion event;
12963           gint child_x, child_y;
12964
12965           gdk_window_get_position (child, &child_x, &child_y);
12966
12967           event.window = tree_view->priv->bin_window;
12968           event.x = x - child_x;
12969           event.y = y - child_y;
12970
12971           /* despite the fact this isn't a real event, I'm almost positive it will
12972            * never trigger a drag event.  maybe_drag is the only function that uses
12973            * more than just event.x and event.y. */
12974           gtk_tree_view_motion_bin_window (GTK_WIDGET (tree_view), &event);
12975         }
12976     }
12977
12978   return TRUE;
12979 }
12980
12981 /**
12982  * gtk_tree_view_collapse_row:
12983  * @tree_view: a #GtkTreeView
12984  * @path: path to a row in the @tree_view
12985  *
12986  * Collapses a row (hides its child rows, if they exist).
12987  *
12988  * Return value: %TRUE if the row was collapsed.
12989  **/
12990 gboolean
12991 gtk_tree_view_collapse_row (GtkTreeView *tree_view,
12992                             GtkTreePath *path)
12993 {
12994   GtkRBTree *tree;
12995   GtkRBNode *node;
12996
12997   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
12998   g_return_val_if_fail (tree_view->priv->tree != NULL, FALSE);
12999   g_return_val_if_fail (path != NULL, FALSE);
13000
13001   if (_gtk_tree_view_find_node (tree_view,
13002                                 path,
13003                                 &tree,
13004                                 &node))
13005     return FALSE;
13006
13007   if (tree == NULL || node->children == NULL)
13008     return FALSE;
13009
13010   return gtk_tree_view_real_collapse_row (tree_view, path, tree, node, FALSE);
13011 }
13012
13013 static void
13014 gtk_tree_view_map_expanded_rows_helper (GtkTreeView            *tree_view,
13015                                         GtkRBTree              *tree,
13016                                         GtkTreePath            *path,
13017                                         GtkTreeViewMappingFunc  func,
13018                                         gpointer                user_data)
13019 {
13020   GtkRBNode *node;
13021
13022   if (tree == NULL || tree->root == NULL)
13023     return;
13024
13025   node = tree->root;
13026
13027   while (node && node->left != tree->nil)
13028     node = node->left;
13029
13030   while (node)
13031     {
13032       if (node->children)
13033         {
13034           (* func) (tree_view, path, user_data);
13035           gtk_tree_path_down (path);
13036           gtk_tree_view_map_expanded_rows_helper (tree_view, node->children, path, func, user_data);
13037           gtk_tree_path_up (path);
13038         }
13039       gtk_tree_path_next (path);
13040       node = _gtk_rbtree_next (tree, node);
13041     }
13042 }
13043
13044 /**
13045  * gtk_tree_view_map_expanded_rows:
13046  * @tree_view: A #GtkTreeView
13047  * @func: (scope call): A function to be called
13048  * @data: User data to be passed to the function.
13049  *
13050  * Calls @func on all expanded rows.
13051  **/
13052 void
13053 gtk_tree_view_map_expanded_rows (GtkTreeView            *tree_view,
13054                                  GtkTreeViewMappingFunc  func,
13055                                  gpointer                user_data)
13056 {
13057   GtkTreePath *path;
13058
13059   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13060   g_return_if_fail (func != NULL);
13061
13062   path = gtk_tree_path_new_first ();
13063
13064   gtk_tree_view_map_expanded_rows_helper (tree_view,
13065                                           tree_view->priv->tree,
13066                                           path, func, user_data);
13067
13068   gtk_tree_path_free (path);
13069 }
13070
13071 /**
13072  * gtk_tree_view_row_expanded:
13073  * @tree_view: A #GtkTreeView.
13074  * @path: A #GtkTreePath to test expansion state.
13075  *
13076  * Returns %TRUE if the node pointed to by @path is expanded in @tree_view.
13077  *
13078  * Return value: %TRUE if #path is expanded.
13079  **/
13080 gboolean
13081 gtk_tree_view_row_expanded (GtkTreeView *tree_view,
13082                             GtkTreePath *path)
13083 {
13084   GtkRBTree *tree;
13085   GtkRBNode *node;
13086
13087   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
13088   g_return_val_if_fail (path != NULL, FALSE);
13089
13090   _gtk_tree_view_find_node (tree_view, path, &tree, &node);
13091
13092   if (node == NULL)
13093     return FALSE;
13094
13095   return (node->children != NULL);
13096 }
13097
13098 /**
13099  * gtk_tree_view_get_reorderable:
13100  * @tree_view: a #GtkTreeView
13101  *
13102  * Retrieves whether the user can reorder the tree via drag-and-drop. See
13103  * gtk_tree_view_set_reorderable().
13104  *
13105  * Return value: %TRUE if the tree can be reordered.
13106  **/
13107 gboolean
13108 gtk_tree_view_get_reorderable (GtkTreeView *tree_view)
13109 {
13110   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
13111
13112   return tree_view->priv->reorderable;
13113 }
13114
13115 /**
13116  * gtk_tree_view_set_reorderable:
13117  * @tree_view: A #GtkTreeView.
13118  * @reorderable: %TRUE, if the tree can be reordered.
13119  *
13120  * This function is a convenience function to allow you to reorder
13121  * models that support the #GtkDragSourceIface and the
13122  * #GtkDragDestIface.  Both #GtkTreeStore and #GtkListStore support
13123  * these.  If @reorderable is %TRUE, then the user can reorder the
13124  * model by dragging and dropping rows. The developer can listen to
13125  * these changes by connecting to the model's row_inserted and
13126  * row_deleted signals. The reordering is implemented by setting up
13127  * the tree view as a drag source and destination. Therefore, drag and
13128  * drop can not be used in a reorderable view for any other purpose.
13129  *
13130  * This function does not give you any degree of control over the order -- any
13131  * reordering is allowed.  If more control is needed, you should probably
13132  * handle drag and drop manually.
13133  **/
13134 void
13135 gtk_tree_view_set_reorderable (GtkTreeView *tree_view,
13136                                gboolean     reorderable)
13137 {
13138   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13139
13140   reorderable = reorderable != FALSE;
13141
13142   if (tree_view->priv->reorderable == reorderable)
13143     return;
13144
13145   if (reorderable)
13146     {
13147       const GtkTargetEntry row_targets[] = {
13148         { "GTK_TREE_MODEL_ROW", GTK_TARGET_SAME_WIDGET, 0 }
13149       };
13150
13151       gtk_tree_view_enable_model_drag_source (tree_view,
13152                                               GDK_BUTTON1_MASK,
13153                                               row_targets,
13154                                               G_N_ELEMENTS (row_targets),
13155                                               GDK_ACTION_MOVE);
13156       gtk_tree_view_enable_model_drag_dest (tree_view,
13157                                             row_targets,
13158                                             G_N_ELEMENTS (row_targets),
13159                                             GDK_ACTION_MOVE);
13160     }
13161   else
13162     {
13163       gtk_tree_view_unset_rows_drag_source (tree_view);
13164       gtk_tree_view_unset_rows_drag_dest (tree_view);
13165     }
13166
13167   tree_view->priv->reorderable = reorderable;
13168
13169   g_object_notify (G_OBJECT (tree_view), "reorderable");
13170 }
13171
13172 static void
13173 gtk_tree_view_real_set_cursor (GtkTreeView     *tree_view,
13174                                GtkTreePath     *path,
13175                                gboolean         clear_and_select,
13176                                gboolean         clamp_node)
13177 {
13178   GtkRBTree *tree = NULL;
13179   GtkRBNode *node = NULL;
13180
13181   if (gtk_tree_row_reference_valid (tree_view->priv->cursor))
13182     {
13183       GtkTreePath *cursor_path;
13184       cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
13185       gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
13186       gtk_tree_path_free (cursor_path);
13187     }
13188
13189   gtk_tree_row_reference_free (tree_view->priv->cursor);
13190   tree_view->priv->cursor = NULL;
13191
13192   /* One cannot set the cursor on a separator.   Also, if
13193    * _gtk_tree_view_find_node returns TRUE, it ran out of tree
13194    * before finding the tree and node belonging to path.  The
13195    * path maps to a non-existing path and we will silently bail out.
13196    * We unset tree and node to avoid further processing.
13197    */
13198   if (!row_is_separator (tree_view, NULL, path)
13199       && _gtk_tree_view_find_node (tree_view, path, &tree, &node) == FALSE)
13200     {
13201       tree_view->priv->cursor =
13202           gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view),
13203                                             tree_view->priv->model,
13204                                             path);
13205     }
13206   else
13207     {
13208       tree = NULL;
13209       node = NULL;
13210     }
13211
13212   if (tree != NULL)
13213     {
13214       GtkRBTree *new_tree = NULL;
13215       GtkRBNode *new_node = NULL;
13216
13217       if (clear_and_select && !tree_view->priv->ctrl_pressed)
13218         {
13219           GtkTreeSelectMode mode = 0;
13220
13221           if (tree_view->priv->ctrl_pressed)
13222             mode |= GTK_TREE_SELECT_MODE_TOGGLE;
13223           if (tree_view->priv->shift_pressed)
13224             mode |= GTK_TREE_SELECT_MODE_EXTEND;
13225
13226           _gtk_tree_selection_internal_select_node (tree_view->priv->selection,
13227                                                     node, tree, path, mode,
13228                                                     FALSE);
13229         }
13230
13231       /* We have to re-find tree and node here again, somebody might have
13232        * cleared the node or the whole tree in the GtkTreeSelection::changed
13233        * callback. If the nodes differ we bail out here.
13234        */
13235       _gtk_tree_view_find_node (tree_view, path, &new_tree, &new_node);
13236
13237       if (tree != new_tree || node != new_node)
13238         return;
13239
13240       if (clamp_node)
13241         {
13242           gtk_tree_view_clamp_node_visible (tree_view, tree, node);
13243           _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
13244         }
13245     }
13246
13247   g_signal_emit (tree_view, tree_view_signals[CURSOR_CHANGED], 0);
13248 }
13249
13250 /**
13251  * gtk_tree_view_get_cursor:
13252  * @tree_view: A #GtkTreeView
13253  * @path: (out) (allow-none): A pointer to be filled with the current cursor path, or %NULL
13254  * @focus_column: (out) (allow-none): A pointer to be filled with the current focus column, or %NULL
13255  *
13256  * Fills in @path and @focus_column with the current path and focus column.  If
13257  * the cursor isn't currently set, then *@path will be %NULL.  If no column
13258  * currently has focus, then *@focus_column will be %NULL.
13259  *
13260  * The returned #GtkTreePath must be freed with gtk_tree_path_free() when
13261  * you are done with it.
13262  **/
13263 void
13264 gtk_tree_view_get_cursor (GtkTreeView        *tree_view,
13265                           GtkTreePath       **path,
13266                           GtkTreeViewColumn **focus_column)
13267 {
13268   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13269
13270   if (path)
13271     {
13272       if (gtk_tree_row_reference_valid (tree_view->priv->cursor))
13273         *path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
13274       else
13275         *path = NULL;
13276     }
13277
13278   if (focus_column)
13279     {
13280       *focus_column = tree_view->priv->focus_column;
13281     }
13282 }
13283
13284 /**
13285  * gtk_tree_view_set_cursor:
13286  * @tree_view: A #GtkTreeView
13287  * @path: A #GtkTreePath
13288  * @focus_column: (allow-none): A #GtkTreeViewColumn, or %NULL
13289  * @start_editing: %TRUE if the specified cell should start being edited.
13290  *
13291  * Sets the current keyboard focus to be at @path, and selects it.  This is
13292  * useful when you want to focus the user's attention on a particular row.  If
13293  * @focus_column is not %NULL, then focus is given to the column specified by
13294  * it. Additionally, if @focus_column is specified, and @start_editing is
13295  * %TRUE, then editing should be started in the specified cell.
13296  * This function is often followed by @gtk_widget_grab_focus (@tree_view)
13297  * in order to give keyboard focus to the widget.  Please note that editing
13298  * can only happen when the widget is realized.
13299  *
13300  * If @path is invalid for @model, the current cursor (if any) will be unset
13301  * and the function will return without failing.
13302  **/
13303 void
13304 gtk_tree_view_set_cursor (GtkTreeView       *tree_view,
13305                           GtkTreePath       *path,
13306                           GtkTreeViewColumn *focus_column,
13307                           gboolean           start_editing)
13308 {
13309   gtk_tree_view_set_cursor_on_cell (tree_view, path, focus_column,
13310                                     NULL, start_editing);
13311 }
13312
13313 /**
13314  * gtk_tree_view_set_cursor_on_cell:
13315  * @tree_view: A #GtkTreeView
13316  * @path: A #GtkTreePath
13317  * @focus_column: (allow-none): A #GtkTreeViewColumn, or %NULL
13318  * @focus_cell: (allow-none): A #GtkCellRenderer, or %NULL
13319  * @start_editing: %TRUE if the specified cell should start being edited.
13320  *
13321  * Sets the current keyboard focus to be at @path, and selects it.  This is
13322  * useful when you want to focus the user's attention on a particular row.  If
13323  * @focus_column is not %NULL, then focus is given to the column specified by
13324  * it. If @focus_column and @focus_cell are not %NULL, and @focus_column
13325  * contains 2 or more editable or activatable cells, then focus is given to
13326  * the cell specified by @focus_cell. Additionally, if @focus_column is
13327  * specified, and @start_editing is %TRUE, then editing should be started in
13328  * the specified cell.  This function is often followed by
13329  * @gtk_widget_grab_focus (@tree_view) in order to give keyboard focus to the
13330  * widget.  Please note that editing can only happen when the widget is
13331  * realized.
13332  *
13333  * If @path is invalid for @model, the current cursor (if any) will be unset
13334  * and the function will return without failing.
13335  *
13336  * Since: 2.2
13337  **/
13338 void
13339 gtk_tree_view_set_cursor_on_cell (GtkTreeView       *tree_view,
13340                                   GtkTreePath       *path,
13341                                   GtkTreeViewColumn *focus_column,
13342                                   GtkCellRenderer   *focus_cell,
13343                                   gboolean           start_editing)
13344 {
13345   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13346   g_return_if_fail (path != NULL);
13347   g_return_if_fail (focus_column == NULL || GTK_IS_TREE_VIEW_COLUMN (focus_column));
13348
13349   if (!tree_view->priv->model)
13350     return;
13351
13352   if (focus_cell)
13353     {
13354       g_return_if_fail (focus_column);
13355       g_return_if_fail (GTK_IS_CELL_RENDERER (focus_cell));
13356     }
13357
13358   /* cancel the current editing, if it exists */
13359   if (tree_view->priv->edited_column &&
13360       gtk_cell_area_get_edit_widget
13361       (gtk_cell_layout_get_area (GTK_CELL_LAYOUT (tree_view->priv->edited_column))))
13362     gtk_tree_view_stop_editing (tree_view, TRUE);
13363
13364   gtk_tree_view_real_set_cursor (tree_view, path, TRUE, TRUE);
13365
13366   if (focus_column &&
13367       gtk_tree_view_column_get_visible (focus_column))
13368     {
13369       GList *list;
13370       gboolean column_in_tree = FALSE;
13371
13372       for (list = tree_view->priv->columns; list; list = list->next)
13373         if (list->data == focus_column)
13374           {
13375             column_in_tree = TRUE;
13376             break;
13377           }
13378       g_return_if_fail (column_in_tree);
13379       tree_view->priv->focus_column = focus_column;
13380       if (focus_cell)
13381         gtk_tree_view_column_focus_cell (focus_column, focus_cell);
13382       if (start_editing)
13383         gtk_tree_view_start_editing (tree_view, path, TRUE);
13384     }
13385 }
13386
13387 /**
13388  * gtk_tree_view_get_bin_window:
13389  * @tree_view: A #GtkTreeView
13390  *
13391  * Returns the window that @tree_view renders to.
13392  * This is used primarily to compare to <literal>event->window</literal>
13393  * to confirm that the event on @tree_view is on the right window.
13394  *
13395  * Return value: (transfer none): A #GdkWindow, or %NULL when @tree_view
13396  *     hasn't been realized yet
13397  **/
13398 GdkWindow *
13399 gtk_tree_view_get_bin_window (GtkTreeView *tree_view)
13400 {
13401   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
13402
13403   return tree_view->priv->bin_window;
13404 }
13405
13406 /**
13407  * gtk_tree_view_get_path_at_pos:
13408  * @tree_view: A #GtkTreeView.
13409  * @x: The x position to be identified (relative to bin_window).
13410  * @y: The y position to be identified (relative to bin_window).
13411  * @path: (out) (allow-none): A pointer to a #GtkTreePath pointer to be filled in, or %NULL
13412  * @column: (out) (allow-none): A pointer to a #GtkTreeViewColumn pointer to be filled in, or %NULL
13413  * @cell_x: (out) (allow-none): A pointer where the X coordinate relative to the cell can be placed, or %NULL
13414  * @cell_y: (out) (allow-none): A pointer where the Y coordinate relative to the cell can be placed, or %NULL
13415  *
13416  * Finds the path at the point (@x, @y), relative to bin_window coordinates
13417  * (please see gtk_tree_view_get_bin_window()).
13418  * That is, @x and @y are relative to an events coordinates. @x and @y must
13419  * come from an event on the @tree_view only where <literal>event->window ==
13420  * gtk_tree_view_get_bin_window (<!-- -->)</literal>. It is primarily for
13421  * things like popup menus. If @path is non-%NULL, then it will be filled
13422  * with the #GtkTreePath at that point.  This path should be freed with
13423  * gtk_tree_path_free().  If @column is non-%NULL, then it will be filled
13424  * with the column at that point.  @cell_x and @cell_y return the coordinates
13425  * relative to the cell background (i.e. the @background_area passed to
13426  * gtk_cell_renderer_render()).  This function is only meaningful if
13427  * @tree_view is realized.  Therefore this function will always return %FALSE
13428  * if @tree_view is not realized or does not have a model.
13429  *
13430  * For converting widget coordinates (eg. the ones you get from
13431  * GtkWidget::query-tooltip), please see
13432  * gtk_tree_view_convert_widget_to_bin_window_coords().
13433  *
13434  * Return value: %TRUE if a row exists at that coordinate.
13435  **/
13436 gboolean
13437 gtk_tree_view_get_path_at_pos (GtkTreeView        *tree_view,
13438                                gint                x,
13439                                gint                y,
13440                                GtkTreePath       **path,
13441                                GtkTreeViewColumn **column,
13442                                gint               *cell_x,
13443                                gint               *cell_y)
13444 {
13445   GtkRBTree *tree;
13446   GtkRBNode *node;
13447   gint y_offset;
13448
13449   g_return_val_if_fail (tree_view != NULL, FALSE);
13450
13451   if (path)
13452     *path = NULL;
13453   if (column)
13454     *column = NULL;
13455
13456   if (tree_view->priv->bin_window == NULL)
13457     return FALSE;
13458
13459   if (tree_view->priv->tree == NULL)
13460     return FALSE;
13461
13462   if (x > tree_view->priv->hadjustment->upper)
13463     return FALSE;
13464
13465   if (x < 0 || y < 0)
13466     return FALSE;
13467
13468   if (column || cell_x)
13469     {
13470       GtkTreeViewColumn *tmp_column;
13471       GtkTreeViewColumn *last_column = NULL;
13472       GList *list;
13473       gint remaining_x = x;
13474       gboolean found = FALSE;
13475       gboolean rtl;
13476       gint width;
13477
13478       rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
13479       for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
13480            list;
13481            list = (rtl ? list->prev : list->next))
13482         {
13483           tmp_column = list->data;
13484
13485           if (gtk_tree_view_column_get_visible (tmp_column) == FALSE)
13486             continue;
13487
13488           last_column = tmp_column;
13489           width = gtk_tree_view_column_get_width (tmp_column);
13490           if (remaining_x <= width)
13491             {
13492               found = TRUE;
13493
13494               if (column)
13495                 *column = tmp_column;
13496
13497               if (cell_x)
13498                 *cell_x = remaining_x;
13499
13500               break;
13501             }
13502           remaining_x -= width;
13503         }
13504
13505       /* If found is FALSE and there is a last_column, then it the remainder
13506        * space is in that area
13507        */
13508       if (!found)
13509         {
13510           if (last_column)
13511             {
13512               if (column)
13513                 *column = last_column;
13514
13515               if (cell_x)
13516                 *cell_x = gtk_tree_view_column_get_width (last_column) + remaining_x;
13517             }
13518           else
13519             {
13520               return FALSE;
13521             }
13522         }
13523     }
13524
13525   y_offset = _gtk_rbtree_find_offset (tree_view->priv->tree,
13526                                       TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, y),
13527                                       &tree, &node);
13528
13529   if (tree == NULL)
13530     return FALSE;
13531
13532   if (cell_y)
13533     *cell_y = y_offset;
13534
13535   if (path)
13536     *path = _gtk_tree_view_find_path (tree_view, tree, node);
13537
13538   return TRUE;
13539 }
13540
13541
13542 static inline gint
13543 gtk_tree_view_get_cell_area_height (GtkTreeView *tree_view,
13544                                     GtkRBNode   *node,
13545                                     gint         vertical_separator)
13546 {
13547   int height;
13548
13549   /* The "cell" areas are the cell_area passed in to gtk_cell_renderer_render(),
13550    * i.e. just the cells, no spacing.
13551    *
13552    * The cell area height is at least expander_size - vertical_separator.
13553    * For regular nodes, the height is then at least expander_size. We should
13554    * be able to enforce the expander_size minimum here, because this
13555    * function will not be called for irregular (e.g. separator) rows.
13556    */
13557   height = gtk_tree_view_get_row_height (tree_view, node);
13558   if (height < tree_view->priv->expander_size)
13559     height = tree_view->priv->expander_size;
13560
13561   return height - vertical_separator;
13562 }
13563
13564 static inline gint
13565 gtk_tree_view_get_cell_area_y_offset (GtkTreeView *tree_view,
13566                                       GtkRBTree   *tree,
13567                                       GtkRBNode   *node,
13568                                       gint         vertical_separator)
13569 {
13570   int offset;
13571
13572   offset = gtk_tree_view_get_row_y_offset (tree_view, tree, node);
13573   offset += vertical_separator / 2;
13574
13575   return offset;
13576 }
13577
13578 /**
13579  * gtk_tree_view_get_cell_area:
13580  * @tree_view: a #GtkTreeView
13581  * @path: (allow-none): a #GtkTreePath for the row, or %NULL to get only horizontal coordinates
13582  * @column: (allow-none): a #GtkTreeViewColumn for the column, or %NULL to get only vertical coordinates
13583  * @rect: rectangle to fill with cell rect
13584  *
13585  * Fills the bounding rectangle in bin_window coordinates for the cell at the
13586  * row specified by @path and the column specified by @column.  If @path is
13587  * %NULL, or points to a path not currently displayed, the @y and @height fields
13588  * of the rectangle will be filled with 0. If @column is %NULL, the @x and @width
13589  * fields will be filled with 0.  The sum of all cell rects does not cover the
13590  * entire tree; there are extra pixels in between rows, for example. The
13591  * returned rectangle is equivalent to the @cell_area passed to
13592  * gtk_cell_renderer_render().  This function is only valid if @tree_view is
13593  * realized.
13594  **/
13595 void
13596 gtk_tree_view_get_cell_area (GtkTreeView        *tree_view,
13597                              GtkTreePath        *path,
13598                              GtkTreeViewColumn  *column,
13599                              GdkRectangle       *rect)
13600 {
13601   GtkAllocation allocation;
13602   GtkRBTree *tree = NULL;
13603   GtkRBNode *node = NULL;
13604   gint vertical_separator;
13605   gint horizontal_separator;
13606
13607   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13608   g_return_if_fail (column == NULL || GTK_IS_TREE_VIEW_COLUMN (column));
13609   g_return_if_fail (rect != NULL);
13610   g_return_if_fail (!column || gtk_tree_view_column_get_tree_view (column) == (GtkWidget *) tree_view);
13611   g_return_if_fail (gtk_widget_get_realized (GTK_WIDGET (tree_view)));
13612
13613   gtk_widget_style_get (GTK_WIDGET (tree_view),
13614                         "vertical-separator", &vertical_separator,
13615                         "horizontal-separator", &horizontal_separator,
13616                         NULL);
13617
13618   rect->x = 0;
13619   rect->y = 0;
13620   rect->width = 0;
13621   rect->height = 0;
13622
13623   if (column)
13624     {
13625       gtk_widget_get_allocation (gtk_tree_view_column_get_button (column), &allocation);
13626       rect->x = allocation.x + horizontal_separator/2;
13627       rect->width = allocation.width - horizontal_separator;
13628     }
13629
13630   if (path)
13631     {
13632       gboolean ret = _gtk_tree_view_find_node (tree_view, path, &tree, &node);
13633
13634       /* Get vertical coords */
13635       if ((!ret && tree == NULL) || ret)
13636         return;
13637
13638       if (row_is_separator (tree_view, NULL, path))
13639         {
13640           /* There isn't really a "cell area" for separator, so we
13641            * return the y, height values for background area instead.
13642            */
13643           rect->y = gtk_tree_view_get_row_y_offset (tree_view, tree, node);
13644           rect->height = gtk_tree_view_get_row_height (tree_view, node);
13645         }
13646       else
13647         {
13648           rect->y = gtk_tree_view_get_cell_area_y_offset (tree_view, tree, node,
13649                                                           vertical_separator);
13650           rect->height = gtk_tree_view_get_cell_area_height (tree_view, node,
13651                                                              vertical_separator);
13652         }
13653
13654       if (column &&
13655           gtk_tree_view_is_expander_column (tree_view, column))
13656         {
13657           gint depth = gtk_tree_path_get_depth (path);
13658           gboolean rtl;
13659
13660           rtl = gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL;
13661
13662           if (!rtl)
13663             rect->x += (depth - 1) * tree_view->priv->level_indentation;
13664           rect->width -= (depth - 1) * tree_view->priv->level_indentation;
13665
13666           if (gtk_tree_view_draw_expanders (tree_view))
13667             {
13668               if (!rtl)
13669                 rect->x += depth * tree_view->priv->expander_size;
13670               rect->width -= depth * tree_view->priv->expander_size;
13671             }
13672
13673           rect->width = MAX (rect->width, 0);
13674         }
13675     }
13676 }
13677
13678 static inline gint
13679 gtk_tree_view_get_row_height (GtkTreeView *tree_view,
13680                               GtkRBNode   *node)
13681 {
13682   int height;
13683
13684   /* The "background" areas of all rows/cells add up to cover the entire tree.
13685    * The background includes all inter-row and inter-cell spacing.
13686    *
13687    * If the row pointed at by node does not have a height set, we default
13688    * to expander_size, which is the minimum height for regular nodes.
13689    * Non-regular nodes (e.g. separators) can have a height set smaller
13690    * than expander_size and should not be overruled here.
13691    */
13692   height = GTK_RBNODE_GET_HEIGHT (node);
13693   if (height <= 0)
13694     height = tree_view->priv->expander_size;
13695
13696   return height;
13697 }
13698
13699 static inline gint
13700 gtk_tree_view_get_row_y_offset (GtkTreeView *tree_view,
13701                                 GtkRBTree   *tree,
13702                                 GtkRBNode   *node)
13703 {
13704   int offset;
13705
13706   offset = _gtk_rbtree_node_find_offset (tree, node);
13707
13708   return RBTREE_Y_TO_TREE_WINDOW_Y (tree_view, offset);
13709 }
13710
13711 /**
13712  * gtk_tree_view_get_background_area:
13713  * @tree_view: a #GtkTreeView
13714  * @path: (allow-none): a #GtkTreePath for the row, or %NULL to get only horizontal coordinates
13715  * @column: (allow-none): a #GtkTreeViewColumn for the column, or %NULL to get only vertical coordiantes
13716  * @rect: rectangle to fill with cell background rect
13717  *
13718  * Fills the bounding rectangle in bin_window coordinates for the cell at the
13719  * row specified by @path and the column specified by @column.  If @path is
13720  * %NULL, or points to a node not found in the tree, the @y and @height fields of
13721  * the rectangle will be filled with 0. If @column is %NULL, the @x and @width
13722  * fields will be filled with 0.  The returned rectangle is equivalent to the
13723  * @background_area passed to gtk_cell_renderer_render().  These background
13724  * areas tile to cover the entire bin window.  Contrast with the @cell_area,
13725  * returned by gtk_tree_view_get_cell_area(), which returns only the cell
13726  * itself, excluding surrounding borders and the tree expander area.
13727  *
13728  **/
13729 void
13730 gtk_tree_view_get_background_area (GtkTreeView        *tree_view,
13731                                    GtkTreePath        *path,
13732                                    GtkTreeViewColumn  *column,
13733                                    GdkRectangle       *rect)
13734 {
13735   GtkRBTree *tree = NULL;
13736   GtkRBNode *node = NULL;
13737
13738   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13739   g_return_if_fail (column == NULL || GTK_IS_TREE_VIEW_COLUMN (column));
13740   g_return_if_fail (rect != NULL);
13741
13742   rect->x = 0;
13743   rect->y = 0;
13744   rect->width = 0;
13745   rect->height = 0;
13746
13747   if (path)
13748     {
13749       /* Get vertical coords */
13750
13751       if (!_gtk_tree_view_find_node (tree_view, path, &tree, &node) &&
13752           tree == NULL)
13753         return;
13754
13755       rect->y = gtk_tree_view_get_row_y_offset (tree_view, tree, node);
13756       rect->height = gtk_tree_view_get_row_height (tree_view, node);
13757     }
13758
13759   if (column)
13760     {
13761       gint x2 = 0;
13762
13763       gtk_tree_view_get_background_xrange (tree_view, tree, column, &rect->x, &x2);
13764       rect->width = x2 - rect->x;
13765     }
13766 }
13767
13768 /**
13769  * gtk_tree_view_get_visible_rect:
13770  * @tree_view: a #GtkTreeView
13771  * @visible_rect: rectangle to fill
13772  *
13773  * Fills @visible_rect with the currently-visible region of the
13774  * buffer, in tree coordinates. Convert to bin_window coordinates with
13775  * gtk_tree_view_convert_tree_to_bin_window_coords().
13776  * Tree coordinates start at 0,0 for row 0 of the tree, and cover the entire
13777  * scrollable area of the tree.
13778  **/
13779 void
13780 gtk_tree_view_get_visible_rect (GtkTreeView  *tree_view,
13781                                 GdkRectangle *visible_rect)
13782 {
13783   GtkAllocation allocation;
13784   GtkWidget *widget;
13785
13786   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13787
13788   widget = GTK_WIDGET (tree_view);
13789
13790   if (visible_rect)
13791     {
13792       gtk_widget_get_allocation (widget, &allocation);
13793       visible_rect->x = tree_view->priv->hadjustment->value;
13794       visible_rect->y = tree_view->priv->vadjustment->value;
13795       visible_rect->width = allocation.width;
13796       visible_rect->height = allocation.height - gtk_tree_view_get_effective_header_height (tree_view);
13797     }
13798 }
13799
13800 /**
13801  * gtk_tree_view_convert_widget_to_tree_coords:
13802  * @tree_view: a #GtkTreeView
13803  * @wx: X coordinate relative to the widget
13804  * @wy: Y coordinate relative to the widget
13805  * @tx: return location for tree X coordinate
13806  * @ty: return location for tree Y coordinate
13807  *
13808  * Converts widget coordinates to coordinates for the
13809  * tree (the full scrollable area of the tree).
13810  *
13811  * Since: 2.12
13812  **/
13813 void
13814 gtk_tree_view_convert_widget_to_tree_coords (GtkTreeView *tree_view,
13815                                              gint         wx,
13816                                              gint         wy,
13817                                              gint        *tx,
13818                                              gint        *ty)
13819 {
13820   gint x, y;
13821
13822   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13823
13824   gtk_tree_view_convert_widget_to_bin_window_coords (tree_view,
13825                                                      wx, wy,
13826                                                      &x, &y);
13827   gtk_tree_view_convert_bin_window_to_tree_coords (tree_view,
13828                                                    x, y,
13829                                                    tx, ty);
13830 }
13831
13832 /**
13833  * gtk_tree_view_convert_tree_to_widget_coords:
13834  * @tree_view: a #GtkTreeView
13835  * @tx: X coordinate relative to the tree
13836  * @ty: Y coordinate relative to the tree
13837  * @wx: return location for widget X coordinate
13838  * @wy: return location for widget Y coordinate
13839  *
13840  * Converts tree coordinates (coordinates in full scrollable area of the tree)
13841  * to widget coordinates.
13842  *
13843  * Since: 2.12
13844  **/
13845 void
13846 gtk_tree_view_convert_tree_to_widget_coords (GtkTreeView *tree_view,
13847                                              gint         tx,
13848                                              gint         ty,
13849                                              gint        *wx,
13850                                              gint        *wy)
13851 {
13852   gint x, y;
13853
13854   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13855
13856   gtk_tree_view_convert_tree_to_bin_window_coords (tree_view,
13857                                                    tx, ty,
13858                                                    &x, &y);
13859   gtk_tree_view_convert_bin_window_to_widget_coords (tree_view,
13860                                                      x, y,
13861                                                      wx, wy);
13862 }
13863
13864 /**
13865  * gtk_tree_view_convert_widget_to_bin_window_coords:
13866  * @tree_view: a #GtkTreeView
13867  * @wx: X coordinate relative to the widget
13868  * @wy: Y coordinate relative to the widget
13869  * @bx: return location for bin_window X coordinate
13870  * @by: return location for bin_window Y coordinate
13871  *
13872  * Converts widget coordinates to coordinates for the bin_window
13873  * (see gtk_tree_view_get_bin_window()).
13874  *
13875  * Since: 2.12
13876  **/
13877 void
13878 gtk_tree_view_convert_widget_to_bin_window_coords (GtkTreeView *tree_view,
13879                                                    gint         wx,
13880                                                    gint         wy,
13881                                                    gint        *bx,
13882                                                    gint        *by)
13883 {
13884   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13885
13886   if (bx)
13887     *bx = wx + tree_view->priv->hadjustment->value;
13888   if (by)
13889     *by = wy - gtk_tree_view_get_effective_header_height (tree_view);
13890 }
13891
13892 /**
13893  * gtk_tree_view_convert_bin_window_to_widget_coords:
13894  * @tree_view: a #GtkTreeView
13895  * @bx: bin_window X coordinate
13896  * @by: bin_window Y coordinate
13897  * @wx: return location for widget X coordinate
13898  * @wy: return location for widget Y coordinate
13899  *
13900  * Converts bin_window coordinates (see gtk_tree_view_get_bin_window())
13901  * to widget relative coordinates.
13902  *
13903  * Since: 2.12
13904  **/
13905 void
13906 gtk_tree_view_convert_bin_window_to_widget_coords (GtkTreeView *tree_view,
13907                                                    gint         bx,
13908                                                    gint         by,
13909                                                    gint        *wx,
13910                                                    gint        *wy)
13911 {
13912   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13913
13914   if (wx)
13915     *wx = bx - tree_view->priv->hadjustment->value;
13916   if (wy)
13917     *wy = by + gtk_tree_view_get_effective_header_height (tree_view);
13918 }
13919
13920 /**
13921  * gtk_tree_view_convert_tree_to_bin_window_coords:
13922  * @tree_view: a #GtkTreeView
13923  * @tx: tree X coordinate
13924  * @ty: tree Y coordinate
13925  * @bx: return location for X coordinate relative to bin_window
13926  * @by: return location for Y coordinate relative to bin_window
13927  *
13928  * Converts tree coordinates (coordinates in full scrollable area of the tree)
13929  * to bin_window coordinates.
13930  *
13931  * Since: 2.12
13932  **/
13933 void
13934 gtk_tree_view_convert_tree_to_bin_window_coords (GtkTreeView *tree_view,
13935                                                  gint         tx,
13936                                                  gint         ty,
13937                                                  gint        *bx,
13938                                                  gint        *by)
13939 {
13940   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13941
13942   if (bx)
13943     *bx = tx;
13944   if (by)
13945     *by = ty - tree_view->priv->dy;
13946 }
13947
13948 /**
13949  * gtk_tree_view_convert_bin_window_to_tree_coords:
13950  * @tree_view: a #GtkTreeView
13951  * @bx: X coordinate relative to bin_window
13952  * @by: Y coordinate relative to bin_window
13953  * @tx: return location for tree X coordinate
13954  * @ty: return location for tree Y coordinate
13955  *
13956  * Converts bin_window coordinates to coordinates for the
13957  * tree (the full scrollable area of the tree).
13958  *
13959  * Since: 2.12
13960  **/
13961 void
13962 gtk_tree_view_convert_bin_window_to_tree_coords (GtkTreeView *tree_view,
13963                                                  gint         bx,
13964                                                  gint         by,
13965                                                  gint        *tx,
13966                                                  gint        *ty)
13967 {
13968   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13969
13970   if (tx)
13971     *tx = bx;
13972   if (ty)
13973     *ty = by + tree_view->priv->dy;
13974 }
13975
13976
13977
13978 /**
13979  * gtk_tree_view_get_visible_range:
13980  * @tree_view: A #GtkTreeView
13981  * @start_path: (allow-none): Return location for start of region, or %NULL.
13982  * @end_path: (allow-none): Return location for end of region, or %NULL.
13983  *
13984  * Sets @start_path and @end_path to be the first and last visible path.
13985  * Note that there may be invisible paths in between.
13986  *
13987  * The paths should be freed with gtk_tree_path_free() after use.
13988  *
13989  * Returns: %TRUE, if valid paths were placed in @start_path and @end_path.
13990  *
13991  * Since: 2.8
13992  **/
13993 gboolean
13994 gtk_tree_view_get_visible_range (GtkTreeView  *tree_view,
13995                                  GtkTreePath **start_path,
13996                                  GtkTreePath **end_path)
13997 {
13998   GtkRBTree *tree;
13999   GtkRBNode *node;
14000   gboolean retval;
14001
14002   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
14003
14004   if (!tree_view->priv->tree)
14005     return FALSE;
14006
14007   retval = TRUE;
14008
14009   if (start_path)
14010     {
14011       _gtk_rbtree_find_offset (tree_view->priv->tree,
14012                                TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, 0),
14013                                &tree, &node);
14014       if (node)
14015         *start_path = _gtk_tree_view_find_path (tree_view, tree, node);
14016       else
14017         retval = FALSE;
14018     }
14019
14020   if (end_path)
14021     {
14022       gint y;
14023
14024       if (tree_view->priv->height < tree_view->priv->vadjustment->page_size)
14025         y = tree_view->priv->height - 1;
14026       else
14027         y = TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, tree_view->priv->vadjustment->page_size) - 1;
14028
14029       _gtk_rbtree_find_offset (tree_view->priv->tree, y, &tree, &node);
14030       if (node)
14031         *end_path = _gtk_tree_view_find_path (tree_view, tree, node);
14032       else
14033         retval = FALSE;
14034     }
14035
14036   return retval;
14037 }
14038
14039 static void
14040 unset_reorderable (GtkTreeView *tree_view)
14041 {
14042   if (tree_view->priv->reorderable)
14043     {
14044       tree_view->priv->reorderable = FALSE;
14045       g_object_notify (G_OBJECT (tree_view), "reorderable");
14046     }
14047 }
14048
14049 /**
14050  * gtk_tree_view_enable_model_drag_source:
14051  * @tree_view: a #GtkTreeView
14052  * @start_button_mask: Mask of allowed buttons to start drag
14053  * @targets: (array): the table of targets that the drag will support
14054  * @n_targets: the number of items in @targets
14055  * @actions: the bitmask of possible actions for a drag from this
14056  *    widget
14057  *
14058  * Turns @tree_view into a drag source for automatic DND. Calling this
14059  * method sets #GtkTreeView:reorderable to %FALSE.
14060  **/
14061 void
14062 gtk_tree_view_enable_model_drag_source (GtkTreeView              *tree_view,
14063                                         GdkModifierType           start_button_mask,
14064                                         const GtkTargetEntry     *targets,
14065                                         gint                      n_targets,
14066                                         GdkDragAction             actions)
14067 {
14068   TreeViewDragInfo *di;
14069
14070   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14071
14072   gtk_drag_source_set (GTK_WIDGET (tree_view),
14073                        0,
14074                        targets,
14075                        n_targets,
14076                        actions);
14077
14078   di = ensure_info (tree_view);
14079
14080   di->start_button_mask = start_button_mask;
14081   di->source_actions = actions;
14082   di->source_set = TRUE;
14083
14084   unset_reorderable (tree_view);
14085 }
14086
14087 /**
14088  * gtk_tree_view_enable_model_drag_dest:
14089  * @tree_view: a #GtkTreeView
14090  * @targets: (array): the table of targets that the drag will support
14091  * @n_targets: the number of items in @targets
14092  * @actions: the bitmask of possible actions for a drag from this
14093  *    widget
14094  *
14095  * Turns @tree_view into a drop destination for automatic DND. Calling
14096  * this method sets #GtkTreeView:reorderable to %FALSE.
14097  **/
14098 void
14099 gtk_tree_view_enable_model_drag_dest (GtkTreeView              *tree_view,
14100                                       const GtkTargetEntry     *targets,
14101                                       gint                      n_targets,
14102                                       GdkDragAction             actions)
14103 {
14104   TreeViewDragInfo *di;
14105
14106   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14107
14108   gtk_drag_dest_set (GTK_WIDGET (tree_view),
14109                      0,
14110                      targets,
14111                      n_targets,
14112                      actions);
14113
14114   di = ensure_info (tree_view);
14115   di->dest_set = TRUE;
14116
14117   unset_reorderable (tree_view);
14118 }
14119
14120 /**
14121  * gtk_tree_view_unset_rows_drag_source:
14122  * @tree_view: a #GtkTreeView
14123  *
14124  * Undoes the effect of
14125  * gtk_tree_view_enable_model_drag_source(). Calling this method sets
14126  * #GtkTreeView:reorderable to %FALSE.
14127  **/
14128 void
14129 gtk_tree_view_unset_rows_drag_source (GtkTreeView *tree_view)
14130 {
14131   TreeViewDragInfo *di;
14132
14133   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14134
14135   di = get_info (tree_view);
14136
14137   if (di)
14138     {
14139       if (di->source_set)
14140         {
14141           gtk_drag_source_unset (GTK_WIDGET (tree_view));
14142           di->source_set = FALSE;
14143         }
14144
14145       if (!di->dest_set && !di->source_set)
14146         remove_info (tree_view);
14147     }
14148
14149   unset_reorderable (tree_view);
14150 }
14151
14152 /**
14153  * gtk_tree_view_unset_rows_drag_dest:
14154  * @tree_view: a #GtkTreeView
14155  *
14156  * Undoes the effect of
14157  * gtk_tree_view_enable_model_drag_dest(). Calling this method sets
14158  * #GtkTreeView:reorderable to %FALSE.
14159  **/
14160 void
14161 gtk_tree_view_unset_rows_drag_dest (GtkTreeView *tree_view)
14162 {
14163   TreeViewDragInfo *di;
14164
14165   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14166
14167   di = get_info (tree_view);
14168
14169   if (di)
14170     {
14171       if (di->dest_set)
14172         {
14173           gtk_drag_dest_unset (GTK_WIDGET (tree_view));
14174           di->dest_set = FALSE;
14175         }
14176
14177       if (!di->dest_set && !di->source_set)
14178         remove_info (tree_view);
14179     }
14180
14181   unset_reorderable (tree_view);
14182 }
14183
14184 /**
14185  * gtk_tree_view_set_drag_dest_row:
14186  * @tree_view: a #GtkTreeView
14187  * @path: (allow-none): The path of the row to highlight, or %NULL.
14188  * @pos: Specifies whether to drop before, after or into the row
14189  *
14190  * Sets the row that is highlighted for feedback.
14191  **/
14192 void
14193 gtk_tree_view_set_drag_dest_row (GtkTreeView            *tree_view,
14194                                  GtkTreePath            *path,
14195                                  GtkTreeViewDropPosition pos)
14196 {
14197   GtkTreePath *current_dest;
14198
14199   /* Note; this function is exported to allow a custom DND
14200    * implementation, so it can't touch TreeViewDragInfo
14201    */
14202
14203   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14204
14205   current_dest = NULL;
14206
14207   if (tree_view->priv->drag_dest_row)
14208     {
14209       current_dest = gtk_tree_row_reference_get_path (tree_view->priv->drag_dest_row);
14210       gtk_tree_row_reference_free (tree_view->priv->drag_dest_row);
14211     }
14212
14213   /* special case a drop on an empty model */
14214   tree_view->priv->empty_view_drop = 0;
14215
14216   if (pos == GTK_TREE_VIEW_DROP_BEFORE && path
14217       && gtk_tree_path_get_depth (path) == 1
14218       && gtk_tree_path_get_indices (path)[0] == 0)
14219     {
14220       gint n_children;
14221
14222       n_children = gtk_tree_model_iter_n_children (tree_view->priv->model,
14223                                                    NULL);
14224
14225       if (!n_children)
14226         tree_view->priv->empty_view_drop = 1;
14227     }
14228
14229   tree_view->priv->drag_dest_pos = pos;
14230
14231   if (path)
14232     {
14233       tree_view->priv->drag_dest_row =
14234         gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view), tree_view->priv->model, path);
14235       gtk_tree_view_queue_draw_path (tree_view, path, NULL);
14236     }
14237   else
14238     tree_view->priv->drag_dest_row = NULL;
14239
14240   if (current_dest)
14241     {
14242       GtkRBTree *tree, *new_tree;
14243       GtkRBNode *node, *new_node;
14244
14245       _gtk_tree_view_find_node (tree_view, current_dest, &tree, &node);
14246       _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
14247
14248       if (tree && node)
14249         {
14250           _gtk_rbtree_next_full (tree, node, &new_tree, &new_node);
14251           if (new_tree && new_node)
14252             _gtk_tree_view_queue_draw_node (tree_view, new_tree, new_node, NULL);
14253
14254           _gtk_rbtree_prev_full (tree, node, &new_tree, &new_node);
14255           if (new_tree && new_node)
14256             _gtk_tree_view_queue_draw_node (tree_view, new_tree, new_node, NULL);
14257         }
14258       gtk_tree_path_free (current_dest);
14259     }
14260 }
14261
14262 /**
14263  * gtk_tree_view_get_drag_dest_row:
14264  * @tree_view: a #GtkTreeView
14265  * @path: (out) (allow-none): Return location for the path of the highlighted row, or %NULL.
14266  * @pos: (out) (allow-none): Return location for the drop position, or %NULL
14267  *
14268  * Gets information about the row that is highlighted for feedback.
14269  **/
14270 void
14271 gtk_tree_view_get_drag_dest_row (GtkTreeView              *tree_view,
14272                                  GtkTreePath             **path,
14273                                  GtkTreeViewDropPosition  *pos)
14274 {
14275   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14276
14277   if (path)
14278     {
14279       if (tree_view->priv->drag_dest_row)
14280         *path = gtk_tree_row_reference_get_path (tree_view->priv->drag_dest_row);
14281       else
14282         {
14283           if (tree_view->priv->empty_view_drop)
14284             *path = gtk_tree_path_new_from_indices (0, -1);
14285           else
14286             *path = NULL;
14287         }
14288     }
14289
14290   if (pos)
14291     *pos = tree_view->priv->drag_dest_pos;
14292 }
14293
14294 /**
14295  * gtk_tree_view_get_dest_row_at_pos:
14296  * @tree_view: a #GtkTreeView
14297  * @drag_x: the position to determine the destination row for
14298  * @drag_y: the position to determine the destination row for
14299  * @path: (out) (allow-none): Return location for the path of the highlighted row, or %NULL.
14300  * @pos: (out) (allow-none): Return location for the drop position, or %NULL
14301  *
14302  * Determines the destination row for a given position.  @drag_x and
14303  * @drag_y are expected to be in widget coordinates.  This function is only
14304  * meaningful if @tree_view is realized.  Therefore this function will always
14305  * return %FALSE if @tree_view is not realized or does not have a model.
14306  *
14307  * Return value: whether there is a row at the given position, %TRUE if this
14308  * is indeed the case.
14309  **/
14310 gboolean
14311 gtk_tree_view_get_dest_row_at_pos (GtkTreeView             *tree_view,
14312                                    gint                     drag_x,
14313                                    gint                     drag_y,
14314                                    GtkTreePath            **path,
14315                                    GtkTreeViewDropPosition *pos)
14316 {
14317   gint cell_y;
14318   gint bin_x, bin_y;
14319   gdouble offset_into_row;
14320   gdouble third;
14321   GdkRectangle cell;
14322   GtkTreeViewColumn *column = NULL;
14323   GtkTreePath *tmp_path = NULL;
14324
14325   /* Note; this function is exported to allow a custom DND
14326    * implementation, so it can't touch TreeViewDragInfo
14327    */
14328
14329   g_return_val_if_fail (tree_view != NULL, FALSE);
14330   g_return_val_if_fail (drag_x >= 0, FALSE);
14331   g_return_val_if_fail (drag_y >= 0, FALSE);
14332
14333   if (path)
14334     *path = NULL;
14335
14336   if (tree_view->priv->bin_window == NULL)
14337     return FALSE;
14338
14339   if (tree_view->priv->tree == NULL)
14340     return FALSE;
14341
14342   /* If in the top third of a row, we drop before that row; if
14343    * in the bottom third, drop after that row; if in the middle,
14344    * and the row has children, drop into the row.
14345    */
14346   gtk_tree_view_convert_widget_to_bin_window_coords (tree_view, drag_x, drag_y,
14347                                                      &bin_x, &bin_y);
14348
14349   if (!gtk_tree_view_get_path_at_pos (tree_view,
14350                                       bin_x,
14351                                       bin_y,
14352                                       &tmp_path,
14353                                       &column,
14354                                       NULL,
14355                                       &cell_y))
14356     return FALSE;
14357
14358   gtk_tree_view_get_background_area (tree_view, tmp_path, column,
14359                                      &cell);
14360
14361   offset_into_row = cell_y;
14362
14363   if (path)
14364     *path = tmp_path;
14365   else
14366     gtk_tree_path_free (tmp_path);
14367
14368   tmp_path = NULL;
14369
14370   third = cell.height / 3.0;
14371
14372   if (pos)
14373     {
14374       if (offset_into_row < third)
14375         {
14376           *pos = GTK_TREE_VIEW_DROP_BEFORE;
14377         }
14378       else if (offset_into_row < (cell.height / 2.0))
14379         {
14380           *pos = GTK_TREE_VIEW_DROP_INTO_OR_BEFORE;
14381         }
14382       else if (offset_into_row < third * 2.0)
14383         {
14384           *pos = GTK_TREE_VIEW_DROP_INTO_OR_AFTER;
14385         }
14386       else
14387         {
14388           *pos = GTK_TREE_VIEW_DROP_AFTER;
14389         }
14390     }
14391
14392   return TRUE;
14393 }
14394
14395
14396
14397 /* KEEP IN SYNC WITH GTK_TREE_VIEW_BIN_EXPOSE */
14398 /**
14399  * gtk_tree_view_create_row_drag_icon:
14400  * @tree_view: a #GtkTreeView
14401  * @path: a #GtkTreePath in @tree_view
14402  *
14403  * Creates a #cairo_surface_t representation of the row at @path.
14404  * This image is used for a drag icon.
14405  *
14406  * Return value: (transfer full): a newly-allocated surface of the drag icon.
14407  **/
14408 cairo_surface_t *
14409 gtk_tree_view_create_row_drag_icon (GtkTreeView  *tree_view,
14410                                     GtkTreePath  *path)
14411 {
14412   GtkTreeIter   iter;
14413   GtkRBTree    *tree;
14414   GtkRBNode    *node;
14415   GtkStyle *style;
14416   gint cell_offset;
14417   GList *list;
14418   GdkRectangle background_area;
14419   GtkWidget *widget;
14420   gint depth;
14421   /* start drawing inside the black outline */
14422   gint x = 1, y = 1;
14423   cairo_surface_t *surface;
14424   gint bin_window_width;
14425   gboolean is_separator = FALSE;
14426   gboolean rtl;
14427   cairo_t *cr;
14428
14429   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
14430   g_return_val_if_fail (path != NULL, NULL);
14431
14432   widget = GTK_WIDGET (tree_view);
14433
14434   if (!gtk_widget_get_realized (widget))
14435     return NULL;
14436
14437   depth = gtk_tree_path_get_depth (path);
14438
14439   _gtk_tree_view_find_node (tree_view,
14440                             path,
14441                             &tree,
14442                             &node);
14443
14444   if (tree == NULL)
14445     return NULL;
14446
14447   if (!gtk_tree_model_get_iter (tree_view->priv->model,
14448                                 &iter,
14449                                 path))
14450     return NULL;
14451
14452   style = gtk_widget_get_style (widget);
14453
14454   is_separator = row_is_separator (tree_view, &iter, NULL);
14455
14456   cell_offset = x;
14457
14458   background_area.y = y;
14459   background_area.height = gtk_tree_view_get_row_height (tree_view, node);
14460
14461   bin_window_width = gdk_window_get_width (tree_view->priv->bin_window);
14462
14463   surface = gdk_window_create_similar_surface (tree_view->priv->bin_window,
14464                                                CAIRO_CONTENT_COLOR,
14465                                                bin_window_width + 2,
14466                                                background_area.height + 2);
14467
14468   cr = cairo_create (surface);
14469   gdk_cairo_set_source_color (cr, &style->base [gtk_widget_get_state (widget)]);
14470   cairo_paint (cr);
14471
14472   rtl = gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL;
14473
14474   for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
14475       list;
14476       list = (rtl ? list->prev : list->next))
14477     {
14478       GtkTreeViewColumn *column = list->data;
14479       GdkRectangle cell_area;
14480       gint vertical_separator;
14481
14482       if (!gtk_tree_view_column_get_visible (column))
14483         continue;
14484
14485       gtk_tree_view_column_cell_set_cell_data (column, tree_view->priv->model, &iter,
14486                                                GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT),
14487                                                node->children?TRUE:FALSE);
14488
14489       background_area.x = cell_offset;
14490       background_area.width = gtk_tree_view_column_get_width (column);
14491
14492       gtk_widget_style_get (widget,
14493                             "vertical-separator", &vertical_separator,
14494                             NULL);
14495
14496       cell_area = background_area;
14497
14498       cell_area.y += vertical_separator / 2;
14499       cell_area.height -= vertical_separator;
14500
14501       if (gtk_tree_view_is_expander_column (tree_view, column))
14502         {
14503           if (!rtl)
14504             cell_area.x += (depth - 1) * tree_view->priv->level_indentation;
14505           cell_area.width -= (depth - 1) * tree_view->priv->level_indentation;
14506
14507           if (gtk_tree_view_draw_expanders (tree_view))
14508             {
14509               if (!rtl)
14510                 cell_area.x += depth * tree_view->priv->expander_size;
14511               cell_area.width -= depth * tree_view->priv->expander_size;
14512             }
14513         }
14514
14515       if (gtk_tree_view_column_cell_is_visible (column))
14516         {
14517           if (is_separator)
14518             gtk_paint_hline (style,
14519                                    cr,
14520                                    GTK_STATE_NORMAL,
14521                                    widget,
14522                                    NULL,
14523                                    cell_area.x,
14524                                    cell_area.x + cell_area.width,
14525                                    cell_area.y + cell_area.height / 2);
14526           else
14527             _gtk_tree_view_column_cell_render (column,
14528                                                cr,
14529                                                &background_area,
14530                                                &cell_area,
14531                                                0, FALSE);
14532         }
14533       cell_offset += gtk_tree_view_column_get_width (column);
14534     }
14535
14536   cairo_set_source_rgb (cr, 0, 0, 0);
14537   cairo_rectangle (cr,
14538                    0.5, 0.5,
14539                    bin_window_width + 1,
14540                    background_area.height + 1);
14541   cairo_set_line_width (cr, 1.0);
14542   cairo_stroke (cr);
14543
14544   cairo_destroy (cr);
14545
14546   cairo_surface_set_device_offset (surface, 2, 2);
14547
14548   return surface;
14549 }
14550
14551
14552 /**
14553  * gtk_tree_view_set_destroy_count_func:
14554  * @tree_view: A #GtkTreeView
14555  * @func: (allow-none): Function to be called when a view row is destroyed, or %NULL
14556  * @data: (allow-none): User data to be passed to @func, or %NULL
14557  * @destroy: (allow-none): Destroy notifier for @data, or %NULL
14558  *
14559  * This function should almost never be used.  It is meant for private use by
14560  * ATK for determining the number of visible children that are removed when the
14561  * user collapses a row, or a row is deleted.
14562  **/
14563 void
14564 gtk_tree_view_set_destroy_count_func (GtkTreeView             *tree_view,
14565                                       GtkTreeDestroyCountFunc  func,
14566                                       gpointer                 data,
14567                                       GDestroyNotify           destroy)
14568 {
14569   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14570
14571   if (tree_view->priv->destroy_count_destroy)
14572     tree_view->priv->destroy_count_destroy (tree_view->priv->destroy_count_data);
14573
14574   tree_view->priv->destroy_count_func = func;
14575   tree_view->priv->destroy_count_data = data;
14576   tree_view->priv->destroy_count_destroy = destroy;
14577 }
14578
14579
14580 /*
14581  * Interactive search
14582  */
14583
14584 /**
14585  * gtk_tree_view_set_enable_search:
14586  * @tree_view: A #GtkTreeView
14587  * @enable_search: %TRUE, if the user can search interactively
14588  *
14589  * If @enable_search is set, then the user can type in text to search through
14590  * the tree interactively (this is sometimes called "typeahead find").
14591  *
14592  * Note that even if this is %FALSE, the user can still initiate a search
14593  * using the "start-interactive-search" key binding.
14594  */
14595 void
14596 gtk_tree_view_set_enable_search (GtkTreeView *tree_view,
14597                                  gboolean     enable_search)
14598 {
14599   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14600
14601   enable_search = !!enable_search;
14602
14603   if (tree_view->priv->enable_search != enable_search)
14604     {
14605        tree_view->priv->enable_search = enable_search;
14606        g_object_notify (G_OBJECT (tree_view), "enable-search");
14607     }
14608 }
14609
14610 /**
14611  * gtk_tree_view_get_enable_search:
14612  * @tree_view: A #GtkTreeView
14613  *
14614  * Returns whether or not the tree allows to start interactive searching
14615  * by typing in text.
14616  *
14617  * Return value: whether or not to let the user search interactively
14618  */
14619 gboolean
14620 gtk_tree_view_get_enable_search (GtkTreeView *tree_view)
14621 {
14622   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
14623
14624   return tree_view->priv->enable_search;
14625 }
14626
14627
14628 /**
14629  * gtk_tree_view_get_search_column:
14630  * @tree_view: A #GtkTreeView
14631  *
14632  * Gets the column searched on by the interactive search code.
14633  *
14634  * Return value: the column the interactive search code searches in.
14635  */
14636 gint
14637 gtk_tree_view_get_search_column (GtkTreeView *tree_view)
14638 {
14639   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
14640
14641   return (tree_view->priv->search_column);
14642 }
14643
14644 /**
14645  * gtk_tree_view_set_search_column:
14646  * @tree_view: A #GtkTreeView
14647  * @column: the column of the model to search in, or -1 to disable searching
14648  *
14649  * Sets @column as the column where the interactive search code should
14650  * search in for the current model.
14651  *
14652  * If the search column is set, users can use the "start-interactive-search"
14653  * key binding to bring up search popup. The enable-search property controls
14654  * whether simply typing text will also start an interactive search.
14655  *
14656  * Note that @column refers to a column of the current model. The search
14657  * column is reset to -1 when the model is changed.
14658  */
14659 void
14660 gtk_tree_view_set_search_column (GtkTreeView *tree_view,
14661                                  gint         column)
14662 {
14663   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14664   g_return_if_fail (column >= -1);
14665
14666   if (tree_view->priv->search_column == column)
14667     return;
14668
14669   tree_view->priv->search_column = column;
14670   g_object_notify (G_OBJECT (tree_view), "search-column");
14671 }
14672
14673 /**
14674  * gtk_tree_view_get_search_equal_func:
14675  * @tree_view: A #GtkTreeView
14676  *
14677  * Returns the compare function currently in use.
14678  *
14679  * Return value: the currently used compare function for the search code.
14680  */
14681
14682 GtkTreeViewSearchEqualFunc
14683 gtk_tree_view_get_search_equal_func (GtkTreeView *tree_view)
14684 {
14685   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
14686
14687   return tree_view->priv->search_equal_func;
14688 }
14689
14690 /**
14691  * gtk_tree_view_set_search_equal_func:
14692  * @tree_view: A #GtkTreeView
14693  * @search_equal_func: the compare function to use during the search
14694  * @search_user_data: (allow-none): user data to pass to @search_equal_func, or %NULL
14695  * @search_destroy: (allow-none): Destroy notifier for @search_user_data, or %NULL
14696  *
14697  * Sets the compare function for the interactive search capabilities; note
14698  * that somewhat like strcmp() returning 0 for equality
14699  * #GtkTreeViewSearchEqualFunc returns %FALSE on matches.
14700  **/
14701 void
14702 gtk_tree_view_set_search_equal_func (GtkTreeView                *tree_view,
14703                                      GtkTreeViewSearchEqualFunc  search_equal_func,
14704                                      gpointer                    search_user_data,
14705                                      GDestroyNotify              search_destroy)
14706 {
14707   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14708   g_return_if_fail (search_equal_func != NULL);
14709
14710   if (tree_view->priv->search_destroy)
14711     tree_view->priv->search_destroy (tree_view->priv->search_user_data);
14712
14713   tree_view->priv->search_equal_func = search_equal_func;
14714   tree_view->priv->search_user_data = search_user_data;
14715   tree_view->priv->search_destroy = search_destroy;
14716   if (tree_view->priv->search_equal_func == NULL)
14717     tree_view->priv->search_equal_func = gtk_tree_view_search_equal_func;
14718 }
14719
14720 /**
14721  * gtk_tree_view_get_search_entry:
14722  * @tree_view: A #GtkTreeView
14723  *
14724  * Returns the #GtkEntry which is currently in use as interactive search
14725  * entry for @tree_view.  In case the built-in entry is being used, %NULL
14726  * will be returned.
14727  *
14728  * Return value: (transfer none): the entry currently in use as search entry.
14729  *
14730  * Since: 2.10
14731  */
14732 GtkEntry *
14733 gtk_tree_view_get_search_entry (GtkTreeView *tree_view)
14734 {
14735   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
14736
14737   if (tree_view->priv->search_custom_entry_set)
14738     return GTK_ENTRY (tree_view->priv->search_entry);
14739
14740   return NULL;
14741 }
14742
14743 /**
14744  * gtk_tree_view_set_search_entry:
14745  * @tree_view: A #GtkTreeView
14746  * @entry: (allow-none): the entry the interactive search code of @tree_view should use or %NULL
14747  *
14748  * Sets the entry which the interactive search code will use for this
14749  * @tree_view.  This is useful when you want to provide a search entry
14750  * in our interface at all time at a fixed position.  Passing %NULL for
14751  * @entry will make the interactive search code use the built-in popup
14752  * entry again.
14753  *
14754  * Since: 2.10
14755  */
14756 void
14757 gtk_tree_view_set_search_entry (GtkTreeView *tree_view,
14758                                 GtkEntry    *entry)
14759 {
14760   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14761   g_return_if_fail (entry == NULL || GTK_IS_ENTRY (entry));
14762
14763   if (tree_view->priv->search_custom_entry_set)
14764     {
14765       if (tree_view->priv->search_entry_changed_id)
14766         {
14767           g_signal_handler_disconnect (tree_view->priv->search_entry,
14768                                        tree_view->priv->search_entry_changed_id);
14769           tree_view->priv->search_entry_changed_id = 0;
14770         }
14771       g_signal_handlers_disconnect_by_func (tree_view->priv->search_entry,
14772                                             G_CALLBACK (gtk_tree_view_search_key_press_event),
14773                                             tree_view);
14774
14775       g_object_unref (tree_view->priv->search_entry);
14776     }
14777   else if (tree_view->priv->search_window)
14778     {
14779       gtk_widget_destroy (tree_view->priv->search_window);
14780
14781       tree_view->priv->search_window = NULL;
14782     }
14783
14784   if (entry)
14785     {
14786       tree_view->priv->search_entry = g_object_ref (entry);
14787       tree_view->priv->search_custom_entry_set = TRUE;
14788
14789       if (tree_view->priv->search_entry_changed_id == 0)
14790         {
14791           tree_view->priv->search_entry_changed_id =
14792             g_signal_connect (tree_view->priv->search_entry, "changed",
14793                               G_CALLBACK (gtk_tree_view_search_init),
14794                               tree_view);
14795         }
14796
14797         g_signal_connect (tree_view->priv->search_entry, "key-press-event",
14798                           G_CALLBACK (gtk_tree_view_search_key_press_event),
14799                           tree_view);
14800
14801         gtk_tree_view_search_init (tree_view->priv->search_entry, tree_view);
14802     }
14803   else
14804     {
14805       tree_view->priv->search_entry = NULL;
14806       tree_view->priv->search_custom_entry_set = FALSE;
14807     }
14808 }
14809
14810 /**
14811  * gtk_tree_view_set_search_position_func:
14812  * @tree_view: A #GtkTreeView
14813  * @func: (allow-none): the function to use to position the search dialog, or %NULL
14814  *    to use the default search position function
14815  * @data: (allow-none): user data to pass to @func, or %NULL
14816  * @destroy: (allow-none): Destroy notifier for @data, or %NULL
14817  *
14818  * Sets the function to use when positioning the search dialog.
14819  *
14820  * Since: 2.10
14821  **/
14822 void
14823 gtk_tree_view_set_search_position_func (GtkTreeView                   *tree_view,
14824                                         GtkTreeViewSearchPositionFunc  func,
14825                                         gpointer                       user_data,
14826                                         GDestroyNotify                 destroy)
14827 {
14828   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14829
14830   if (tree_view->priv->search_position_destroy)
14831     tree_view->priv->search_position_destroy (tree_view->priv->search_position_user_data);
14832
14833   tree_view->priv->search_position_func = func;
14834   tree_view->priv->search_position_user_data = user_data;
14835   tree_view->priv->search_position_destroy = destroy;
14836   if (tree_view->priv->search_position_func == NULL)
14837     tree_view->priv->search_position_func = gtk_tree_view_search_position_func;
14838 }
14839
14840 /**
14841  * gtk_tree_view_get_search_position_func:
14842  * @tree_view: A #GtkTreeView
14843  *
14844  * Returns the positioning function currently in use.
14845  *
14846  * Return value: the currently used function for positioning the search dialog.
14847  *
14848  * Since: 2.10
14849  */
14850 GtkTreeViewSearchPositionFunc
14851 gtk_tree_view_get_search_position_func (GtkTreeView *tree_view)
14852 {
14853   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
14854
14855   return tree_view->priv->search_position_func;
14856 }
14857
14858
14859 static void
14860 gtk_tree_view_search_dialog_hide (GtkWidget   *search_dialog,
14861                                   GtkTreeView *tree_view,
14862                                   GdkDevice   *device)
14863 {
14864   if (tree_view->priv->disable_popdown)
14865     return;
14866
14867   if (tree_view->priv->search_entry_changed_id)
14868     {
14869       g_signal_handler_disconnect (tree_view->priv->search_entry,
14870                                    tree_view->priv->search_entry_changed_id);
14871       tree_view->priv->search_entry_changed_id = 0;
14872     }
14873   if (tree_view->priv->typeselect_flush_timeout)
14874     {
14875       g_source_remove (tree_view->priv->typeselect_flush_timeout);
14876       tree_view->priv->typeselect_flush_timeout = 0;
14877     }
14878
14879   if (gtk_widget_get_visible (search_dialog))
14880     {
14881       /* send focus-in event */
14882       send_focus_change (GTK_WIDGET (tree_view->priv->search_entry), device, FALSE);
14883       gtk_widget_hide (search_dialog);
14884       gtk_entry_set_text (GTK_ENTRY (tree_view->priv->search_entry), "");
14885       send_focus_change (GTK_WIDGET (tree_view), device, TRUE);
14886     }
14887 }
14888
14889 static void
14890 gtk_tree_view_search_position_func (GtkTreeView *tree_view,
14891                                     GtkWidget   *search_dialog,
14892                                     gpointer     user_data)
14893 {
14894   gint x, y;
14895   gint tree_x, tree_y;
14896   gint tree_width, tree_height;
14897   GdkWindow *tree_window = gtk_widget_get_window (GTK_WIDGET (tree_view));
14898   GdkScreen *screen = gdk_window_get_screen (tree_window);
14899   GtkRequisition requisition;
14900   gint monitor_num;
14901   GdkRectangle monitor;
14902
14903   monitor_num = gdk_screen_get_monitor_at_window (screen, tree_window);
14904   gdk_screen_get_monitor_geometry (screen, monitor_num, &monitor);
14905
14906   gtk_widget_realize (search_dialog);
14907
14908   gdk_window_get_origin (tree_window, &tree_x, &tree_y);
14909   tree_width = gdk_window_get_width (tree_window);
14910   tree_height = gdk_window_get_height (tree_window);
14911   gtk_widget_get_preferred_size (search_dialog, &requisition, NULL);
14912
14913   if (tree_x + tree_width > gdk_screen_get_width (screen))
14914     x = gdk_screen_get_width (screen) - requisition.width;
14915   else if (tree_x + tree_width - requisition.width < 0)
14916     x = 0;
14917   else
14918     x = tree_x + tree_width - requisition.width;
14919
14920   if (tree_y + tree_height + requisition.height > gdk_screen_get_height (screen))
14921     y = gdk_screen_get_height (screen) - requisition.height;
14922   else if (tree_y + tree_height < 0) /* isn't really possible ... */
14923     y = 0;
14924   else
14925     y = tree_y + tree_height;
14926
14927   gtk_window_move (GTK_WINDOW (search_dialog), x, y);
14928 }
14929
14930 static void
14931 gtk_tree_view_search_disable_popdown (GtkEntry *entry,
14932                                       GtkMenu  *menu,
14933                                       gpointer  data)
14934 {
14935   GtkTreeView *tree_view = (GtkTreeView *)data;
14936
14937   tree_view->priv->disable_popdown = 1;
14938   g_signal_connect (menu, "hide",
14939                     G_CALLBACK (gtk_tree_view_search_enable_popdown), data);
14940 }
14941
14942 /* Because we're visible but offscreen, we just set a flag in the preedit
14943  * callback.
14944  */
14945 static void
14946 gtk_tree_view_search_preedit_changed (GtkIMContext *im_context,
14947                                       GtkTreeView  *tree_view)
14948 {
14949   tree_view->priv->imcontext_changed = 1;
14950   if (tree_view->priv->typeselect_flush_timeout)
14951     {
14952       g_source_remove (tree_view->priv->typeselect_flush_timeout);
14953       tree_view->priv->typeselect_flush_timeout =
14954         gdk_threads_add_timeout (GTK_TREE_VIEW_SEARCH_DIALOG_TIMEOUT,
14955                        (GSourceFunc) gtk_tree_view_search_entry_flush_timeout,
14956                        tree_view);
14957     }
14958
14959 }
14960
14961 static void
14962 gtk_tree_view_search_activate (GtkEntry    *entry,
14963                                GtkTreeView *tree_view)
14964 {
14965   GtkTreePath *path;
14966   GtkRBNode *node;
14967   GtkRBTree *tree;
14968
14969   gtk_tree_view_search_dialog_hide (tree_view->priv->search_window,
14970                                     tree_view,
14971                                     gtk_get_current_event_device ());
14972
14973   /* If we have a row selected and it's the cursor row, we activate
14974    * the row XXX */
14975   if (gtk_tree_row_reference_valid (tree_view->priv->cursor))
14976     {
14977       path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
14978
14979       _gtk_tree_view_find_node (tree_view, path, &tree, &node);
14980
14981       if (node && GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
14982         gtk_tree_view_row_activated (tree_view, path, tree_view->priv->focus_column);
14983
14984       gtk_tree_path_free (path);
14985     }
14986 }
14987
14988 static gboolean
14989 gtk_tree_view_real_search_enable_popdown (gpointer data)
14990 {
14991   GtkTreeView *tree_view = (GtkTreeView *)data;
14992
14993   tree_view->priv->disable_popdown = 0;
14994
14995   return FALSE;
14996 }
14997
14998 static void
14999 gtk_tree_view_search_enable_popdown (GtkWidget *widget,
15000                                      gpointer   data)
15001 {
15002   gdk_threads_add_timeout_full (G_PRIORITY_HIGH, 200, gtk_tree_view_real_search_enable_popdown, g_object_ref (data), g_object_unref);
15003 }
15004
15005 static gboolean
15006 gtk_tree_view_search_delete_event (GtkWidget *widget,
15007                                    GdkEventAny *event,
15008                                    GtkTreeView *tree_view)
15009 {
15010   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
15011
15012   gtk_tree_view_search_dialog_hide (widget, tree_view, NULL);
15013
15014   return TRUE;
15015 }
15016
15017 static gboolean
15018 gtk_tree_view_search_button_press_event (GtkWidget *widget,
15019                                          GdkEventButton *event,
15020                                          GtkTreeView *tree_view)
15021 {
15022   GdkDevice *keyb_device;
15023
15024   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
15025
15026   keyb_device = gdk_device_get_associated_device (event->device);
15027   gtk_tree_view_search_dialog_hide (widget, tree_view, keyb_device);
15028
15029   if (event->window == tree_view->priv->bin_window)
15030     gtk_tree_view_button_press (GTK_WIDGET (tree_view), event);
15031
15032   return TRUE;
15033 }
15034
15035 static gboolean
15036 gtk_tree_view_search_scroll_event (GtkWidget *widget,
15037                                    GdkEventScroll *event,
15038                                    GtkTreeView *tree_view)
15039 {
15040   gboolean retval = FALSE;
15041
15042   if (event->direction == GDK_SCROLL_UP)
15043     {
15044       gtk_tree_view_search_move (widget, tree_view, TRUE);
15045       retval = TRUE;
15046     }
15047   else if (event->direction == GDK_SCROLL_DOWN)
15048     {
15049       gtk_tree_view_search_move (widget, tree_view, FALSE);
15050       retval = TRUE;
15051     }
15052
15053   /* renew the flush timeout */
15054   if (retval && tree_view->priv->typeselect_flush_timeout
15055       && !tree_view->priv->search_custom_entry_set)
15056     {
15057       g_source_remove (tree_view->priv->typeselect_flush_timeout);
15058       tree_view->priv->typeselect_flush_timeout =
15059         gdk_threads_add_timeout (GTK_TREE_VIEW_SEARCH_DIALOG_TIMEOUT,
15060                        (GSourceFunc) gtk_tree_view_search_entry_flush_timeout,
15061                        tree_view);
15062     }
15063
15064   return retval;
15065 }
15066
15067 static gboolean
15068 gtk_tree_view_search_key_press_event (GtkWidget *widget,
15069                                       GdkEventKey *event,
15070                                       GtkTreeView *tree_view)
15071 {
15072   gboolean retval = FALSE;
15073
15074   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
15075   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
15076
15077   /* close window and cancel the search */
15078   if (!tree_view->priv->search_custom_entry_set
15079       && (event->keyval == GDK_KEY_Escape ||
15080           event->keyval == GDK_KEY_Tab ||
15081             event->keyval == GDK_KEY_KP_Tab ||
15082             event->keyval == GDK_KEY_ISO_Left_Tab))
15083     {
15084       gtk_tree_view_search_dialog_hide (widget, tree_view,
15085                                         gdk_event_get_device ((GdkEvent *) event));
15086       return TRUE;
15087     }
15088
15089   /* select previous matching iter */
15090   if (event->keyval == GDK_KEY_Up || event->keyval == GDK_KEY_KP_Up)
15091     {
15092       if (!gtk_tree_view_search_move (widget, tree_view, TRUE))
15093         gtk_widget_error_bell (widget);
15094
15095       retval = TRUE;
15096     }
15097
15098   if (((event->state & (GTK_DEFAULT_ACCEL_MOD_MASK | GDK_SHIFT_MASK)) == (GTK_DEFAULT_ACCEL_MOD_MASK | GDK_SHIFT_MASK))
15099       && (event->keyval == GDK_KEY_g || event->keyval == GDK_KEY_G))
15100     {
15101       if (!gtk_tree_view_search_move (widget, tree_view, TRUE))
15102         gtk_widget_error_bell (widget);
15103
15104       retval = TRUE;
15105     }
15106
15107   /* select next matching iter */
15108   if (event->keyval == GDK_KEY_Down || event->keyval == GDK_KEY_KP_Down)
15109     {
15110       if (!gtk_tree_view_search_move (widget, tree_view, FALSE))
15111         gtk_widget_error_bell (widget);
15112
15113       retval = TRUE;
15114     }
15115
15116   if (((event->state & (GTK_DEFAULT_ACCEL_MOD_MASK | GDK_SHIFT_MASK)) == GTK_DEFAULT_ACCEL_MOD_MASK)
15117       && (event->keyval == GDK_KEY_g || event->keyval == GDK_KEY_G))
15118     {
15119       if (!gtk_tree_view_search_move (widget, tree_view, FALSE))
15120         gtk_widget_error_bell (widget);
15121
15122       retval = TRUE;
15123     }
15124
15125   /* renew the flush timeout */
15126   if (retval && tree_view->priv->typeselect_flush_timeout
15127       && !tree_view->priv->search_custom_entry_set)
15128     {
15129       g_source_remove (tree_view->priv->typeselect_flush_timeout);
15130       tree_view->priv->typeselect_flush_timeout =
15131         gdk_threads_add_timeout (GTK_TREE_VIEW_SEARCH_DIALOG_TIMEOUT,
15132                        (GSourceFunc) gtk_tree_view_search_entry_flush_timeout,
15133                        tree_view);
15134     }
15135
15136   return retval;
15137 }
15138
15139 /*  this function returns FALSE if there is a search string but
15140  *  nothing was found, and TRUE otherwise.
15141  */
15142 static gboolean
15143 gtk_tree_view_search_move (GtkWidget   *window,
15144                            GtkTreeView *tree_view,
15145                            gboolean     up)
15146 {
15147   gboolean ret;
15148   gint len;
15149   gint count = 0;
15150   const gchar *text;
15151   GtkTreeIter iter;
15152   GtkTreeModel *model;
15153   GtkTreeSelection *selection;
15154
15155   text = gtk_entry_get_text (GTK_ENTRY (tree_view->priv->search_entry));
15156
15157   g_return_val_if_fail (text != NULL, FALSE);
15158
15159   len = strlen (text);
15160
15161   if (up && tree_view->priv->selected_iter == 1)
15162     return strlen (text) < 1;
15163
15164   len = strlen (text);
15165
15166   if (len < 1)
15167     return TRUE;
15168
15169   model = gtk_tree_view_get_model (tree_view);
15170   selection = gtk_tree_view_get_selection (tree_view);
15171
15172   /* search */
15173   gtk_tree_selection_unselect_all (selection);
15174   if (!gtk_tree_model_get_iter_first (model, &iter))
15175     return TRUE;
15176
15177   ret = gtk_tree_view_search_iter (model, selection, &iter, text,
15178                                    &count, up?((tree_view->priv->selected_iter) - 1):((tree_view->priv->selected_iter + 1)));
15179
15180   if (ret)
15181     {
15182       /* found */
15183       tree_view->priv->selected_iter += up?(-1):(1);
15184       return TRUE;
15185     }
15186   else
15187     {
15188       /* return to old iter */
15189       count = 0;
15190       gtk_tree_model_get_iter_first (model, &iter);
15191       gtk_tree_view_search_iter (model, selection,
15192                                  &iter, text,
15193                                  &count, tree_view->priv->selected_iter);
15194       return FALSE;
15195     }
15196 }
15197
15198 static gboolean
15199 gtk_tree_view_search_equal_func (GtkTreeModel *model,
15200                                  gint          column,
15201                                  const gchar  *key,
15202                                  GtkTreeIter  *iter,
15203                                  gpointer      search_data)
15204 {
15205   gboolean retval = TRUE;
15206   const gchar *str;
15207   gchar *normalized_string;
15208   gchar *normalized_key;
15209   gchar *case_normalized_string = NULL;
15210   gchar *case_normalized_key = NULL;
15211   GValue value = {0,};
15212   GValue transformed = {0,};
15213
15214   gtk_tree_model_get_value (model, iter, column, &value);
15215
15216   g_value_init (&transformed, G_TYPE_STRING);
15217
15218   if (!g_value_transform (&value, &transformed))
15219     {
15220       g_value_unset (&value);
15221       return TRUE;
15222     }
15223
15224   g_value_unset (&value);
15225
15226   str = g_value_get_string (&transformed);
15227   if (!str)
15228     {
15229       g_value_unset (&transformed);
15230       return TRUE;
15231     }
15232
15233   normalized_string = g_utf8_normalize (str, -1, G_NORMALIZE_ALL);
15234   normalized_key = g_utf8_normalize (key, -1, G_NORMALIZE_ALL);
15235
15236   if (normalized_string && normalized_key)
15237     {
15238       case_normalized_string = g_utf8_casefold (normalized_string, -1);
15239       case_normalized_key = g_utf8_casefold (normalized_key, -1);
15240
15241       if (strncmp (case_normalized_key, case_normalized_string, strlen (case_normalized_key)) == 0)
15242         retval = FALSE;
15243     }
15244
15245   g_value_unset (&transformed);
15246   g_free (normalized_key);
15247   g_free (normalized_string);
15248   g_free (case_normalized_key);
15249   g_free (case_normalized_string);
15250
15251   return retval;
15252 }
15253
15254 static gboolean
15255 gtk_tree_view_search_iter (GtkTreeModel     *model,
15256                            GtkTreeSelection *selection,
15257                            GtkTreeIter      *iter,
15258                            const gchar      *text,
15259                            gint             *count,
15260                            gint              n)
15261 {
15262   GtkRBTree *tree = NULL;
15263   GtkRBNode *node = NULL;
15264   GtkTreePath *path;
15265
15266   GtkTreeView *tree_view = gtk_tree_selection_get_tree_view (selection);
15267
15268   path = gtk_tree_model_get_path (model, iter);
15269   _gtk_tree_view_find_node (tree_view, path, &tree, &node);
15270
15271   do
15272     {
15273       if (! tree_view->priv->search_equal_func (model, tree_view->priv->search_column, text, iter, tree_view->priv->search_user_data))
15274         {
15275           (*count)++;
15276           if (*count == n)
15277             {
15278               gtk_tree_view_scroll_to_cell (tree_view, path, NULL,
15279                                             TRUE, 0.5, 0.0);
15280               gtk_tree_selection_select_iter (selection, iter);
15281               gtk_tree_view_real_set_cursor (tree_view, path, FALSE, TRUE);
15282
15283               if (path)
15284                 gtk_tree_path_free (path);
15285
15286               return TRUE;
15287             }
15288         }
15289
15290       if (node->children)
15291         {
15292           gboolean has_child;
15293           GtkTreeIter tmp;
15294
15295           tree = node->children;
15296           node = tree->root;
15297
15298           while (node->left != tree->nil)
15299             node = node->left;
15300
15301           tmp = *iter;
15302           has_child = gtk_tree_model_iter_children (model, iter, &tmp);
15303           gtk_tree_path_down (path);
15304
15305           /* sanity check */
15306           TREE_VIEW_INTERNAL_ASSERT (has_child, FALSE);
15307         }
15308       else
15309         {
15310           gboolean done = FALSE;
15311
15312           do
15313             {
15314               node = _gtk_rbtree_next (tree, node);
15315
15316               if (node)
15317                 {
15318                   gboolean has_next;
15319
15320                   has_next = gtk_tree_model_iter_next (model, iter);
15321
15322                   done = TRUE;
15323                   gtk_tree_path_next (path);
15324
15325                   /* sanity check */
15326                   TREE_VIEW_INTERNAL_ASSERT (has_next, FALSE);
15327                 }
15328               else
15329                 {
15330                   gboolean has_parent;
15331                   GtkTreeIter tmp_iter = *iter;
15332
15333                   node = tree->parent_node;
15334                   tree = tree->parent_tree;
15335
15336                   if (!tree)
15337                     {
15338                       if (path)
15339                         gtk_tree_path_free (path);
15340
15341                       /* we've run out of tree, done with this func */
15342                       return FALSE;
15343                     }
15344
15345                   has_parent = gtk_tree_model_iter_parent (model,
15346                                                            iter,
15347                                                            &tmp_iter);
15348                   gtk_tree_path_up (path);
15349
15350                   /* sanity check */
15351                   TREE_VIEW_INTERNAL_ASSERT (has_parent, FALSE);
15352                 }
15353             }
15354           while (!done);
15355         }
15356     }
15357   while (1);
15358
15359   return FALSE;
15360 }
15361
15362 static void
15363 gtk_tree_view_search_init (GtkWidget   *entry,
15364                            GtkTreeView *tree_view)
15365 {
15366   gint ret;
15367   gint count = 0;
15368   const gchar *text;
15369   GtkTreeIter iter;
15370   GtkTreeModel *model;
15371   GtkTreeSelection *selection;
15372
15373   g_return_if_fail (GTK_IS_ENTRY (entry));
15374   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
15375
15376   text = gtk_entry_get_text (GTK_ENTRY (entry));
15377
15378   model = gtk_tree_view_get_model (tree_view);
15379   selection = gtk_tree_view_get_selection (tree_view);
15380
15381   /* search */
15382   gtk_tree_selection_unselect_all (selection);
15383   if (tree_view->priv->typeselect_flush_timeout
15384       && !tree_view->priv->search_custom_entry_set)
15385     {
15386       g_source_remove (tree_view->priv->typeselect_flush_timeout);
15387       tree_view->priv->typeselect_flush_timeout =
15388         gdk_threads_add_timeout (GTK_TREE_VIEW_SEARCH_DIALOG_TIMEOUT,
15389                        (GSourceFunc) gtk_tree_view_search_entry_flush_timeout,
15390                        tree_view);
15391     }
15392
15393   if (*text == '\0')
15394     return;
15395
15396   if (!gtk_tree_model_get_iter_first (model, &iter))
15397     return;
15398
15399   ret = gtk_tree_view_search_iter (model, selection,
15400                                    &iter, text,
15401                                    &count, 1);
15402
15403   if (ret)
15404     tree_view->priv->selected_iter = 1;
15405 }
15406
15407 void
15408 _gtk_tree_view_remove_editable (GtkTreeView       *tree_view,
15409                                 GtkTreeViewColumn *column,
15410                                 GtkCellEditable   *cell_editable)
15411 {
15412   if (tree_view->priv->edited_column == NULL)
15413     return;
15414
15415   g_return_if_fail (column == tree_view->priv->edited_column);
15416
15417   tree_view->priv->edited_column = NULL;
15418
15419   if (gtk_widget_has_focus (GTK_WIDGET (cell_editable)))
15420     gtk_widget_grab_focus (GTK_WIDGET (tree_view));
15421
15422   gtk_container_remove (GTK_CONTAINER (tree_view),
15423                         GTK_WIDGET (cell_editable));
15424
15425   /* FIXME should only redraw a single node */
15426   gtk_widget_queue_draw (GTK_WIDGET (tree_view));
15427 }
15428
15429 static gboolean
15430 gtk_tree_view_start_editing (GtkTreeView *tree_view,
15431                              GtkTreePath *cursor_path,
15432                              gboolean     edit_only)
15433 {
15434   GtkTreeIter iter;
15435   GdkRectangle cell_area;
15436   GtkTreeViewColumn *focus_column;
15437   gchar *path_string;
15438   guint flags = 0; /* can be 0, as the flags are primarily for rendering */
15439   gint retval = FALSE;
15440   GtkRBTree *cursor_tree;
15441   GtkRBNode *cursor_node;
15442
15443   g_assert (tree_view->priv->focus_column);
15444   focus_column = tree_view->priv->focus_column;
15445
15446   if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
15447     return FALSE;
15448
15449   if (_gtk_tree_view_find_node (tree_view, cursor_path, &cursor_tree, &cursor_node) ||
15450       cursor_node == NULL)
15451     return FALSE;
15452
15453   path_string = gtk_tree_path_to_string (cursor_path);
15454   gtk_tree_model_get_iter (tree_view->priv->model, &iter, cursor_path);
15455
15456   validate_row (tree_view, cursor_tree, cursor_node, &iter, cursor_path);
15457
15458   gtk_tree_view_column_cell_set_cell_data (focus_column,
15459                                            tree_view->priv->model,
15460                                            &iter,
15461                                            GTK_RBNODE_FLAG_SET (cursor_node, GTK_RBNODE_IS_PARENT),
15462                                            cursor_node->children?TRUE:FALSE);
15463   gtk_tree_view_get_cell_area (tree_view,
15464                                cursor_path,
15465                                focus_column,
15466                                &cell_area);
15467
15468   if (gtk_cell_area_activate (gtk_cell_layout_get_area (GTK_CELL_LAYOUT (focus_column)),
15469                               _gtk_tree_view_column_get_context (focus_column),
15470                               GTK_WIDGET (tree_view),
15471                               &cell_area,
15472                               flags, edit_only))
15473     retval = TRUE;
15474
15475   return retval;
15476 }
15477
15478 void
15479 _gtk_tree_view_add_editable (GtkTreeView       *tree_view,
15480                              GtkTreeViewColumn *column,
15481                              GtkTreePath       *path,
15482                              GtkCellEditable   *cell_editable,
15483                              GdkRectangle      *cell_area)
15484 {
15485   gint pre_val = tree_view->priv->vadjustment->value;
15486   GtkRequisition requisition;
15487
15488   tree_view->priv->edited_column = column;
15489
15490   gtk_tree_view_real_set_cursor (tree_view, path, FALSE, TRUE);
15491   cell_area->y += pre_val - (int)tree_view->priv->vadjustment->value;
15492
15493   gtk_widget_get_preferred_size (GTK_WIDGET (cell_editable),
15494                                  &requisition, NULL);
15495
15496   tree_view->priv->draw_keyfocus = TRUE;
15497
15498   if (requisition.height < cell_area->height)
15499     {
15500       gint diff = cell_area->height - requisition.height;
15501       gtk_tree_view_put (tree_view,
15502                          GTK_WIDGET (cell_editable),
15503                          cell_area->x, cell_area->y + diff/2,
15504                          cell_area->width, requisition.height);
15505     }
15506   else
15507     {
15508       gtk_tree_view_put (tree_view,
15509                          GTK_WIDGET (cell_editable),
15510                          cell_area->x, cell_area->y,
15511                          cell_area->width, cell_area->height);
15512     }
15513 }
15514
15515 static void
15516 gtk_tree_view_stop_editing (GtkTreeView *tree_view,
15517                             gboolean     cancel_editing)
15518 {
15519   GtkTreeViewColumn *column;
15520
15521   if (tree_view->priv->edited_column == NULL)
15522     return;
15523
15524   /*
15525    * This is very evil. We need to do this, because
15526    * gtk_cell_editable_editing_done may trigger gtk_tree_view_row_changed
15527    * later on. If gtk_tree_view_row_changed notices
15528    * tree_view->priv->edited_column != NULL, it'll call
15529    * gtk_tree_view_stop_editing again. Bad things will happen then.
15530    *
15531    * Please read that again if you intend to modify anything here.
15532    */
15533
15534   column = tree_view->priv->edited_column;
15535   gtk_cell_area_stop_editing (gtk_cell_layout_get_area (GTK_CELL_LAYOUT (column)), cancel_editing);
15536   tree_view->priv->edited_column = NULL;
15537 }
15538
15539
15540 /**
15541  * gtk_tree_view_set_hover_selection:
15542  * @tree_view: a #GtkTreeView
15543  * @hover: %TRUE to enable hover selection mode
15544  *
15545  * Enables of disables the hover selection mode of @tree_view.
15546  * Hover selection makes the selected row follow the pointer.
15547  * Currently, this works only for the selection modes
15548  * %GTK_SELECTION_SINGLE and %GTK_SELECTION_BROWSE.
15549  *
15550  * Since: 2.6
15551  **/
15552 void
15553 gtk_tree_view_set_hover_selection (GtkTreeView *tree_view,
15554                                    gboolean     hover)
15555 {
15556   hover = hover != FALSE;
15557
15558   if (hover != tree_view->priv->hover_selection)
15559     {
15560       tree_view->priv->hover_selection = hover;
15561
15562       g_object_notify (G_OBJECT (tree_view), "hover-selection");
15563     }
15564 }
15565
15566 /**
15567  * gtk_tree_view_get_hover_selection:
15568  * @tree_view: a #GtkTreeView
15569  *
15570  * Returns whether hover selection mode is turned on for @tree_view.
15571  *
15572  * Return value: %TRUE if @tree_view is in hover selection mode
15573  *
15574  * Since: 2.6
15575  **/
15576 gboolean
15577 gtk_tree_view_get_hover_selection (GtkTreeView *tree_view)
15578 {
15579   return tree_view->priv->hover_selection;
15580 }
15581
15582 /**
15583  * gtk_tree_view_set_hover_expand:
15584  * @tree_view: a #GtkTreeView
15585  * @expand: %TRUE to enable hover selection mode
15586  *
15587  * Enables of disables the hover expansion mode of @tree_view.
15588  * Hover expansion makes rows expand or collapse if the pointer
15589  * moves over them.
15590  *
15591  * Since: 2.6
15592  **/
15593 void
15594 gtk_tree_view_set_hover_expand (GtkTreeView *tree_view,
15595                                 gboolean     expand)
15596 {
15597   expand = expand != FALSE;
15598
15599   if (expand != tree_view->priv->hover_expand)
15600     {
15601       tree_view->priv->hover_expand = expand;
15602
15603       g_object_notify (G_OBJECT (tree_view), "hover-expand");
15604     }
15605 }
15606
15607 /**
15608  * gtk_tree_view_get_hover_expand:
15609  * @tree_view: a #GtkTreeView
15610  *
15611  * Returns whether hover expansion mode is turned on for @tree_view.
15612  *
15613  * Return value: %TRUE if @tree_view is in hover expansion mode
15614  *
15615  * Since: 2.6
15616  **/
15617 gboolean
15618 gtk_tree_view_get_hover_expand (GtkTreeView *tree_view)
15619 {
15620   return tree_view->priv->hover_expand;
15621 }
15622
15623 /**
15624  * gtk_tree_view_set_rubber_banding:
15625  * @tree_view: a #GtkTreeView
15626  * @enable: %TRUE to enable rubber banding
15627  *
15628  * Enables or disables rubber banding in @tree_view.  If the selection mode
15629  * is #GTK_SELECTION_MULTIPLE, rubber banding will allow the user to select
15630  * multiple rows by dragging the mouse.
15631  *
15632  * Since: 2.10
15633  **/
15634 void
15635 gtk_tree_view_set_rubber_banding (GtkTreeView *tree_view,
15636                                   gboolean     enable)
15637 {
15638   enable = enable != FALSE;
15639
15640   if (enable != tree_view->priv->rubber_banding_enable)
15641     {
15642       tree_view->priv->rubber_banding_enable = enable;
15643
15644       g_object_notify (G_OBJECT (tree_view), "rubber-banding");
15645     }
15646 }
15647
15648 /**
15649  * gtk_tree_view_get_rubber_banding:
15650  * @tree_view: a #GtkTreeView
15651  *
15652  * Returns whether rubber banding is turned on for @tree_view.  If the
15653  * selection mode is #GTK_SELECTION_MULTIPLE, rubber banding will allow the
15654  * user to select multiple rows by dragging the mouse.
15655  *
15656  * Return value: %TRUE if rubber banding in @tree_view is enabled.
15657  *
15658  * Since: 2.10
15659  **/
15660 gboolean
15661 gtk_tree_view_get_rubber_banding (GtkTreeView *tree_view)
15662 {
15663   return tree_view->priv->rubber_banding_enable;
15664 }
15665
15666 /**
15667  * gtk_tree_view_is_rubber_banding_active:
15668  * @tree_view: a #GtkTreeView
15669  *
15670  * Returns whether a rubber banding operation is currently being done
15671  * in @tree_view.
15672  *
15673  * Return value: %TRUE if a rubber banding operation is currently being
15674  * done in @tree_view.
15675  *
15676  * Since: 2.12
15677  **/
15678 gboolean
15679 gtk_tree_view_is_rubber_banding_active (GtkTreeView *tree_view)
15680 {
15681   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
15682
15683   if (tree_view->priv->rubber_banding_enable
15684       && tree_view->priv->rubber_band_status == RUBBER_BAND_ACTIVE)
15685     return TRUE;
15686
15687   return FALSE;
15688 }
15689
15690 /**
15691  * gtk_tree_view_get_row_separator_func:
15692  * @tree_view: a #GtkTreeView
15693  *
15694  * Returns the current row separator function.
15695  *
15696  * Return value: the current row separator function.
15697  *
15698  * Since: 2.6
15699  **/
15700 GtkTreeViewRowSeparatorFunc
15701 gtk_tree_view_get_row_separator_func (GtkTreeView *tree_view)
15702 {
15703   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
15704
15705   return tree_view->priv->row_separator_func;
15706 }
15707
15708 /**
15709  * gtk_tree_view_set_row_separator_func:
15710  * @tree_view: a #GtkTreeView
15711  * @func: (allow-none): a #GtkTreeViewRowSeparatorFunc
15712  * @data: (allow-none): user data to pass to @func, or %NULL
15713  * @destroy: (allow-none): destroy notifier for @data, or %NULL
15714  *
15715  * Sets the row separator function, which is used to determine
15716  * whether a row should be drawn as a separator. If the row separator
15717  * function is %NULL, no separators are drawn. This is the default value.
15718  *
15719  * Since: 2.6
15720  **/
15721 void
15722 gtk_tree_view_set_row_separator_func (GtkTreeView                 *tree_view,
15723                                       GtkTreeViewRowSeparatorFunc  func,
15724                                       gpointer                     data,
15725                                       GDestroyNotify               destroy)
15726 {
15727   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
15728
15729   if (tree_view->priv->row_separator_destroy)
15730     tree_view->priv->row_separator_destroy (tree_view->priv->row_separator_data);
15731
15732   tree_view->priv->row_separator_func = func;
15733   tree_view->priv->row_separator_data = data;
15734   tree_view->priv->row_separator_destroy = destroy;
15735
15736   /* Have the tree recalculate heights */
15737   _gtk_rbtree_mark_invalid (tree_view->priv->tree);
15738   gtk_widget_queue_resize (GTK_WIDGET (tree_view));
15739 }
15740
15741
15742 static void
15743 gtk_tree_view_grab_notify (GtkWidget *widget,
15744                            gboolean   was_grabbed)
15745 {
15746   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
15747
15748   tree_view->priv->in_grab = !was_grabbed;
15749
15750   if (!was_grabbed)
15751     {
15752       tree_view->priv->pressed_button = -1;
15753
15754       if (tree_view->priv->rubber_band_status)
15755         gtk_tree_view_stop_rubber_band (tree_view);
15756     }
15757 }
15758
15759 static void
15760 gtk_tree_view_state_changed (GtkWidget      *widget,
15761                              GtkStateType    previous_state)
15762 {
15763   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
15764
15765   if (gtk_widget_get_realized (widget))
15766     {
15767       gdk_window_set_background (tree_view->priv->bin_window,
15768                                  &gtk_widget_get_style (widget)->base[gtk_widget_get_state (widget)]);
15769     }
15770
15771   gtk_widget_queue_draw (widget);
15772 }
15773
15774 /**
15775  * gtk_tree_view_get_grid_lines:
15776  * @tree_view: a #GtkTreeView
15777  *
15778  * Returns which grid lines are enabled in @tree_view.
15779  *
15780  * Return value: a #GtkTreeViewGridLines value indicating which grid lines
15781  * are enabled.
15782  *
15783  * Since: 2.10
15784  */
15785 GtkTreeViewGridLines
15786 gtk_tree_view_get_grid_lines (GtkTreeView *tree_view)
15787 {
15788   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), 0);
15789
15790   return tree_view->priv->grid_lines;
15791 }
15792
15793 /**
15794  * gtk_tree_view_set_grid_lines:
15795  * @tree_view: a #GtkTreeView
15796  * @grid_lines: a #GtkTreeViewGridLines value indicating which grid lines to
15797  * enable.
15798  *
15799  * Sets which grid lines to draw in @tree_view.
15800  *
15801  * Since: 2.10
15802  */
15803 void
15804 gtk_tree_view_set_grid_lines (GtkTreeView           *tree_view,
15805                               GtkTreeViewGridLines   grid_lines)
15806 {
15807   GtkTreeViewPrivate *priv;
15808   GtkWidget *widget;
15809   GtkTreeViewGridLines old_grid_lines;
15810
15811   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
15812
15813   priv = tree_view->priv;
15814   widget = GTK_WIDGET (tree_view);
15815
15816   old_grid_lines = priv->grid_lines;
15817   priv->grid_lines = grid_lines;
15818
15819   if (gtk_widget_get_realized (widget))
15820     {
15821       if (grid_lines == GTK_TREE_VIEW_GRID_LINES_NONE &&
15822           priv->grid_line_width)
15823         {
15824           priv->grid_line_width = 0;
15825         }
15826
15827       if (grid_lines != GTK_TREE_VIEW_GRID_LINES_NONE &&
15828           !priv->grid_line_width)
15829         {
15830           gint8 *dash_list;
15831
15832           gtk_widget_style_get (widget,
15833                                 "grid-line-width", &priv->grid_line_width,
15834                                 "grid-line-pattern", (gchar *)&dash_list,
15835                                 NULL);
15836
15837           if (dash_list)
15838             {
15839               priv->grid_line_dashes[0] = dash_list[0];
15840               if (dash_list[0])
15841                 priv->grid_line_dashes[1] = dash_list[1];
15842
15843               g_free (dash_list);
15844             }
15845           else
15846             {
15847               priv->grid_line_dashes[0] = 1;
15848               priv->grid_line_dashes[1] = 1;
15849             }
15850         }
15851     }
15852
15853   if (old_grid_lines != grid_lines)
15854     {
15855       gtk_widget_queue_draw (GTK_WIDGET (tree_view));
15856
15857       g_object_notify (G_OBJECT (tree_view), "enable-grid-lines");
15858     }
15859 }
15860
15861 /**
15862  * gtk_tree_view_get_enable_tree_lines:
15863  * @tree_view: a #GtkTreeView.
15864  *
15865  * Returns whether or not tree lines are drawn in @tree_view.
15866  *
15867  * Return value: %TRUE if tree lines are drawn in @tree_view, %FALSE
15868  * otherwise.
15869  *
15870  * Since: 2.10
15871  */
15872 gboolean
15873 gtk_tree_view_get_enable_tree_lines (GtkTreeView *tree_view)
15874 {
15875   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
15876
15877   return tree_view->priv->tree_lines_enabled;
15878 }
15879
15880 /**
15881  * gtk_tree_view_set_enable_tree_lines:
15882  * @tree_view: a #GtkTreeView
15883  * @enabled: %TRUE to enable tree line drawing, %FALSE otherwise.
15884  *
15885  * Sets whether to draw lines interconnecting the expanders in @tree_view.
15886  * This does not have any visible effects for lists.
15887  *
15888  * Since: 2.10
15889  */
15890 void
15891 gtk_tree_view_set_enable_tree_lines (GtkTreeView *tree_view,
15892                                      gboolean     enabled)
15893 {
15894   GtkTreeViewPrivate *priv;
15895   GtkWidget *widget;
15896   gboolean was_enabled;
15897
15898   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
15899
15900   enabled = enabled != FALSE;
15901
15902   priv = tree_view->priv;
15903   widget = GTK_WIDGET (tree_view);
15904
15905   was_enabled = priv->tree_lines_enabled;
15906
15907   priv->tree_lines_enabled = enabled;
15908
15909   if (gtk_widget_get_realized (widget))
15910     {
15911       if (!enabled && priv->tree_line_width)
15912         {
15913           priv->tree_line_width = 0;
15914         }
15915
15916       if (enabled && !priv->tree_line_width)
15917         {
15918           gint8 *dash_list;
15919           gtk_widget_style_get (widget,
15920                                 "tree-line-width", &priv->tree_line_width,
15921                                 "tree-line-pattern", (gchar *)&dash_list,
15922                                 NULL);
15923
15924           if (dash_list)
15925             {
15926               priv->tree_line_dashes[0] = dash_list[0];
15927               if (dash_list[0])
15928                 priv->tree_line_dashes[1] = dash_list[1];
15929
15930               g_free (dash_list);
15931             }
15932           else
15933             {
15934               priv->tree_line_dashes[0] = 1;
15935               priv->tree_line_dashes[1] = 1;
15936             }
15937         }
15938     }
15939
15940   if (was_enabled != enabled)
15941     {
15942       gtk_widget_queue_draw (GTK_WIDGET (tree_view));
15943
15944       g_object_notify (G_OBJECT (tree_view), "enable-tree-lines");
15945     }
15946 }
15947
15948
15949 /**
15950  * gtk_tree_view_set_show_expanders:
15951  * @tree_view: a #GtkTreeView
15952  * @enabled: %TRUE to enable expander drawing, %FALSE otherwise.
15953  *
15954  * Sets whether to draw and enable expanders and indent child rows in
15955  * @tree_view.  When disabled there will be no expanders visible in trees
15956  * and there will be no way to expand and collapse rows by default.  Also
15957  * note that hiding the expanders will disable the default indentation.  You
15958  * can set a custom indentation in this case using
15959  * gtk_tree_view_set_level_indentation().
15960  * This does not have any visible effects for lists.
15961  *
15962  * Since: 2.12
15963  */
15964 void
15965 gtk_tree_view_set_show_expanders (GtkTreeView *tree_view,
15966                                   gboolean     enabled)
15967 {
15968   gboolean was_enabled;
15969
15970   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
15971
15972   enabled = enabled != FALSE;
15973   was_enabled = tree_view->priv->show_expanders;
15974
15975   tree_view->priv->show_expanders = enabled == TRUE;
15976
15977   if (enabled != was_enabled)
15978     gtk_widget_queue_draw (GTK_WIDGET (tree_view));
15979 }
15980
15981 /**
15982  * gtk_tree_view_get_show_expanders:
15983  * @tree_view: a #GtkTreeView.
15984  *
15985  * Returns whether or not expanders are drawn in @tree_view.
15986  *
15987  * Return value: %TRUE if expanders are drawn in @tree_view, %FALSE
15988  * otherwise.
15989  *
15990  * Since: 2.12
15991  */
15992 gboolean
15993 gtk_tree_view_get_show_expanders (GtkTreeView *tree_view)
15994 {
15995   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
15996
15997   return tree_view->priv->show_expanders;
15998 }
15999
16000 /**
16001  * gtk_tree_view_set_level_indentation:
16002  * @tree_view: a #GtkTreeView
16003  * @indentation: the amount, in pixels, of extra indentation in @tree_view.
16004  *
16005  * Sets the amount of extra indentation for child levels to use in @tree_view
16006  * in addition to the default indentation.  The value should be specified in
16007  * pixels, a value of 0 disables this feature and in this case only the default
16008  * indentation will be used.
16009  * This does not have any visible effects for lists.
16010  *
16011  * Since: 2.12
16012  */
16013 void
16014 gtk_tree_view_set_level_indentation (GtkTreeView *tree_view,
16015                                      gint         indentation)
16016 {
16017   tree_view->priv->level_indentation = indentation;
16018
16019   gtk_widget_queue_draw (GTK_WIDGET (tree_view));
16020 }
16021
16022 /**
16023  * gtk_tree_view_get_level_indentation:
16024  * @tree_view: a #GtkTreeView.
16025  *
16026  * Returns the amount, in pixels, of extra indentation for child levels
16027  * in @tree_view.
16028  *
16029  * Return value: the amount of extra indentation for child levels in
16030  * @tree_view.  A return value of 0 means that this feature is disabled.
16031  *
16032  * Since: 2.12
16033  */
16034 gint
16035 gtk_tree_view_get_level_indentation (GtkTreeView *tree_view)
16036 {
16037   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), 0);
16038
16039   return tree_view->priv->level_indentation;
16040 }
16041
16042 /**
16043  * gtk_tree_view_set_tooltip_row:
16044  * @tree_view: a #GtkTreeView
16045  * @tooltip: a #GtkTooltip
16046  * @path: a #GtkTreePath
16047  *
16048  * Sets the tip area of @tooltip to be the area covered by the row at @path.
16049  * See also gtk_tree_view_set_tooltip_column() for a simpler alternative.
16050  * See also gtk_tooltip_set_tip_area().
16051  *
16052  * Since: 2.12
16053  */
16054 void
16055 gtk_tree_view_set_tooltip_row (GtkTreeView *tree_view,
16056                                GtkTooltip  *tooltip,
16057                                GtkTreePath *path)
16058 {
16059   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
16060   g_return_if_fail (GTK_IS_TOOLTIP (tooltip));
16061
16062   gtk_tree_view_set_tooltip_cell (tree_view, tooltip, path, NULL, NULL);
16063 }
16064
16065 /**
16066  * gtk_tree_view_set_tooltip_cell:
16067  * @tree_view: a #GtkTreeView
16068  * @tooltip: a #GtkTooltip
16069  * @path: (allow-none): a #GtkTreePath or %NULL
16070  * @column: (allow-none): a #GtkTreeViewColumn or %NULL
16071  * @cell: (allow-none): a #GtkCellRenderer or %NULL
16072  *
16073  * Sets the tip area of @tooltip to the area @path, @column and @cell have
16074  * in common.  For example if @path is %NULL and @column is set, the tip
16075  * area will be set to the full area covered by @column.  See also
16076  * gtk_tooltip_set_tip_area().
16077  *
16078  * Note that if @path is not specified and @cell is set and part of a column
16079  * containing the expander, the tooltip might not show and hide at the correct
16080  * position.  In such cases @path must be set to the current node under the
16081  * mouse cursor for this function to operate correctly.
16082  *
16083  * See also gtk_tree_view_set_tooltip_column() for a simpler alternative.
16084  *
16085  * Since: 2.12
16086  */
16087 void
16088 gtk_tree_view_set_tooltip_cell (GtkTreeView       *tree_view,
16089                                 GtkTooltip        *tooltip,
16090                                 GtkTreePath       *path,
16091                                 GtkTreeViewColumn *column,
16092                                 GtkCellRenderer   *cell)
16093 {
16094   GtkAllocation allocation;
16095   GdkRectangle rect;
16096
16097   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
16098   g_return_if_fail (GTK_IS_TOOLTIP (tooltip));
16099   g_return_if_fail (column == NULL || GTK_IS_TREE_VIEW_COLUMN (column));
16100   g_return_if_fail (cell == NULL || GTK_IS_CELL_RENDERER (cell));
16101
16102   /* Determine x values. */
16103   if (column && cell)
16104     {
16105       GdkRectangle tmp;
16106       gint start, width;
16107
16108       /* We always pass in path here, whether it is NULL or not.
16109        * For cells in expander columns path must be specified so that
16110        * we can correctly account for the indentation.  This also means
16111        * that the tooltip is constrained vertically by the "Determine y
16112        * values" code below; this is not a real problem since cells actually
16113        * don't stretch vertically in constrast to columns.
16114        */
16115       gtk_tree_view_get_cell_area (tree_view, path, column, &tmp);
16116       gtk_tree_view_column_cell_get_position (column, cell, &start, &width);
16117
16118       gtk_tree_view_convert_bin_window_to_widget_coords (tree_view,
16119                                                          tmp.x + start, 0,
16120                                                          &rect.x, NULL);
16121       rect.width = width;
16122     }
16123   else if (column)
16124     {
16125       GdkRectangle tmp;
16126
16127       gtk_tree_view_get_background_area (tree_view, NULL, column, &tmp);
16128       gtk_tree_view_convert_bin_window_to_widget_coords (tree_view,
16129                                                          tmp.x, 0,
16130                                                          &rect.x, NULL);
16131       rect.width = tmp.width;
16132     }
16133   else
16134     {
16135       gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
16136       rect.x = 0;
16137       rect.width = allocation.width;
16138     }
16139
16140   /* Determine y values. */
16141   if (path)
16142     {
16143       GdkRectangle tmp;
16144
16145       gtk_tree_view_get_background_area (tree_view, path, NULL, &tmp);
16146       gtk_tree_view_convert_bin_window_to_widget_coords (tree_view,
16147                                                          0, tmp.y,
16148                                                          NULL, &rect.y);
16149       rect.height = tmp.height;
16150     }
16151   else
16152     {
16153       rect.y = 0;
16154       rect.height = tree_view->priv->vadjustment->page_size;
16155     }
16156
16157   gtk_tooltip_set_tip_area (tooltip, &rect);
16158 }
16159
16160 /**
16161  * gtk_tree_view_get_tooltip_context:
16162  * @tree_view: a #GtkTreeView
16163  * @x: the x coordinate (relative to widget coordinates)
16164  * @y: the y coordinate (relative to widget coordinates)
16165  * @keyboard_tip: whether this is a keyboard tooltip or not
16166  * @model: (out) (allow-none): a pointer to receive a #GtkTreeModel or %NULL
16167  * @path: (out) (allow-none): a pointer to receive a #GtkTreePath or %NULL
16168  * @iter: (out) (allow-none): a pointer to receive a #GtkTreeIter or %NULL
16169  *
16170  * This function is supposed to be used in a #GtkWidget::query-tooltip
16171  * signal handler for #GtkTreeView.  The @x, @y and @keyboard_tip values
16172  * which are received in the signal handler, should be passed to this
16173  * function without modification.
16174  *
16175  * The return value indicates whether there is a tree view row at the given
16176  * coordinates (%TRUE) or not (%FALSE) for mouse tooltips.  For keyboard
16177  * tooltips the row returned will be the cursor row.  When %TRUE, then any of
16178  * @model, @path and @iter which have been provided will be set to point to
16179  * that row and the corresponding model.  @x and @y will always be converted
16180  * to be relative to @tree_view's bin_window if @keyboard_tooltip is %FALSE.
16181  *
16182  * Return value: whether or not the given tooltip context points to a row.
16183  *
16184  * Since: 2.12
16185  */
16186 gboolean
16187 gtk_tree_view_get_tooltip_context (GtkTreeView   *tree_view,
16188                                    gint          *x,
16189                                    gint          *y,
16190                                    gboolean       keyboard_tip,
16191                                    GtkTreeModel **model,
16192                                    GtkTreePath  **path,
16193                                    GtkTreeIter   *iter)
16194 {
16195   GtkTreePath *tmppath = NULL;
16196
16197   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
16198   g_return_val_if_fail (x != NULL, FALSE);
16199   g_return_val_if_fail (y != NULL, FALSE);
16200
16201   if (keyboard_tip)
16202     {
16203       gtk_tree_view_get_cursor (tree_view, &tmppath, NULL);
16204
16205       if (!tmppath)
16206         return FALSE;
16207     }
16208   else
16209     {
16210       gtk_tree_view_convert_widget_to_bin_window_coords (tree_view, *x, *y,
16211                                                          x, y);
16212
16213       if (!gtk_tree_view_get_path_at_pos (tree_view, *x, *y,
16214                                           &tmppath, NULL, NULL, NULL))
16215         return FALSE;
16216     }
16217
16218   if (model)
16219     *model = gtk_tree_view_get_model (tree_view);
16220
16221   if (iter)
16222     gtk_tree_model_get_iter (gtk_tree_view_get_model (tree_view),
16223                              iter, tmppath);
16224
16225   if (path)
16226     *path = tmppath;
16227   else
16228     gtk_tree_path_free (tmppath);
16229
16230   return TRUE;
16231 }
16232
16233 static gboolean
16234 gtk_tree_view_set_tooltip_query_cb (GtkWidget  *widget,
16235                                     gint        x,
16236                                     gint        y,
16237                                     gboolean    keyboard_tip,
16238                                     GtkTooltip *tooltip,
16239                                     gpointer    data)
16240 {
16241   GValue value = { 0, };
16242   GValue transformed = { 0, };
16243   GtkTreeIter iter;
16244   GtkTreePath *path;
16245   GtkTreeModel *model;
16246   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
16247
16248   if (!gtk_tree_view_get_tooltip_context (GTK_TREE_VIEW (widget),
16249                                           &x, &y,
16250                                           keyboard_tip,
16251                                           &model, &path, &iter))
16252     return FALSE;
16253
16254   gtk_tree_model_get_value (model, &iter,
16255                             tree_view->priv->tooltip_column, &value);
16256
16257   g_value_init (&transformed, G_TYPE_STRING);
16258
16259   if (!g_value_transform (&value, &transformed))
16260     {
16261       g_value_unset (&value);
16262       gtk_tree_path_free (path);
16263
16264       return FALSE;
16265     }
16266
16267   g_value_unset (&value);
16268
16269   if (!g_value_get_string (&transformed))
16270     {
16271       g_value_unset (&transformed);
16272       gtk_tree_path_free (path);
16273
16274       return FALSE;
16275     }
16276
16277   gtk_tooltip_set_markup (tooltip, g_value_get_string (&transformed));
16278   gtk_tree_view_set_tooltip_row (tree_view, tooltip, path);
16279
16280   gtk_tree_path_free (path);
16281   g_value_unset (&transformed);
16282
16283   return TRUE;
16284 }
16285
16286 /**
16287  * gtk_tree_view_set_tooltip_column:
16288  * @tree_view: a #GtkTreeView
16289  * @column: an integer, which is a valid column number for @tree_view's model
16290  *
16291  * If you only plan to have simple (text-only) tooltips on full rows, you
16292  * can use this function to have #GtkTreeView handle these automatically
16293  * for you. @column should be set to the column in @tree_view's model
16294  * containing the tooltip texts, or -1 to disable this feature.
16295  *
16296  * When enabled, #GtkWidget::has-tooltip will be set to %TRUE and
16297  * @tree_view will connect a #GtkWidget::query-tooltip signal handler.
16298  *
16299  * Note that the signal handler sets the text with gtk_tooltip_set_markup(),
16300  * so &amp;, &lt;, etc have to be escaped in the text.
16301  *
16302  * Since: 2.12
16303  */
16304 void
16305 gtk_tree_view_set_tooltip_column (GtkTreeView *tree_view,
16306                                   gint         column)
16307 {
16308   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
16309
16310   if (column == tree_view->priv->tooltip_column)
16311     return;
16312
16313   if (column == -1)
16314     {
16315       g_signal_handlers_disconnect_by_func (tree_view,
16316                                             gtk_tree_view_set_tooltip_query_cb,
16317                                             NULL);
16318       gtk_widget_set_has_tooltip (GTK_WIDGET (tree_view), FALSE);
16319     }
16320   else
16321     {
16322       if (tree_view->priv->tooltip_column == -1)
16323         {
16324           g_signal_connect (tree_view, "query-tooltip",
16325                             G_CALLBACK (gtk_tree_view_set_tooltip_query_cb), NULL);
16326           gtk_widget_set_has_tooltip (GTK_WIDGET (tree_view), TRUE);
16327         }
16328     }
16329
16330   tree_view->priv->tooltip_column = column;
16331   g_object_notify (G_OBJECT (tree_view), "tooltip-column");
16332 }
16333
16334 /**
16335  * gtk_tree_view_get_tooltip_column:
16336  * @tree_view: a #GtkTreeView
16337  *
16338  * Returns the column of @tree_view's model which is being used for
16339  * displaying tooltips on @tree_view's rows.
16340  *
16341  * Return value: the index of the tooltip column that is currently being
16342  * used, or -1 if this is disabled.
16343  *
16344  * Since: 2.12
16345  */
16346 gint
16347 gtk_tree_view_get_tooltip_column (GtkTreeView *tree_view)
16348 {
16349   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), 0);
16350
16351   return tree_view->priv->tooltip_column;
16352 }