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 "gtktreeview.h"
  22 #include "gtkrbtree.h"
  23 #include "gtktreednd.h"
  24 #include "gtktreeprivate.h"
  25 #include "gtkcellrenderer.h"
  26 #include "gtksignal.h"
  27 #include "gtkmain.h"
  28 #include "gtkbutton.h"
  29 #include "gtkalignment.h"
  30 #include "gtklabel.h"
  31 #include "gtkhbox.h"
  32 #include "gtkarrow.h"
  33 #include "gtkintl.h"
  34 #include "gtkbindings.h"
  35
  36 #include <gdk/gdkkeysyms.h>
  37
  38 #if defined (GDK_WINDOWING_X11)
  39 #include "x11/gdkx.h"
  40 #elif defined (GDK_WINDOWING_WIN32)
  41 #include "win32/gdkwin32.h"
  42 #elif defined(GDK_WINDOWING_FB)
  43 #include "linux-fb/gdkfb.h"
  44 #elif defined (GDK_WINDOWING_NANOX)
  45 #include "nanox/gdkprivate-nanox.h"
  46 #endif
  47
  48
  49 #define SCROLL_EDGE_SIZE 15
  50
  51
  52 /* The "background" areas of all rows/cells add up to cover the entire tree.
  53  * The background includes all inter-row and inter-cell spacing.
  54  * The "cell" areas are the cell_area passed in to gtk_cell_renderer_render(),
  55  * i.e. just the cells, no spacing.
  56  */
  57 #define BACKGROUND_FIRST_PIXEL(tree_view,tree,node) (_gtk_rbtree_node_find_offset ((tree), (node)) + TREE_VIEW_HEADER_HEIGHT ((tree_view)))
  58 #define CELL_FIRST_PIXEL(tree_view,tree,node,separator) (BACKGROUND_FIRST_PIXEL (tree_view,tree,node) + separator/2)
  59
  60 #define BACKGROUND_HEIGHT(node) (GTK_RBNODE_GET_HEIGHT (node))
  61 #define CELL_HEIGHT(node, separator) (BACKGROUND_HEIGHT (node) - separator);
  62
  63 #define TREE_WINDOW_Y_TO_RBTREE_Y(tree_view,y) ((y) - TREE_VIEW_HEADER_HEIGHT (tree_view))
  64 #define RBTREE_Y_TO_TREE_WINDOW_Y(tree_view,y) ((y) + TREE_VIEW_HEADER_HEIGHT (tree_view))
  65
  66
  67 typedef struct _GtkTreeViewChild GtkTreeViewChild;
  68 struct _GtkTreeViewChild
  69 {
  70   GtkWidget *widget;
  71   gint x;
  72   gint y;
  73 };
  74
  75
  76 typedef struct _TreeViewDragInfo TreeViewDragInfo;
  77 struct _TreeViewDragInfo
  78 {
  79   GdkModifierType start_button_mask;
  80   GtkTargetList *source_target_list;
  81   GdkDragAction source_actions;
  82   GClosure *row_draggable_closure;
  83
  84   GtkTargetList *dest_target_list;
  85   GClosure *location_droppable_closure;
  86
  87   guint source_set : 1;
  88   guint dest_set : 1;
  89 };
  90
  91
  92 /* Signals */
  93 enum
  94 {
  95   ROW_ACTIVATED,
  96   EXPAND_ROW,
  97   COLLAPSE_ROW,
  98   COLUMNS_CHANGED,
  99   MOVE_CURSOR,
 100   SET_ANCHOR,
 101   TOGGLE_CURSOR_ROW,
 102   EXPAND_COLLAPSE_CURSOR_ROW,
 103   SELECT_CURSOR_PARENT,
 104   LAST_SIGNAL
 105 };
 106
 107 /* Properties */
 108 enum {
 109   PROP_0,
 110   PROP_MODEL,
 111   PROP_HADJUSTMENT,
 112   PROP_VADJUSTMENT,
 113   PROP_HEADERS_VISIBLE,
 114   PROP_HEADERS_CLICKABLE,
 115   PROP_EXPANDER_COLUMN,
 116   PROP_REORDERABLE,
 117   PROP_RULES_HINT
 118 };
 119
 120 static void     gtk_tree_view_class_init           (GtkTreeViewClass *klass);
 121 static void     gtk_tree_view_init                 (GtkTreeView      *tree_view);
 122
 123 /* object signals */
 124 static void     gtk_tree_view_finalize             (GObject          *object);
 125 static void     gtk_tree_view_set_property         (GObject         *object,
 126                                                     guint            prop_id,
 127                                                     const GValue    *value,
 128                                                     GParamSpec      *pspec);
 129 static void     gtk_tree_view_get_property         (GObject         *object,
 130                                                     guint            prop_id,
 131                                                     GValue          *value,
 132                                                     GParamSpec      *pspec);
 133
 134 /* gtkobject signals */
 135 static void     gtk_tree_view_destroy              (GtkObject        *object);
 136
 137 /* gtkwidget signals */
 138 static void     gtk_tree_view_setup_model          (GtkTreeView      *tree_view);
 139 static void     gtk_tree_view_realize              (GtkWidget        *widget);
 140 static void     gtk_tree_view_unrealize            (GtkWidget        *widget);
 141 static void     gtk_tree_view_map                  (GtkWidget        *widget);
 142 static void     gtk_tree_view_size_request         (GtkWidget        *widget,
 143                                                     GtkRequisition   *requisition);
 144 static void     gtk_tree_view_size_allocate        (GtkWidget        *widget,
 145                                                     GtkAllocation    *allocation);
 146 static gboolean gtk_tree_view_expose               (GtkWidget        *widget,
 147                                                     GdkEventExpose   *event);
 148 static gboolean gtk_tree_view_key_press            (GtkWidget        *widget,
 149                                                     GdkEventKey      *event);
 150 static gboolean gtk_tree_view_motion               (GtkWidget        *widget,
 151                                                     GdkEventMotion   *event);
 152 static gboolean gtk_tree_view_enter_notify         (GtkWidget        *widget,
 153                                                     GdkEventCrossing *event);
 154 static gboolean gtk_tree_view_leave_notify         (GtkWidget        *widget,
 155                                                     GdkEventCrossing *event);
 156 static gboolean gtk_tree_view_button_press         (GtkWidget        *widget,
 157                                                     GdkEventButton   *event);
 158 static gboolean gtk_tree_view_button_release       (GtkWidget        *widget,
 159                                                     GdkEventButton   *event);
 160 static void     gtk_tree_view_set_focus_child      (GtkContainer     *container,
 161                                                     GtkWidget        *child);
 162 static void     gtk_tree_view_draw_focus           (GtkWidget        *widget);
 163 static gint     gtk_tree_view_focus_in             (GtkWidget        *widget,
 164                                                     GdkEventFocus    *event);
 165 static gint     gtk_tree_view_focus_out            (GtkWidget        *widget,
 166                                                     GdkEventFocus    *event);
 167 static gint     gtk_tree_view_focus                (GtkContainer     *container,
 168                                                     GtkDirectionType  direction);
 169
 170 /* container signals */
 171 static void     gtk_tree_view_remove               (GtkContainer     *container,
 172                                                     GtkWidget        *widget);
 173 static void     gtk_tree_view_forall               (GtkContainer     *container,
 174                                                     gboolean          include_internals,
 175                                                     GtkCallback       callback,
 176                                                     gpointer          callback_data);
 177
 178 /* Source side drag signals */
 179 static void gtk_tree_view_drag_begin       (GtkWidget        *widget,
 180                                             GdkDragContext   *context);
 181 static void gtk_tree_view_drag_end         (GtkWidget        *widget,
 182                                             GdkDragContext   *context);
 183 static void gtk_tree_view_drag_data_get    (GtkWidget        *widget,
 184                                             GdkDragContext   *context,
 185                                             GtkSelectionData *selection_data,
 186                                             guint             info,
 187                                             guint             time);
 188 static void gtk_tree_view_drag_data_delete (GtkWidget        *widget,
 189                                             GdkDragContext   *context);
 190
 191 /* Target side drag signals */
 192 static void     gtk_tree_view_drag_leave         (GtkWidget        *widget,
 193                                                   GdkDragContext   *context,
 194                                                   guint             time);
 195 static gboolean gtk_tree_view_drag_motion        (GtkWidget        *widget,
 196                                                   GdkDragContext   *context,
 197                                                   gint              x,
 198                                                   gint              y,
 199                                                   guint             time);
 200 static gboolean gtk_tree_view_drag_drop          (GtkWidget        *widget,
 201                                                   GdkDragContext   *context,
 202                                                   gint              x,
 203                                                   gint              y,
 204                                                   guint             time);
 205 static void     gtk_tree_view_drag_data_received (GtkWidget        *widget,
 206                                                   GdkDragContext   *context,
 207                                                   gint              x,
 208                                                   gint              y,
 209                                                   GtkSelectionData *selection_data,
 210                                                   guint             info,
 211                                                   guint             time);
 212
 213 /* tree_model signals */
 214 static void gtk_tree_view_set_adjustments                 (GtkTreeView     *tree_view,
 215                                                            GtkAdjustment   *hadj,
 216                                                            GtkAdjustment   *vadj);
 217 static void gtk_tree_view_real_move_cursor                (GtkTreeView     *tree_view,
 218                                                            GtkMovementStep  step,
 219                                                            gint             count,
 220                                                            gboolean         extend_selection);
 221 static void gtk_tree_view_real_set_anchor                 (GtkTreeView     *tree_view);
 222 static void gtk_tree_view_real_toggle_cursor_row          (GtkTreeView     *tree_view);
 223 static void gtk_tree_view_real_expand_collapse_cursor_row (GtkTreeView     *tree_view,
 224                                                            gboolean         logical,
 225                                                            gboolean         expand,
 226                                                            gboolean         open_all);
 227 static void gtk_tree_view_real_select_cursor_parent       (GtkTreeView     *tree_view);
 228 static void gtk_tree_view_range_changed                   (GtkTreeModel    *model,
 229                                                            GtkTreePath     *path,
 230                                                            GtkTreeIter     *iter,
 231                                                            GtkTreePath     *end_path,
 232                                                            GtkTreeIter     *end_iter,
 233                                                            gpointer         data);
 234 static void gtk_tree_view_inserted                        (GtkTreeModel    *model,
 235                                                            GtkTreePath     *path,
 236                                                            GtkTreeIter     *iter,
 237                                                            gpointer         data);
 238 static void gtk_tree_view_has_child_toggled               (GtkTreeModel    *model,
 239                                                            GtkTreePath     *path,
 240                                                            GtkTreeIter     *iter,
 241                                                            gpointer         data);
 242 static void gtk_tree_view_deleted                         (GtkTreeModel    *model,
 243                                                            GtkTreePath     *path,
 244                                                            gpointer         data);
 245 static void gtk_tree_view_reordered                       (GtkTreeModel    *model,
 246                                                            GtkTreePath     *parent,
 247                                                            GtkTreeIter     *iter,
 248                                                            gint            *new_order,
 249                                                            gpointer         data);
 250
 251
 252
 253
 254 /* Internal functions */
 255
 256 static void     gtk_tree_view_add_move_binding     (GtkBindingSet    *binding_set,
 257                                                     guint             keyval,
 258                                                     guint             modmask,
 259                                                     GtkMovementStep   step,
 260                                                     gint              count);
 261 static void     gtk_tree_view_unref_tree           (GtkTreeView      *tree_view,
 262                                                     GtkRBTree        *tree);
 263 static void     gtk_tree_view_queue_draw_node      (GtkTreeView      *tree_view,
 264                                                     GtkRBTree        *tree,
 265                                                     GtkRBNode        *node,
 266                                                     GdkRectangle     *clip_rect);
 267 static void     gtk_tree_view_queue_draw_path      (GtkTreeView      *tree_view,
 268                                                     GtkTreePath      *path,
 269                                                     GdkRectangle     *clip_rect);
 270 static void     gtk_tree_view_draw_arrow           (GtkTreeView      *tree_view,
 271                                                     GtkRBTree        *tree,
 272                                                     GtkRBNode        *node,
 273                                                     gint              x,
 274                                                     gint              y);
 275 static void     gtk_tree_view_get_arrow_xrange     (GtkTreeView      *tree_view,
 276                                                     gint              *x1,
 277                                                     gint              *x2);
 278 static gint     gtk_tree_view_new_column_width     (GtkTreeView      *tree_view,
 279                                                     gint              i,
 280                                                     gint             *x);
 281 static void     gtk_tree_view_ensure_scroll_timeout(GtkTreeView      *tree_view,
 282                                                     GFunc             func);
 283 static void     gtk_tree_view_adjustment_changed   (GtkAdjustment    *adjustment,
 284                                                     GtkTreeView      *tree_view);
 285 static gint     gtk_tree_view_insert_iter_height   (GtkTreeView      *tree_view,
 286                                                     GtkRBTree        *tree,
 287                                                     GtkTreeIter      *iter,
 288                                                     gint              depth);
 289 static void     gtk_tree_view_build_tree           (GtkTreeView      *tree_view,
 290                                                     GtkRBTree        *tree,
 291                                                     GtkTreeIter      *iter,
 292                                                     gint              depth,
 293                                                     gboolean          recurse,
 294                                                     gboolean          calc_bounds);
 295 static void     gtk_tree_view_calc_size            (GtkTreeView      *priv,
 296                                                     GtkRBTree        *tree,
 297                                                     GtkTreeIter      *iter,
 298                                                     gint              depth);
 299 static gboolean gtk_tree_view_discover_dirty_iter  (GtkTreeView      *tree_view,
 300                                                     GtkTreeIter      *iter,
 301                                                     gint              depth,
 302                                                     gint             *height);
 303 static void     gtk_tree_view_discover_dirty       (GtkTreeView      *tree_view,
 304                                                     GtkRBTree        *tree,
 305                                                     GtkTreeIter      *iter,
 306                                                     gint              depth);
 307 static void     gtk_tree_view_check_dirty          (GtkTreeView      *tree_view);
 308 static void     gtk_tree_view_clamp_node_visible   (GtkTreeView      *tree_view,
 309                                                     GtkRBTree        *tree,
 310                                                     GtkRBNode        *node);
 311 static gboolean gtk_tree_view_maybe_begin_dragging_row (GtkTreeView      *tree_view,
 312                                                         GdkEventMotion   *event);
 313 static void     _gtk_tree_view_update_col_width    (GtkTreeView      *tree_view);
 314
 315
 316 static void gtk_tree_view_set_cursor_focus         (GtkTreeView *tree_view);
 317 static void gtk_tree_view_move_cursor_up_down      (GtkTreeView *tree_view,
 318                                                     gint         count,
 319                                                     gboolean     extend_selection);
 320 static void gtk_tree_view_move_cursor_page_up_down (GtkTreeView *tree_view,
 321                                                     gint         count,
 322                                                     gboolean     extend_selection);
 323 static void gtk_tree_view_move_cursor_left_right   (GtkTreeView *tree_view,
 324                                                     gint         count);
 325 static void gtk_tree_view_move_cursor_start_end    (GtkTreeView *tree_view,
 326                                                     gint         count,
 327                                                     gboolean     extend_selection);
 328 static gboolean gtk_tree_view_real_collapse_row (GtkTreeView *tree_view,
 329                                                  GtkTreePath *path,
 330                                                  GtkRBTree   *tree,
 331                                                  GtkRBNode   *node);
 332 static gboolean gtk_tree_view_real_expand_row (GtkTreeView *tree_view,
 333                                                GtkTreePath *path,
 334                                                GtkRBTree   *tree,
 335                                                GtkRBNode   *node,
 336                                                gboolean     open_all);
 337
 338
 339 static GtkContainerClass *parent_class = NULL;
 340 static guint tree_view_signals[LAST_SIGNAL] = { 0 };
 341
 342 \f
 343
 344 /* GType Methods
 345  */
 346
 347 GtkType
 348 gtk_tree_view_get_type (void)
 349 {
 350   static GtkType tree_view_type = 0;
 351
 352   if (!tree_view_type)
 353     {
 354       static const GTypeInfo tree_view_info =
 355       {
 356         sizeof (GtkTreeViewClass),
 357         NULL,           /* base_init */
 358         NULL,           /* base_finalize */
 359         (GClassInitFunc) gtk_tree_view_class_init,
 360         NULL,           /* class_finalize */
 361         NULL,           /* class_data */
 362         sizeof (GtkTreeView),
 363         0,              /* n_preallocs */
 364         (GInstanceInitFunc) gtk_tree_view_init
 365       };
 366
 367       tree_view_type = g_type_register_static (GTK_TYPE_CONTAINER, "GtkTreeView", &tree_view_info, 0);
 368     }
 369
 370   return tree_view_type;
 371 }
 372
 373 static void
 374 gtk_tree_view_class_init (GtkTreeViewClass *class)
 375 {
 376   GObjectClass *o_class;
 377   GtkObjectClass *object_class;
 378   GtkWidgetClass *widget_class;
 379   GtkContainerClass *container_class;
 380   GtkBindingSet *binding_set;
 381
 382   parent_class = g_type_class_peek_parent (class);
 383   binding_set = gtk_binding_set_by_class (class);
 384
 385   o_class = (GObjectClass *) class;
 386   object_class = (GtkObjectClass *) class;
 387   widget_class = (GtkWidgetClass *) class;
 388   container_class = (GtkContainerClass *) class;
 389
 390   /* GObject signals */
 391   o_class->set_property = gtk_tree_view_set_property;
 392   o_class->get_property = gtk_tree_view_get_property;
 393   o_class->finalize = gtk_tree_view_finalize;
 394
 395   /* GtkObject signals */
 396   object_class->destroy = gtk_tree_view_destroy;
 397
 398   /* GtkWidget signals */
 399   widget_class->map = gtk_tree_view_map;
 400   widget_class->realize = gtk_tree_view_realize;
 401   widget_class->unrealize = gtk_tree_view_unrealize;
 402   widget_class->size_request = gtk_tree_view_size_request;
 403   widget_class->size_allocate = gtk_tree_view_size_allocate;
 404   widget_class->button_press_event = gtk_tree_view_button_press;
 405   widget_class->button_release_event = gtk_tree_view_button_release;
 406   widget_class->motion_notify_event = gtk_tree_view_motion;
 407   widget_class->expose_event = gtk_tree_view_expose;
 408   widget_class->key_press_event = gtk_tree_view_key_press;
 409   widget_class->enter_notify_event = gtk_tree_view_enter_notify;
 410   widget_class->leave_notify_event = gtk_tree_view_leave_notify;
 411   widget_class->focus_in_event = gtk_tree_view_focus_in;
 412   widget_class->focus_out_event = gtk_tree_view_focus_out;
 413   widget_class->drag_begin = gtk_tree_view_drag_begin;
 414   widget_class->drag_end = gtk_tree_view_drag_end;
 415   widget_class->drag_data_get = gtk_tree_view_drag_data_get;
 416   widget_class->drag_data_delete = gtk_tree_view_drag_data_delete;
 417   widget_class->drag_leave = gtk_tree_view_drag_leave;
 418   widget_class->drag_motion = gtk_tree_view_drag_motion;
 419   widget_class->drag_drop = gtk_tree_view_drag_drop;
 420   widget_class->drag_data_received = gtk_tree_view_drag_data_received;
 421
 422   /* GtkContainer signals */
 423   container_class->remove = gtk_tree_view_remove;
 424   container_class->forall = gtk_tree_view_forall;
 425   container_class->focus = gtk_tree_view_focus;
 426   container_class->set_focus_child = gtk_tree_view_set_focus_child;
 427
 428   class->set_scroll_adjustments = gtk_tree_view_set_adjustments;
 429   class->move_cursor = gtk_tree_view_real_move_cursor;
 430   class->set_anchor = gtk_tree_view_real_set_anchor;
 431   class->toggle_cursor_row = gtk_tree_view_real_toggle_cursor_row;
 432   class->expand_collapse_cursor_row = gtk_tree_view_real_expand_collapse_cursor_row;
 433   class->select_cursor_parent = gtk_tree_view_real_select_cursor_parent;
 434
 435   /* Properties */
 436
 437   g_object_class_install_property (o_class,
 438                                    PROP_MODEL,
 439                                    g_param_spec_object ("model",
 440                                                         _("TreeView Model"),
 441                                                         _("The model for the tree view"),
 442                                                         GTK_TYPE_TREE_MODEL,
 443                                                         G_PARAM_READWRITE));
 444
 445   g_object_class_install_property (o_class,
 446                                    PROP_HADJUSTMENT,
 447                                    g_param_spec_object ("hadjustment",
 448                                                         _("Horizontal Adjustment"),
 449                                                         _("Horizontal Adjustment for the widget"),
 450                                                         GTK_TYPE_ADJUSTMENT,
 451                                                         G_PARAM_READWRITE));
 452
 453   g_object_class_install_property (o_class,
 454                                    PROP_VADJUSTMENT,
 455                                    g_param_spec_object ("vadjustment",
 456                                                         _("Vertical Adjustment"),
 457                                                         _("Vertical Adjustment for the widget"),
 458                                                         GTK_TYPE_ADJUSTMENT,
 459                                                         G_PARAM_READWRITE));
 460
 461   g_object_class_install_property (o_class,
 462                                    PROP_HEADERS_VISIBLE,
 463                                    g_param_spec_boolean ("headers_visible",
 464                                                          _("Visible"),
 465                                                          _("Show the column header buttons"),
 466                                                          FALSE,
 467                                                          G_PARAM_READWRITE));
 468
 469   g_object_class_install_property (o_class,
 470                                    PROP_HEADERS_CLICKABLE,
 471                                    g_param_spec_boolean ("headers_clickable",
 472                                                          _("Headers Clickable"),
 473                                                          _("Column headers respond to click events"),
 474                                                          FALSE,
 475                                                          G_PARAM_WRITABLE));
 476
 477   g_object_class_install_property (o_class,
 478                                    PROP_EXPANDER_COLUMN,
 479                                    g_param_spec_uint ("expander_column",
 480                                                       _("Expand Column"),
 481                                                       _("Set the column number for the expander column"),
 482                                                       0,
 483                                                       G_MAXINT,
 484                                                       0,
 485                                                       G_PARAM_READWRITE));
 486
 487   g_object_class_install_property (o_class,
 488                                    PROP_REORDERABLE,
 489                                    g_param_spec_boolean ("reorderable",
 490                                                          _("Reorderable"),
 491                                                          _("View is reorderable"),
 492                                                          FALSE,
 493                                                          G_PARAM_READWRITE));
 494
 495   g_object_class_install_property (o_class,
 496                                    PROP_RULES_HINT,
 497                                    g_param_spec_boolean ("rules_hint",
 498                                                          _("Rules Hint"),
 499                                                          _("Set a hint to the theme engine to draw rows in alternating colors"),
 500                                                          FALSE,
 501                                                          G_PARAM_READWRITE));
 502
 503   /* Style properties */
 504   /* the width of the column resize windows */
 505 #define _TREE_VIEW_EXPANDER_WIDTH 14
 506 #define _TREE_VIEW_EXPANDER_HEIGHT 14
 507 #define _TREE_VIEW_VERTICAL_SEPARATOR 2
 508 #define _TREE_VIEW_HORIZONTAL_SEPARATOR 0
 509
 510   gtk_widget_class_install_style_property (widget_class,
 511                                            g_param_spec_int ("expander_width",
 512                                                              _("Expander Width"),
 513                                                              _("Width of the expander arrow"),
 514                                                              0,
 515                                                              G_MAXINT,
 516                                                              _TREE_VIEW_EXPANDER_WIDTH,
 517                                                              G_PARAM_READABLE));
 518
 519   gtk_widget_class_install_style_property (widget_class,
 520                                            g_param_spec_int ("expander_height",
 521                                                              _("Expander Height"),
 522                                                              _("Height of the expander arrow"),
 523                                                              4,
 524                                                              G_MAXINT,
 525                                                              _TREE_VIEW_EXPANDER_HEIGHT,
 526                                                              G_PARAM_READABLE));
 527
 528     gtk_widget_class_install_style_property (widget_class,
 529                                            g_param_spec_int ("vertical_separator",
 530                                                              _("Vertical Separator Width"),
 531                                                              _("Vertical space between cells"),
 532                                                              0,
 533                                                              G_MAXINT,
 534                                                              _TREE_VIEW_VERTICAL_SEPARATOR,
 535                                                              G_PARAM_READABLE));
 536
 537     gtk_widget_class_install_style_property (widget_class,
 538                                            g_param_spec_int ("horizontal_separator",
 539                                                              _("Horizontal Separator Width"),
 540                                                              _("Horizontal space between cells"),
 541                                                              0,
 542                                                              G_MAXINT,
 543                                                              _TREE_VIEW_HORIZONTAL_SEPARATOR,
 544                                                              G_PARAM_READABLE));
 545
 546   /* Signals */
 547   widget_class->set_scroll_adjustments_signal =
 548     gtk_signal_new ("set_scroll_adjustments",
 549                     GTK_RUN_LAST,
 550                     GTK_CLASS_TYPE (object_class),
 551                     GTK_SIGNAL_OFFSET (GtkTreeViewClass, set_scroll_adjustments),
 552                     gtk_marshal_VOID__OBJECT_OBJECT,
 553                     GTK_TYPE_NONE, 2,
 554                     GTK_TYPE_ADJUSTMENT, GTK_TYPE_ADJUSTMENT);
 555
 556   tree_view_signals[ROW_ACTIVATED] =
 557     gtk_signal_new ("row_activated",
 558                     GTK_RUN_LAST | GTK_RUN_ACTION,
 559                     GTK_CLASS_TYPE (object_class),
 560                     GTK_SIGNAL_OFFSET (GtkTreeViewClass, row_activated),
 561                     gtk_marshal_VOID__BOXED_OBJECT,
 562                     GTK_TYPE_NONE, 2,
 563                     GTK_TYPE_TREE_PATH,
 564                     GTK_TYPE_TREE_VIEW_COLUMN);
 565
 566   tree_view_signals[EXPAND_ROW] =
 567     g_signal_newc ("expand_row",
 568                    G_TYPE_FROM_CLASS (object_class),
 569                    G_SIGNAL_RUN_LAST,
 570                    G_STRUCT_OFFSET (GtkTreeViewClass, expand_row),
 571                    _gtk_boolean_handled_accumulator, NULL,
 572                     gtk_marshal_BOOLEAN__BOXED_BOXED,
 573                    G_TYPE_BOOLEAN, 2,
 574                    GTK_TYPE_TREE_ITER,
 575                    GTK_TYPE_TREE_PATH);
 576
 577   tree_view_signals[COLLAPSE_ROW] =
 578     g_signal_newc ("collapse_row",
 579                    G_TYPE_FROM_CLASS (object_class),
 580                    G_SIGNAL_RUN_LAST,
 581                    G_STRUCT_OFFSET (GtkTreeViewClass, collapse_row),
 582                    _gtk_boolean_handled_accumulator, NULL,
 583                     gtk_marshal_BOOLEAN__BOXED_BOXED,
 584                    G_TYPE_BOOLEAN, 2,
 585                    GTK_TYPE_TREE_ITER,
 586                    GTK_TYPE_TREE_PATH);
 587
 588   tree_view_signals[COLUMNS_CHANGED] =
 589     g_signal_newc ("columns_changed",
 590                    G_TYPE_FROM_CLASS (object_class),
 591                    G_SIGNAL_RUN_LAST,
 592                    G_STRUCT_OFFSET (GtkTreeViewClass, columns_changed),
 593                    NULL, NULL,
 594                    gtk_marshal_NONE__NONE,
 595                    G_TYPE_NONE, 0);
 596
 597   tree_view_signals[MOVE_CURSOR] =
 598     g_signal_newc ("move_cursor",
 599                    G_TYPE_FROM_CLASS (object_class),
 600                    G_SIGNAL_RUN_LAST | GTK_RUN_ACTION,
 601                    G_STRUCT_OFFSET (GtkTreeViewClass, move_cursor),
 602                    NULL, NULL,
 603                    gtk_marshal_VOID__ENUM_INT_BOOLEAN,
 604                    GTK_TYPE_NONE, 3, GTK_TYPE_MOVEMENT_STEP, GTK_TYPE_INT, GTK_TYPE_BOOL);
 605
 606   tree_view_signals[TOGGLE_CURSOR_ROW] =
 607     g_signal_newc ("toggle_cursor_row",
 608                    G_TYPE_FROM_CLASS (object_class),
 609                    G_SIGNAL_RUN_LAST | GTK_RUN_ACTION,
 610                    G_STRUCT_OFFSET (GtkTreeViewClass, toggle_cursor_row),
 611                    NULL, NULL,
 612                    gtk_marshal_NONE__NONE,
 613                    GTK_TYPE_NONE, 0);
 614
 615   tree_view_signals[EXPAND_COLLAPSE_CURSOR_ROW] =
 616     g_signal_newc ("expand_collapse_cursor_row",
 617                    G_TYPE_FROM_CLASS (object_class),
 618                    G_SIGNAL_RUN_LAST | GTK_RUN_ACTION,
 619                    G_STRUCT_OFFSET (GtkTreeViewClass, expand_collapse_cursor_row),
 620                    NULL, NULL,
 621                    gtk_marshal_VOID__BOOLEAN_BOOLEAN_BOOLEAN,
 622                    GTK_TYPE_NONE, 3, GTK_TYPE_BOOL, GTK_TYPE_BOOL, GTK_TYPE_BOOL);
 623
 624   tree_view_signals[SELECT_CURSOR_PARENT] =
 625     g_signal_newc ("select_cursor_parent",
 626                    G_TYPE_FROM_CLASS (object_class),
 627                    G_SIGNAL_RUN_LAST | GTK_RUN_ACTION,
 628                    G_STRUCT_OFFSET (GtkTreeViewClass, select_cursor_parent),
 629                    NULL, NULL,
 630                    gtk_marshal_NONE__NONE,
 631                    GTK_TYPE_NONE, 0);
 632
 633   /* Key bindings */
 634   gtk_tree_view_add_move_binding (binding_set, GDK_Up, 0,
 635                                   GTK_MOVEMENT_DISPLAY_LINES, -1);
 636
 637   gtk_tree_view_add_move_binding (binding_set, GDK_Down, 0,
 638                                   GTK_MOVEMENT_DISPLAY_LINES, 1);
 639
 640   gtk_tree_view_add_move_binding (binding_set, GDK_p, GDK_CONTROL_MASK,
 641                                   GTK_MOVEMENT_DISPLAY_LINES, -1);
 642
 643   gtk_tree_view_add_move_binding (binding_set, GDK_n, GDK_CONTROL_MASK,
 644                                   GTK_MOVEMENT_DISPLAY_LINES, 1);
 645
 646   gtk_tree_view_add_move_binding (binding_set, GDK_Home, 0,
 647                                   GTK_MOVEMENT_BUFFER_ENDS, -1);
 648
 649   gtk_tree_view_add_move_binding (binding_set, GDK_End, 0,
 650                                   GTK_MOVEMENT_BUFFER_ENDS, 1);
 651
 652   gtk_tree_view_add_move_binding (binding_set, GDK_Page_Up, 0,
 653                                   GTK_MOVEMENT_PAGES, -1);
 654
 655   gtk_tree_view_add_move_binding (binding_set, GDK_Page_Down, 0,
 656                                   GTK_MOVEMENT_PAGES, 1);
 657
 658   gtk_binding_entry_add_signal (binding_set, GDK_Right, 0, "move_cursor", 3,
 659                                 GTK_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
 660                                 GTK_TYPE_INT, 1,
 661                                 GTK_TYPE_BOOL, FALSE);
 662
 663   gtk_binding_entry_add_signal (binding_set, GDK_Left, 0, "move_cursor", 3,
 664                                 GTK_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
 665                                 GTK_TYPE_INT, -1,
 666                                 GTK_TYPE_BOOL, FALSE);
 667
 668   gtk_binding_entry_add_signal (binding_set, GDK_f, GDK_CONTROL_MASK, "move_cursor", 3,
 669                                 GTK_TYPE_ENUM, GTK_MOVEMENT_LOGICAL_POSITIONS,
 670                                 GTK_TYPE_INT, 1,
 671                                 GTK_TYPE_BOOL, FALSE);
 672
 673   gtk_binding_entry_add_signal (binding_set, GDK_b, GDK_CONTROL_MASK, "move_cursor", 3,
 674                                 GTK_TYPE_ENUM, GTK_MOVEMENT_LOGICAL_POSITIONS,
 675                                 GTK_TYPE_INT, -1,
 676                                 GTK_TYPE_BOOL, FALSE);
 677
 678   gtk_binding_entry_add_signal (binding_set, GDK_space, GDK_CONTROL_MASK, "toggle_cursor_row", 0);
 679
 680   /* expand and collapse rows */
 681   gtk_binding_entry_add_signal (binding_set, GDK_plus, 0, "expand_collapse_cursor_row", 3,
 682                                 GTK_TYPE_BOOL, FALSE,
 683                                 GTK_TYPE_BOOL, TRUE,
 684                                 GTK_TYPE_BOOL, FALSE);
 685   /* Not doable on US keyboards */
 686   gtk_binding_entry_add_signal (binding_set, GDK_plus, GDK_SHIFT_MASK, "expand_collapse_cursor_row", 3,
 687                                 GTK_TYPE_BOOL, FALSE,
 688                                 GTK_TYPE_BOOL, TRUE,
 689                                 GTK_TYPE_BOOL, TRUE);
 690   gtk_binding_entry_add_signal (binding_set, GDK_KP_Add, 0, "expand_collapse_cursor_row", 3,
 691                                 GTK_TYPE_BOOL, FALSE,
 692                                 GTK_TYPE_BOOL, TRUE,
 693                                 GTK_TYPE_BOOL, FALSE);
 694   gtk_binding_entry_add_signal (binding_set, GDK_KP_Add, GDK_SHIFT_MASK, "expand_collapse_cursor_row", 3,
 695                                 GTK_TYPE_BOOL, FALSE,
 696                                 GTK_TYPE_BOOL, TRUE,
 697                                 GTK_TYPE_BOOL, TRUE);
 698   gtk_binding_entry_add_signal (binding_set, GDK_KP_Add, GDK_SHIFT_MASK, "expand_collapse_cursor_row", 3,
 699                                 GTK_TYPE_BOOL, FALSE,
 700                                 GTK_TYPE_BOOL, TRUE,
 701                                 GTK_TYPE_BOOL, TRUE);
 702   gtk_binding_entry_add_signal (binding_set, GDK_Right, GDK_SHIFT_MASK, "expand_collapse_cursor_row", 3,
 703                                 GTK_TYPE_BOOL, TRUE,
 704                                 GTK_TYPE_BOOL, TRUE,
 705                                 GTK_TYPE_BOOL, TRUE);
 706
 707   gtk_binding_entry_add_signal (binding_set, GDK_minus, 0, "expand_collapse_cursor_row", 3,
 708                                 GTK_TYPE_BOOL, FALSE,
 709                                 GTK_TYPE_BOOL, FALSE,
 710                                 GTK_TYPE_BOOL, FALSE);
 711   gtk_binding_entry_add_signal (binding_set, GDK_minus, GDK_SHIFT_MASK, "expand_collapse_cursor_row", 3,
 712                                 GTK_TYPE_BOOL, FALSE,
 713                                 GTK_TYPE_BOOL, FALSE,
 714                                 GTK_TYPE_BOOL, TRUE);
 715   gtk_binding_entry_add_signal (binding_set, GDK_KP_Subtract, 0, "expand_collapse_cursor_row", 3,
 716                                 GTK_TYPE_BOOL, FALSE,
 717                                 GTK_TYPE_BOOL, FALSE,
 718                                 GTK_TYPE_BOOL, FALSE);
 719   gtk_binding_entry_add_signal (binding_set, GDK_KP_Subtract, GDK_SHIFT_MASK, "expand_collapse_cursor_row", 3,
 720                                 GTK_TYPE_BOOL, FALSE,
 721                                 GTK_TYPE_BOOL, FALSE,
 722                                 GTK_TYPE_BOOL, TRUE);
 723   gtk_binding_entry_add_signal (binding_set, GDK_Left, GDK_SHIFT_MASK, "expand_collapse_cursor_row", 3,
 724                                 GTK_TYPE_BOOL, FALSE,
 725                                 GTK_TYPE_BOOL, FALSE,
 726                                 GTK_TYPE_BOOL, TRUE);
 727
 728   gtk_binding_entry_add_signal (binding_set, GDK_BackSpace, 0, "select_cursor_parent", 0);
 729
 730 }
 731
 732 static void
 733 gtk_tree_view_init (GtkTreeView *tree_view)
 734 {
 735   tree_view->priv = g_new0 (GtkTreeViewPrivate, 1);
 736
 737   GTK_WIDGET_SET_FLAGS (tree_view, GTK_CAN_FOCUS);
 738
 739   tree_view->priv->flags = GTK_TREE_VIEW_IS_LIST | GTK_TREE_VIEW_SHOW_EXPANDERS | GTK_TREE_VIEW_DRAW_KEYFOCUS | GTK_TREE_VIEW_HEADERS_VISIBLE;
 740   gtk_widget_style_get (GTK_WIDGET (tree_view), "expander_width", &tree_view->priv->tab_offset, NULL);
 741   tree_view->priv->n_columns = 0;
 742   tree_view->priv->header_height = 1;
 743   tree_view->priv->x_drag = 0;
 744   tree_view->priv->drag_pos = -1;
 745   tree_view->priv->header_has_focus = FALSE;
 746   tree_view->priv->pressed_button = -1;
 747   tree_view->priv->press_start_x = -1;
 748   tree_view->priv->press_start_y = -1;
 749   tree_view->priv->reorderable = FALSE;
 750   gtk_tree_view_set_adjustments (tree_view, NULL, NULL);
 751   _gtk_tree_view_update_size (tree_view);
 752 }
 753
 754 \f
 755
 756 /* GObject Methods
 757  */
 758
 759 static void
 760 gtk_tree_view_set_property (GObject         *object,
 761                             guint            prop_id,
 762                             const GValue    *value,
 763                             GParamSpec      *pspec)
 764 {
 765   GtkTreeView *tree_view;
 766
 767   tree_view = GTK_TREE_VIEW (object);
 768
 769   switch (prop_id)
 770     {
 771     case PROP_MODEL:
 772       gtk_tree_view_set_model (tree_view, GTK_TREE_MODEL (g_value_get_object (value)));
 773       break;
 774     case PROP_HADJUSTMENT:
 775       gtk_tree_view_set_hadjustment (tree_view, GTK_ADJUSTMENT (g_value_get_object (value)));
 776       break;
 777     case PROP_VADJUSTMENT:
 778       gtk_tree_view_set_vadjustment (tree_view, GTK_ADJUSTMENT (g_value_get_object (value)));
 779       break;
 780     case PROP_HEADERS_VISIBLE:
 781       gtk_tree_view_set_headers_visible (tree_view, g_value_get_boolean (value));
 782       break;
 783     case PROP_HEADERS_CLICKABLE:
 784       gtk_tree_view_set_headers_clickable (tree_view, g_value_get_boolean (value));
 785       break;
 786     case PROP_EXPANDER_COLUMN:
 787       gtk_tree_view_set_expander_column (tree_view, g_value_get_uint (value));
 788       break;
 789     case PROP_REORDERABLE:
 790       gtk_tree_view_set_reorderable (tree_view, g_value_get_boolean (value));
 791       break;
 792     case PROP_RULES_HINT:
 793       gtk_tree_view_set_rules_hint (tree_view, g_value_get_boolean (value));
 794       break;
 795     default:
 796       break;
 797     }
 798 }
 799
 800 static void
 801 gtk_tree_view_get_property (GObject         *object,
 802                             guint            prop_id,
 803                             GValue          *value,
 804                             GParamSpec      *pspec)
 805 {
 806   GtkTreeView *tree_view;
 807
 808   tree_view = GTK_TREE_VIEW (object);
 809
 810   switch (prop_id)
 811     {
 812     case PROP_MODEL:
 813       g_value_set_object (value, G_OBJECT (tree_view->priv->model));
 814       break;
 815     case PROP_HADJUSTMENT:
 816       g_value_set_object (value, G_OBJECT (tree_view->priv->hadjustment));
 817       break;
 818     case PROP_VADJUSTMENT:
 819       g_value_set_object (value, G_OBJECT (tree_view->priv->vadjustment));
 820       break;
 821     case PROP_HEADERS_VISIBLE:
 822       g_value_set_boolean (value, gtk_tree_view_get_headers_visible (tree_view));
 823       break;
 824     case PROP_EXPANDER_COLUMN:
 825       g_value_set_uint (value, tree_view->priv->expander_column);
 826       break;
 827     case PROP_REORDERABLE:
 828       g_value_set_boolean (value, tree_view->priv->reorderable);
 829       break;
 830     case PROP_RULES_HINT:
 831       g_value_set_boolean (value, tree_view->priv->has_rules);
 832       break;
 833     default:
 834       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 835       break;
 836     }
 837 }
 838
 839 static void
 840 gtk_tree_view_finalize (GObject *object)
 841 {
 842   GtkTreeView *tree_view = (GtkTreeView *) object;
 843
 844   g_free (tree_view->priv);
 845
 846   if (G_OBJECT_CLASS (parent_class)->finalize)
 847     (* G_OBJECT_CLASS (parent_class)->finalize) (object);
 848 }
 849
 850 \f
 851
 852 /* GtkObject Methods
 853  */
 854
 855 static void
 856 gtk_tree_view_destroy (GtkObject *object)
 857 {
 858   GtkTreeView *tree_view = (GtkTreeView *) object;
 859   GList *list;
 860
 861
 862   if (tree_view->priv->tree != NULL)
 863     {
 864       gtk_tree_view_unref_tree (tree_view, tree_view->priv->tree);
 865       _gtk_rbtree_free (tree_view->priv->tree);
 866       tree_view->priv->tree = NULL;
 867     }
 868
 869   if (tree_view->priv->model != NULL)
 870     {
 871       g_object_unref (G_OBJECT (tree_view->priv->model));
 872       tree_view->priv->model = NULL;
 873     }
 874
 875   if (tree_view->priv->columns != NULL)
 876     {
 877       for (list = tree_view->priv->columns; list; list = list->next)
 878         g_object_unref (G_OBJECT (list->data));
 879       g_list_free (tree_view->priv->columns);
 880       tree_view->priv->columns = NULL;
 881     }
 882
 883   if (tree_view->priv->selection != NULL)
 884     {
 885       _gtk_tree_selection_set_tree_view (tree_view->priv->selection, NULL);
 886       g_object_unref (tree_view->priv->selection);
 887       tree_view->priv->selection = NULL;
 888     }
 889
 890   if (tree_view->priv->anchor != NULL)
 891     {
 892       gtk_tree_row_reference_free (tree_view->priv->anchor);
 893       tree_view->priv->anchor = NULL;
 894     }
 895
 896   if (tree_view->priv->scroll_to_path != NULL)
 897     {
 898       gtk_tree_path_free (tree_view->priv->scroll_to_path);
 899       tree_view->priv->scroll_to_path = NULL;
 900     }
 901
 902   if (tree_view->priv->drag_dest_row != NULL)
 903     {
 904       gtk_tree_row_reference_free (tree_view->priv->drag_dest_row);
 905       tree_view->priv->drag_dest_row = NULL;
 906     }
 907
 908   if (tree_view->priv->cursor)
 909     {
 910       gtk_tree_row_reference_free (tree_view->priv->cursor);
 911       tree_view->priv->cursor = NULL;
 912     }
 913
 914   if (tree_view->priv->column_drop_func_data &&
 915       tree_view->priv->column_drop_func_data_destroy)
 916     {
 917       (* tree_view->priv->column_drop_func_data_destroy) (tree_view->priv->column_drop_func_data);
 918       tree_view->priv->column_drop_func_data = NULL;
 919     }
 920
 921   if (GTK_OBJECT_CLASS (parent_class)->destroy)
 922     (* GTK_OBJECT_CLASS (parent_class)->destroy) (object);
 923 }
 924
 925 \f
 926
 927 /* GtkWidget Methods
 928  */
 929
 930 /* GtkWidget::map helper */
 931 static void
 932 gtk_tree_view_map_buttons (GtkTreeView *tree_view)
 933 {
 934   GList *list;
 935
 936   g_return_if_fail (GTK_WIDGET_MAPPED (tree_view));
 937
 938   if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_HEADERS_VISIBLE))
 939     {
 940       GtkTreeViewColumn *column;
 941
 942       for (list = tree_view->priv->columns; list; list = list->next)
 943         {
 944           column = list->data;
 945           if (GTK_WIDGET_VISIBLE (column->button) &&
 946               !GTK_WIDGET_MAPPED (column->button))
 947             gtk_widget_map (column->button);
 948         }
 949       for (list = tree_view->priv->columns; list; list = list->next)
 950         {
 951           column = list->data;
 952           if (column->visible == FALSE)
 953             continue;
 954           if (column->column_type == GTK_TREE_VIEW_COLUMN_RESIZEABLE)
 955             {
 956               gdk_window_raise (column->window);
 957               gdk_window_show (column->window);
 958             }
 959           else
 960             gdk_window_hide (column->window);
 961         }
 962       gdk_window_show (tree_view->priv->header_window);
 963     }
 964 }
 965
 966 static void
 967 gtk_tree_view_map (GtkWidget *widget)
 968 {
 969   GList *tmp_list;
 970   GtkTreeView *tree_view;
 971
 972   g_return_if_fail (GTK_IS_TREE_VIEW (widget));
 973
 974   tree_view = GTK_TREE_VIEW (widget);
 975
 976   GTK_WIDGET_SET_FLAGS (widget, GTK_MAPPED);
 977
 978   tmp_list = tree_view->priv->children;
 979   while (tmp_list)
 980     {
 981       GtkTreeViewChild *child = tmp_list->data;
 982       tmp_list = tmp_list->next;
 983
 984       if (GTK_WIDGET_VISIBLE (child->widget))
 985         {
 986           if (!GTK_WIDGET_MAPPED (child->widget))
 987             gtk_widget_map (child->widget);
 988         }
 989     }
 990   gdk_window_show (tree_view->priv->bin_window);
 991
 992   gtk_tree_view_map_buttons (tree_view);
 993
 994   gdk_window_show (widget->window);
 995 }
 996
 997 static void
 998 gtk_tree_view_realize (GtkWidget *widget)
 999 {
1000   GList *tmp_list;
1001   GtkTreeView *tree_view;
1002   GdkGCValues values;
1003   GdkWindowAttr attributes;
1004   gint attributes_mask;
1005
1006   g_return_if_fail (widget != NULL);
1007   g_return_if_fail (GTK_IS_TREE_VIEW (widget));
1008
1009   tree_view = GTK_TREE_VIEW (widget);
1010
1011   gtk_tree_view_check_dirty (GTK_TREE_VIEW (widget));
1012   GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
1013
1014   /* Make the main, clipping window */
1015   attributes.window_type = GDK_WINDOW_CHILD;
1016   attributes.x = widget->allocation.x;
1017   attributes.y = widget->allocation.y;
1018   attributes.width = widget->allocation.width;
1019   attributes.height = widget->allocation.height;
1020   attributes.wclass = GDK_INPUT_OUTPUT;
1021   attributes.visual = gtk_widget_get_visual (widget);
1022   attributes.colormap = gtk_widget_get_colormap (widget);
1023   attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK;
1024
1025   attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
1026
1027   widget->window = gdk_window_new (gtk_widget_get_parent_window (widget),
1028                                    &attributes, attributes_mask);
1029   gdk_window_set_user_data (widget->window, widget);
1030
1031   /* Make the window for the tree */
1032   attributes.x = 0;
1033   attributes.y = 0;
1034   attributes.width = tree_view->priv->width;
1035   attributes.height = tree_view->priv->height + TREE_VIEW_HEADER_HEIGHT (tree_view);
1036   attributes.event_mask = GDK_EXPOSURE_MASK |
1037     GDK_SCROLL_MASK |
1038     GDK_POINTER_MOTION_MASK |
1039     GDK_ENTER_NOTIFY_MASK |
1040     GDK_LEAVE_NOTIFY_MASK |
1041     GDK_BUTTON_PRESS_MASK |
1042     GDK_BUTTON_RELEASE_MASK |
1043     gtk_widget_get_events (widget);
1044
1045   tree_view->priv->bin_window = gdk_window_new (widget->window,
1046                                                 &attributes, attributes_mask);
1047   gdk_window_set_user_data (tree_view->priv->bin_window, widget);
1048
1049   /* Make the column header window */
1050   attributes.x = 0;
1051   attributes.y = 0;
1052   attributes.width = MAX (tree_view->priv->width, widget->allocation.width);
1053   attributes.height = tree_view->priv->header_height;
1054   attributes.event_mask = (GDK_EXPOSURE_MASK |
1055                            GDK_SCROLL_MASK |
1056                            GDK_BUTTON_PRESS_MASK |
1057                            GDK_BUTTON_RELEASE_MASK |
1058                            GDK_KEY_PRESS_MASK |
1059                            GDK_KEY_RELEASE_MASK) |
1060     gtk_widget_get_events (widget);
1061
1062   tree_view->priv->header_window = gdk_window_new (widget->window,
1063                                                    &attributes, attributes_mask);
1064   gdk_window_set_user_data (tree_view->priv->header_window, widget);
1065
1066
1067   values.foreground = (widget->style->white.pixel==0 ?
1068                        widget->style->black:widget->style->white);
1069   values.function = GDK_XOR;
1070   values.subwindow_mode = GDK_INCLUDE_INFERIORS;
1071   tree_view->priv->xor_gc = gdk_gc_new_with_values (widget->window,
1072                                                     &values,
1073                                                     GDK_GC_FOREGROUND |
1074                                                     GDK_GC_FUNCTION |
1075                                                     GDK_GC_SUBWINDOW);
1076   /* Add them all up. */
1077   widget->style = gtk_style_attach (widget->style, widget->window);
1078   gdk_window_set_background (widget->window, &widget->style->base[widget->state]);
1079   gdk_window_set_background (tree_view->priv->bin_window, &widget->style->base[widget->state]);
1080   gtk_style_set_background (widget->style, tree_view->priv->header_window, GTK_STATE_NORMAL);
1081
1082   tmp_list = tree_view->priv->children;
1083   while (tmp_list)
1084     {
1085       GtkTreeViewChild *child = tmp_list->data;
1086       tmp_list = tmp_list->next;
1087
1088       gtk_widget_set_parent_window (child->widget, tree_view->priv->bin_window);
1089     }
1090
1091   for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list = tmp_list->next)
1092     _gtk_tree_view_column_realize_button (GTK_TREE_VIEW_COLUMN (tmp_list->data));
1093
1094   _gtk_tree_view_update_size (GTK_TREE_VIEW (widget));
1095
1096   if (tree_view->priv->scroll_to_path != NULL ||
1097       tree_view->priv->scroll_to_column != NULL)
1098     {
1099       gtk_tree_view_scroll_to_cell (tree_view,
1100                                     tree_view->priv->scroll_to_path,
1101                                     tree_view->priv->scroll_to_column,
1102                                     tree_view->priv->scroll_to_row_align,
1103                                     tree_view->priv->scroll_to_col_align);
1104       if (tree_view->priv->scroll_to_path)
1105         {
1106           gtk_tree_path_free (tree_view->priv->scroll_to_path);
1107           tree_view->priv->scroll_to_path = NULL;
1108         }
1109       tree_view->priv->scroll_to_column = NULL;
1110     }
1111 }
1112
1113 static void
1114 gtk_tree_view_unrealize (GtkWidget *widget)
1115 {
1116   GtkTreeView *tree_view;
1117   GList *list;
1118
1119   g_return_if_fail (GTK_IS_TREE_VIEW (widget));
1120
1121   tree_view = GTK_TREE_VIEW (widget);
1122
1123   if (tree_view->priv->scroll_timeout != 0)
1124     {
1125       gtk_timeout_remove (tree_view->priv->scroll_timeout);
1126       tree_view->priv->scroll_timeout = 0;
1127     }
1128
1129   if (tree_view->priv->open_dest_timeout != 0)
1130     {
1131       gtk_timeout_remove (tree_view->priv->open_dest_timeout);
1132       tree_view->priv->open_dest_timeout = 0;
1133     }
1134
1135   for (list = tree_view->priv->columns; list; list = list->next)
1136     _gtk_tree_view_column_unrealize_button (GTK_TREE_VIEW_COLUMN (list->data));
1137
1138   gdk_window_set_user_data (tree_view->priv->bin_window, NULL);
1139   gdk_window_destroy (tree_view->priv->bin_window);
1140   tree_view->priv->bin_window = NULL;
1141
1142   gdk_window_set_user_data (tree_view->priv->header_window, NULL);
1143   gdk_window_destroy (tree_view->priv->header_window);
1144   tree_view->priv->header_window = NULL;
1145
1146   if (tree_view->priv->drag_window)
1147     {
1148       gdk_window_set_user_data (tree_view->priv->drag_window, NULL);
1149       gdk_window_destroy (tree_view->priv->drag_window);
1150       tree_view->priv->drag_window = NULL;
1151     }
1152
1153   if (tree_view->priv->drag_highlight_window)
1154     {
1155       gdk_window_set_user_data (tree_view->priv->drag_highlight_window, NULL);
1156       gdk_window_destroy (tree_view->priv->drag_highlight_window);
1157       tree_view->priv->drag_highlight_window = NULL;
1158     }
1159
1160   if (tree_view->priv->cursor_drag)
1161     {
1162       gdk_cursor_destroy (tree_view->priv->cursor_drag);
1163       tree_view->priv->cursor_drag = NULL;
1164     }
1165
1166   if (tree_view->priv->xor_gc)
1167     {
1168       gdk_gc_destroy (tree_view->priv->xor_gc);
1169       tree_view->priv->xor_gc = NULL;
1170     }
1171
1172   /* GtkWidget::unrealize destroys children and widget->window */
1173   if (GTK_WIDGET_CLASS (parent_class)->unrealize)
1174     (* GTK_WIDGET_CLASS (parent_class)->unrealize) (widget);
1175 }
1176
1177 /* GtkWidget::size_request helper */
1178 static void
1179 gtk_tree_view_size_request_buttons (GtkTreeView *tree_view)
1180 {
1181   GList *list;
1182
1183   tree_view->priv->header_height = 1;
1184
1185   if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_MODEL_SETUP))
1186     {
1187       for (list = tree_view->priv->columns; list; list = list->next)
1188         {
1189           GtkRequisition requisition;
1190           GtkTreeViewColumn *column = list->data;
1191
1192           if (column->button == NULL)
1193             continue;
1194
1195           column = list->data;
1196
1197           gtk_widget_size_request (column->button, &requisition);
1198
1199           _gtk_tree_view_column_set_width (column, MAX (column->width, requisition.width));
1200           tree_view->priv->header_height = MAX (tree_view->priv->header_height, requisition.height);
1201         }
1202     }
1203 }
1204
1205 static void
1206 gtk_tree_view_size_request (GtkWidget      *widget,
1207                             GtkRequisition *requisition)
1208 {
1209   GtkTreeView *tree_view;
1210   GList *tmp_list;
1211
1212   g_return_if_fail (GTK_IS_TREE_VIEW (widget));
1213
1214   tree_view = GTK_TREE_VIEW (widget);
1215
1216   requisition->width = tree_view->priv->width;
1217   requisition->height = tree_view->priv->height + tree_view->priv->header_height;
1218
1219   tmp_list = tree_view->priv->children;
1220
1221   while (tmp_list)
1222     {
1223       GtkTreeViewChild *child = tmp_list->data;
1224       GtkRequisition child_requisition;
1225
1226       tmp_list = tmp_list->next;
1227
1228       if (GTK_WIDGET_VISIBLE (child->widget))
1229         gtk_widget_size_request (child->widget, &child_requisition);
1230     }
1231
1232   gtk_tree_view_size_request_buttons (tree_view);
1233 }
1234
1235 /* GtkWidget::size_allocate helper */
1236 static void
1237 gtk_tree_view_size_allocate_buttons (GtkWidget *widget)
1238 {
1239   GtkTreeView *tree_view;
1240   GList *list;
1241   GtkTreeViewColumn *column;
1242   GtkAllocation allocation;
1243   gint width = 0;
1244
1245   tree_view = GTK_TREE_VIEW (widget);
1246
1247   allocation.y = 0;
1248   allocation.height = tree_view->priv->header_height;
1249
1250   for (list = tree_view->priv->columns; list != NULL; list = list->next)
1251     {
1252       column = list->data;
1253
1254       if (!column->visible)
1255         continue;
1256
1257       allocation.x = width;
1258       allocation.width = column->displayed_width;
1259       width += column->width;
1260       gtk_widget_size_allocate (column->button, &allocation);
1261
1262       if (column->window)
1263         gdk_window_move_resize (column->window,
1264                                 allocation.x + allocation.width - TREE_VIEW_DRAG_WIDTH/2,
1265                                 allocation.y,
1266                                 TREE_VIEW_DRAG_WIDTH, allocation.height);
1267     }
1268 }
1269
1270 static void
1271 gtk_tree_view_size_allocate (GtkWidget     *widget,
1272                              GtkAllocation *allocation)
1273 {
1274   GList *tmp_list;
1275   GtkTreeView *tree_view;
1276
1277   g_return_if_fail (GTK_IS_TREE_VIEW (widget));
1278
1279   widget->allocation = *allocation;
1280
1281   tree_view = GTK_TREE_VIEW (widget);
1282
1283   gtk_tree_view_check_dirty (tree_view);
1284
1285   tmp_list = tree_view->priv->children;
1286
1287   while (tmp_list)
1288     {
1289       GtkAllocation allocation;
1290       GtkRequisition requisition;
1291
1292       GtkTreeViewChild *child = tmp_list->data;
1293       tmp_list = tmp_list->next;
1294
1295       allocation.x = child->x;
1296       allocation.y = child->y;
1297       gtk_widget_get_child_requisition (child->widget, &requisition);
1298       allocation.width = requisition.width;
1299       allocation.height = requisition.height;
1300
1301       gtk_widget_size_allocate (child->widget, &allocation);
1302     }
1303
1304   if (GTK_WIDGET_REALIZED (widget))
1305     {
1306       gdk_window_move_resize (widget->window,
1307                               allocation->x, allocation->y,
1308                               allocation->width, allocation->height);
1309       gdk_window_resize (tree_view->priv->header_window,
1310                          MAX (tree_view->priv->width, allocation->width),
1311                          tree_view->priv->header_height);
1312       if (tree_view->priv->width < allocation->width)
1313           gdk_window_resize (tree_view->priv->bin_window,
1314                              allocation->width,
1315                              tree_view->priv->height + TREE_VIEW_HEADER_HEIGHT (tree_view));
1316
1317       _gtk_tree_view_update_col_width (tree_view);
1318     }
1319
1320   gtk_tree_view_size_allocate_buttons (widget);
1321
1322   tree_view->priv->hadjustment->page_size = allocation->width;
1323   tree_view->priv->hadjustment->page_increment = allocation->width;
1324   tree_view->priv->hadjustment->step_increment = allocation->width / 10;
1325   tree_view->priv->hadjustment->lower = 0;
1326   tree_view->priv->hadjustment->upper = tree_view->priv->width;
1327
1328   if (tree_view->priv->hadjustment->value + allocation->width > tree_view->priv->width)
1329     tree_view->priv->hadjustment->value = MAX (tree_view->priv->width - allocation->width, 0);
1330   gtk_signal_emit_by_name (GTK_OBJECT (tree_view->priv->hadjustment), "changed");
1331
1332   tree_view->priv->vadjustment->page_size = allocation->height - TREE_VIEW_HEADER_HEIGHT (tree_view);
1333   tree_view->priv->vadjustment->step_increment = (tree_view->priv->vadjustment->page_size) / 10;
1334   tree_view->priv->vadjustment->page_increment = (allocation->height - TREE_VIEW_HEADER_HEIGHT (tree_view)) / 2;
1335   tree_view->priv->vadjustment->lower = 0;
1336   tree_view->priv->vadjustment->upper = tree_view->priv->height;
1337
1338   if (tree_view->priv->vadjustment->value + allocation->height > tree_view->priv->height)
1339     gtk_adjustment_set_value (tree_view->priv->vadjustment,
1340                               MAX (tree_view->priv->height - allocation->height, 0));
1341
1342   gtk_signal_emit_by_name (GTK_OBJECT (tree_view->priv->vadjustment), "changed");
1343
1344 }
1345
1346 static gboolean
1347 gtk_tree_view_button_press (GtkWidget      *widget,
1348                             GdkEventButton *event)
1349 {
1350   GtkTreeView *tree_view;
1351   GList *list;
1352   GtkTreeViewColumn *column = NULL;
1353   gint i;
1354   GdkRectangle background_area;
1355   GdkRectangle cell_area;
1356   gint vertical_separator;
1357
1358   g_return_val_if_fail (GTK_IS_TREE_VIEW (widget), FALSE);
1359   g_return_val_if_fail (event != NULL, FALSE);
1360
1361   tree_view = GTK_TREE_VIEW (widget);
1362   gtk_widget_style_get (widget, "vertical_separator", &vertical_separator, NULL);
1363
1364   if (event->window == tree_view->priv->bin_window)
1365     {
1366       GtkRBNode *node;
1367       GtkRBTree *tree;
1368       GtkTreePath *path;
1369       gchar *path_string;
1370       gint depth;
1371       gint new_y;
1372       gint y_offset;
1373       GtkTreeViewColumn *column = NULL;
1374
1375       if (!GTK_WIDGET_HAS_FOCUS (widget))
1376         gtk_widget_grab_focus (widget);
1377       GTK_TREE_VIEW_UNSET_FLAG (tree_view, GTK_TREE_VIEW_DRAW_KEYFOCUS);
1378
1379       /* are we in an arrow? */
1380       if (tree_view->priv->prelight_node &&
1381           GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_ARROW_PRELIT))
1382         {
1383           if (event->button == 1)
1384             {
1385               gtk_grab_add (widget);
1386               tree_view->priv->button_pressed_node = tree_view->priv->prelight_node;
1387               tree_view->priv->button_pressed_tree = tree_view->priv->prelight_tree;
1388               gtk_tree_view_draw_arrow (GTK_TREE_VIEW (widget),
1389                                         tree_view->priv->prelight_tree,
1390                                         tree_view->priv->prelight_node,
1391                                         event->x,
1392                                         event->y);
1393             }
1394           return TRUE;
1395         }
1396
1397       /* find the node that was clicked */
1398       new_y = ((gint)event->y<TREE_VIEW_HEADER_HEIGHT (tree_view))?TREE_VIEW_HEADER_HEIGHT (tree_view):(gint)event->y;
1399       y_offset = -_gtk_rbtree_find_offset (tree_view->priv->tree,
1400                                            TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, new_y),
1401                                            &tree,
1402                                            &node) + new_y - (gint)event->y;
1403
1404       if (node == NULL)
1405         /* We clicked in dead space */
1406         return TRUE;
1407
1408       /* Get the path and the node */
1409       path = _gtk_tree_view_find_path (tree_view, tree, node);
1410       depth = gtk_tree_path_get_depth (path);
1411       background_area.y = y_offset + event->y + vertical_separator;
1412       background_area.height = GTK_RBNODE_GET_HEIGHT (node) - vertical_separator;
1413       background_area.x = 0;
1414       /* Let the cell have a chance at selecting it. */
1415
1416       for (i = 0, list = tree_view->priv->columns; i < tree_view->priv->n_columns; i++, list = list->next)
1417         {
1418           GtkTreeIter iter;
1419
1420           column = list->data;
1421
1422           if (!column->visible)
1423             continue;
1424
1425           background_area.width = column->displayed_width;
1426           if (i == tree_view->priv->expander_column &&
1427               TREE_VIEW_DRAW_EXPANDERS(tree_view))
1428             {
1429               cell_area = background_area;
1430               cell_area.x += depth*tree_view->priv->tab_offset;
1431               cell_area.width -= depth*tree_view->priv->tab_offset;
1432             }
1433           else
1434             {
1435               cell_area = background_area;
1436             }
1437
1438           if ((background_area.x > (gint) event->x) ||
1439               (background_area.y > (gint) event->y) ||
1440               (background_area.x + background_area.width <= (gint) event->x) ||
1441               (background_area.y + background_area.height <= (gint) event->y))
1442             {
1443               background_area.x += background_area.width;
1444               continue;
1445             }
1446
1447           gtk_tree_model_get_iter (tree_view->priv->model,
1448                                    &iter,
1449                                    path);
1450           gtk_tree_view_column_cell_set_cell_data (column,
1451                                                    tree_view->priv->model,
1452                                                    &iter);
1453
1454           path_string = gtk_tree_path_to_string (path);
1455
1456           if (gtk_tree_view_column_cell_event (column,
1457                                                (GdkEvent *)event,
1458                                                path_string,
1459                                                &background_area,
1460                                                &cell_area, 0))
1461             {
1462               g_free (path_string);
1463               gtk_tree_path_free (path);
1464               return TRUE;
1465             }
1466           else
1467             {
1468               g_free (path_string);
1469               break;
1470             }
1471         }
1472
1473       if (column == NULL)
1474         return FALSE;
1475
1476       /* Save press to possibly begin a drag
1477        */
1478       if (tree_view->priv->pressed_button < 0)
1479         {
1480           tree_view->priv->pressed_button = event->button;
1481           tree_view->priv->press_start_x = event->x;
1482           tree_view->priv->press_start_y = event->y;
1483         }
1484
1485       /* Handle the selection */
1486       if (tree_view->priv->selection == NULL)
1487         tree_view->priv->selection =
1488           _gtk_tree_selection_new_with_tree_view (tree_view);
1489
1490       _gtk_tree_selection_internal_select_node (tree_view->priv->selection,
1491                                                 node,
1492                                                 tree,
1493                                                 path,
1494                                                 event->state);
1495
1496       if (event->button == 1 && event->type == GDK_2BUTTON_PRESS)
1497           gtk_tree_view_row_activated (tree_view, path, column);
1498
1499       gtk_tree_path_free (path);
1500       return TRUE;
1501     }
1502
1503   for (i = 0, list = tree_view->priv->columns; list; list = list->next, i++)
1504     {
1505       column = list->data;
1506       if (event->window == column->window &&
1507           column->column_type == GTK_TREE_VIEW_COLUMN_RESIZEABLE &&
1508           column->window)
1509         {
1510           gpointer drag_data;
1511
1512           if (gdk_pointer_grab (column->window, FALSE,
1513                                 GDK_POINTER_MOTION_HINT_MASK |
1514                                 GDK_BUTTON1_MOTION_MASK |
1515                                 GDK_BUTTON_RELEASE_MASK,
1516                                 NULL, NULL, event->time))
1517             return FALSE;
1518
1519           gtk_grab_add (widget);
1520           GTK_TREE_VIEW_SET_FLAG (tree_view, GTK_TREE_VIEW_IN_COLUMN_RESIZE);
1521
1522           /* block attached dnd signal handler */
1523           drag_data = gtk_object_get_data (GTK_OBJECT (widget), "gtk-site-data");
1524           if (drag_data)
1525             gtk_signal_handler_block_by_data (GTK_OBJECT (widget), drag_data);
1526
1527           if (!GTK_WIDGET_HAS_FOCUS (widget))
1528             gtk_widget_grab_focus (widget);
1529
1530           tree_view->priv->drag_pos = i;
1531           tree_view->priv->x_drag = (column->button->allocation.x + column->button->allocation.width);
1532         }
1533     }
1534   return TRUE;
1535 }
1536
1537 /* GtkWidget::button_release_event helper */
1538 static gboolean
1539 gtk_tree_view_button_release_drag_column (GtkWidget      *widget,
1540                                           GdkEventButton *event)
1541 {
1542   GtkTreeView *tree_view;
1543   GtkAllocation allocation;
1544
1545   tree_view = GTK_TREE_VIEW (widget);
1546
1547   allocation = tree_view->priv->drag_column->button->allocation;
1548   allocation.x = tree_view->priv->drag_column_x;
1549   gdk_pointer_ungrab (GDK_CURRENT_TIME);
1550   gdk_keyboard_ungrab (GDK_CURRENT_TIME);
1551   gdk_window_reparent (tree_view->priv->drag_column->button->window,
1552                        tree_view->priv->header_window,
1553                        tree_view->priv->drag_column_x,
1554                        tree_view->priv->drag_column->button->allocation.y);
1555   gtk_widget_set_parent_window (tree_view->priv->drag_column->button, tree_view->priv->header_window);
1556
1557   gtk_widget_size_allocate (tree_view->priv->drag_column->button, &allocation);
1558   gtk_widget_grab_focus (tree_view->priv->drag_column->button);
1559
1560   if (tree_view->priv->cur_reorder &&
1561       tree_view->priv->cur_reorder->left_column != tree_view->priv->drag_column)
1562     gtk_tree_view_move_column_after (tree_view, tree_view->priv->drag_column,
1563                                      tree_view->priv->cur_reorder->left_column);
1564   tree_view->priv->drag_column = NULL;
1565   gdk_window_hide (tree_view->priv->drag_window);
1566
1567   g_list_foreach (tree_view->priv->column_drag_info, (GFunc) g_free, NULL);
1568   g_list_free (tree_view->priv->column_drag_info);
1569   tree_view->priv->column_drag_info = NULL;
1570
1571   gdk_window_hide (tree_view->priv->drag_highlight_window);
1572
1573   /* Reset our flags */
1574   tree_view->priv->drag_column_window_state = DRAG_COLUMN_WINDOW_STATE_UNSET;
1575   GTK_TREE_VIEW_UNSET_FLAG (tree_view, GTK_TREE_VIEW_IN_COLUMN_DRAG);
1576
1577   return TRUE;
1578 }
1579
1580 /* GtkWidget::button_release_event helper */
1581 static gboolean
1582 gtk_tree_view_button_release_column_resize (GtkWidget      *widget,
1583                                             GdkEventButton *event)
1584 {
1585   GtkTreeView *tree_view;
1586   gpointer drag_data;
1587   gint width;
1588   gint x;
1589   gint i;
1590
1591   tree_view = GTK_TREE_VIEW (widget);
1592
1593   i = tree_view->priv->drag_pos;
1594   tree_view->priv->drag_pos = -1;
1595
1596       /* unblock attached dnd signal handler */
1597   drag_data = gtk_object_get_data (GTK_OBJECT (widget), "gtk-site-data");
1598   if (drag_data)
1599     gtk_signal_handler_unblock_by_data (GTK_OBJECT (widget), drag_data);
1600
1601   GTK_TREE_VIEW_UNSET_FLAG (tree_view, GTK_TREE_VIEW_IN_COLUMN_RESIZE);
1602   gtk_widget_get_pointer (widget, &x, NULL);
1603   gtk_grab_remove (widget);
1604   gdk_pointer_ungrab (event->time);
1605
1606   width = gtk_tree_view_new_column_width (GTK_TREE_VIEW (widget), i, &x);
1607   _gtk_tree_view_column_set_width (gtk_tree_view_get_column (GTK_TREE_VIEW (widget), i), width);
1608
1609   return TRUE;
1610 }
1611
1612 static gboolean
1613 gtk_tree_view_button_release (GtkWidget      *widget,
1614                               GdkEventButton *event)
1615 {
1616   GtkTreeView *tree_view;
1617
1618   g_return_val_if_fail (GTK_IS_TREE_VIEW (widget), FALSE);
1619   g_return_val_if_fail (event != NULL, FALSE);
1620
1621   tree_view = GTK_TREE_VIEW (widget);
1622
1623   if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_IN_COLUMN_DRAG))
1624     return gtk_tree_view_button_release_drag_column (widget, event);
1625
1626   if (tree_view->priv->pressed_button == event->button)
1627     tree_view->priv->pressed_button = -1;
1628
1629   if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_IN_COLUMN_RESIZE))
1630     return gtk_tree_view_button_release_column_resize (widget, event);
1631
1632   if (tree_view->priv->button_pressed_node == NULL)
1633     return FALSE;
1634
1635   if (event->button == 1)
1636     {
1637       gtk_grab_remove (widget);
1638       if (tree_view->priv->button_pressed_node == tree_view->priv->prelight_node &&
1639           GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_ARROW_PRELIT))
1640         {
1641           GtkTreePath *path = NULL;
1642
1643           path = _gtk_tree_view_find_path (tree_view,
1644                                            tree_view->priv->button_pressed_tree,
1645                                            tree_view->priv->button_pressed_node);
1646           /* Actually activate the node */
1647           if (tree_view->priv->button_pressed_node->children == NULL)
1648             gtk_tree_view_real_expand_row (tree_view, path,
1649                                            tree_view->priv->button_pressed_tree,
1650                                            tree_view->priv->button_pressed_node,
1651                                            FALSE);
1652           else
1653             gtk_tree_view_real_collapse_row (GTK_TREE_VIEW (widget), path,
1654                                              tree_view->priv->button_pressed_tree,
1655                                              tree_view->priv->button_pressed_node);
1656           gtk_tree_path_free (path);
1657         }
1658
1659       tree_view->priv->button_pressed_tree = NULL;
1660       tree_view->priv->button_pressed_node = NULL;
1661     }
1662
1663   return TRUE;
1664 }
1665
1666
1667 /* GtkWidget::motion_event function set.
1668  */
1669
1670 static gboolean
1671 coords_are_over_arrow (GtkTreeView *tree_view,
1672                        GtkRBTree   *tree,
1673                        GtkRBNode   *node,
1674                        /* these are in tree window coords */
1675                        gint         x,
1676                        gint         y)
1677 {
1678   GdkRectangle arrow;
1679   gint x2;
1680
1681   if (!GTK_WIDGET_REALIZED (tree_view))
1682     return FALSE;
1683
1684   if ((node->flags & GTK_RBNODE_IS_PARENT) == 0)
1685     return FALSE;
1686
1687   arrow.y = BACKGROUND_FIRST_PIXEL (tree_view, tree, node);
1688
1689   arrow.height = BACKGROUND_HEIGHT (node);
1690
1691   gtk_tree_view_get_arrow_xrange (tree_view, &arrow.x, &x2);
1692
1693   arrow.width = x2 - arrow.x;
1694
1695   return (x >= arrow.x &&
1696           x < (arrow.x + arrow.height) &&
1697           y >= arrow.y &&
1698           y < (arrow.y + arrow.height));
1699 }
1700
1701 static void
1702 do_unprelight (GtkTreeView *tree_view,
1703                /* these are in tree window coords */
1704                gint x,
1705                gint y)
1706 {
1707   if (tree_view->priv->prelight_node == NULL)
1708     return;
1709
1710   GTK_RBNODE_UNSET_FLAG (tree_view->priv->prelight_node, GTK_RBNODE_IS_PRELIT);
1711
1712   if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_ARROW_PRELIT) &&
1713       !coords_are_over_arrow (tree_view,
1714                               tree_view->priv->prelight_tree,
1715                               tree_view->priv->prelight_node,
1716                               x,
1717                               y))
1718     /* We need to unprelight the old arrow. */
1719     {
1720       GTK_TREE_VIEW_UNSET_FLAG (tree_view, GTK_TREE_VIEW_ARROW_PRELIT);
1721
1722       gtk_tree_view_draw_arrow (tree_view,
1723                                 tree_view->priv->prelight_tree,
1724                                 tree_view->priv->prelight_node,
1725                                 x,
1726                                 y);
1727
1728     }
1729
1730   tree_view->priv->prelight_node = NULL;
1731   tree_view->priv->prelight_tree = NULL;
1732 }
1733
1734 static void
1735 do_prelight (GtkTreeView *tree_view,
1736              GtkRBTree   *tree,
1737              GtkRBNode   *node,
1738              /* these are in tree window coords */
1739              gint         x,
1740              gint         y)
1741 {
1742   if (coords_are_over_arrow (tree_view, tree, node, x, y))
1743     GTK_TREE_VIEW_SET_FLAG (tree_view, GTK_TREE_VIEW_ARROW_PRELIT);
1744
1745   tree_view->priv->prelight_node = node;
1746   tree_view->priv->prelight_tree = tree;
1747
1748   GTK_RBNODE_SET_FLAG (node, GTK_RBNODE_IS_PRELIT);
1749 }
1750
1751 static void
1752 ensure_unprelighted (GtkTreeView *tree_view)
1753 {
1754   do_unprelight (tree_view, -1000, -1000); /* coords not possibly over an arrow */
1755 }
1756
1757
1758
1759 /* Our motion arrow is either a box (in the case of the original spot)
1760  * or an arrow.  It is expander_width wide.
1761  */
1762 /*
1763  * 11111111111111
1764  * 01111111111110
1765  * 00111111111100
1766  * 00011111111000
1767  * 00001111110000
1768  * 00000111100000
1769  * 00000111100000
1770  * 00000111100000
1771  * ~ ~ ~ ~ ~ ~ ~
1772  * 00000111100000
1773  * 00000111100000
1774  * 00000111100000
1775  * 00001111110000
1776  * 00011111111000
1777  * 00111111111100
1778  * 01111111111110
1779  * 11111111111111
1780  */
1781
1782 static void
1783 gtk_tree_view_motion_draw_column_motion_arrow (GtkTreeView *tree_view)
1784 {
1785   GtkTreeViewColumnReorder *reorder = tree_view->priv->cur_reorder;
1786   GtkWidget *widget = GTK_WIDGET (tree_view);
1787   GdkBitmap *mask = NULL;
1788   gint x;
1789   gint y;
1790   gint width;
1791   gint height;
1792   gint arrow_type = DRAG_COLUMN_WINDOW_STATE_UNSET;
1793   GdkWindowAttr attributes;
1794   guint attributes_mask;
1795
1796   if (!reorder ||
1797       reorder->left_column == tree_view->priv->drag_column ||
1798       reorder->right_column == tree_view->priv->drag_column)
1799     arrow_type = DRAG_COLUMN_WINDOW_STATE_ORIGINAL;
1800   else if (reorder->left_column || reorder->right_column)
1801     {
1802       GdkRectangle visible_rect;
1803       gtk_tree_view_get_visible_rect (tree_view, &visible_rect);
1804       if (reorder->left_column)
1805         x = reorder->left_column->button->allocation.x + reorder->left_column->button->allocation.width;
1806       else
1807         x = reorder->right_column->button->allocation.x;
1808       if (x < visible_rect.x)
1809         arrow_type = DRAG_COLUMN_WINDOW_STATE_ARROW_LEFT;
1810       else if (x > visible_rect.x + visible_rect.width)
1811         arrow_type = DRAG_COLUMN_WINDOW_STATE_ARROW_RIGHT;
1812       else
1813         arrow_type = DRAG_COLUMN_WINDOW_STATE_ARROW;
1814     }
1815
1816   /* We want to draw the rectangle over the initial location. */
1817   if (arrow_type == DRAG_COLUMN_WINDOW_STATE_ORIGINAL)
1818     {
1819       GdkGC *gc;
1820       GdkColor col;
1821
1822       if (tree_view->priv->drag_column_window_state != DRAG_COLUMN_WINDOW_STATE_ORIGINAL)
1823         {
1824
1825           if (tree_view->priv->drag_highlight_window)
1826             gdk_window_destroy (tree_view->priv->drag_highlight_window);
1827
1828           attributes.window_type = GDK_WINDOW_CHILD;
1829           attributes.wclass = GDK_INPUT_OUTPUT;
1830           attributes.visual = gtk_widget_get_visual (GTK_WIDGET (tree_view));
1831           attributes.colormap = gtk_widget_get_colormap (GTK_WIDGET (tree_view));
1832           attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK;
1833           attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
1834           tree_view->priv->drag_highlight_window = gdk_window_new (tree_view->priv->header_window, &attributes, attributes_mask);
1835           gdk_window_set_user_data (tree_view->priv->drag_highlight_window, GTK_WIDGET (tree_view));
1836
1837           width = tree_view->priv->drag_column->button->allocation.width;
1838           height = tree_view->priv->drag_column->button->allocation.height;
1839           gdk_window_move_resize (tree_view->priv->drag_highlight_window,
1840                                   tree_view->priv->drag_column_x, 0, width, height);
1841
1842           mask = gdk_pixmap_new (tree_view->priv->drag_highlight_window, width, height, 1);
1843           gc = gdk_gc_new (mask);
1844           col.pixel = 1;
1845           gdk_gc_set_foreground (gc, &col);
1846           gdk_draw_rectangle (mask, gc, TRUE, 0, 0, width, height);
1847           col.pixel = 0;
1848           gdk_gc_set_foreground(gc, &col);
1849           gdk_draw_rectangle (mask, gc, TRUE, 2, 2, width - 4, height - 4);
1850           gdk_gc_destroy (gc);
1851
1852           gdk_window_shape_combine_mask (tree_view->priv->drag_highlight_window,
1853                                          mask, 0, 0);
1854           if (mask) gdk_pixmap_unref (mask);
1855           tree_view->priv->drag_column_window_state = DRAG_COLUMN_WINDOW_STATE_ORIGINAL;
1856         }
1857     }
1858   else if (arrow_type == DRAG_COLUMN_WINDOW_STATE_ARROW)
1859     {
1860       gint i, j = 1;
1861       GdkGC *gc;
1862       GdkColor col;
1863       gint expander_width;
1864
1865       gtk_widget_style_get (widget,
1866                             "expander_height", &width,
1867                             "expander_width", &expander_width,
1868                             NULL);
1869
1870       /* Get x, y, width, height of arrow */
1871       if (reorder->left_column)
1872         {
1873           gdk_window_get_origin (reorder->left_column->button->window, &x, &y);
1874           x += reorder->left_column->button->allocation.width - width/2;
1875           height = reorder->left_column->button->allocation.height;
1876         }
1877       else
1878         {
1879           gdk_window_get_origin (reorder->right_column->button->window, &x, &y);
1880           x -= width/2;
1881           height = reorder->right_column->button->allocation.height;
1882         }
1883       y -= expander_width/2; /* The arrow takes up only half the space */
1884       height += expander_width;
1885
1886       /* Create the new window */
1887       if (tree_view->priv->drag_column_window_state != DRAG_COLUMN_WINDOW_STATE_ARROW)
1888         {
1889           if (tree_view->priv->drag_highlight_window)
1890             gdk_window_destroy (tree_view->priv->drag_highlight_window);
1891
1892           attributes.window_type = GDK_WINDOW_TEMP;
1893           attributes.wclass = GDK_INPUT_OUTPUT;
1894           attributes.visual = gtk_widget_get_visual (GTK_WIDGET (tree_view));
1895           attributes.colormap = gtk_widget_get_colormap (GTK_WIDGET (tree_view));
1896           attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK;
1897           attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
1898           attributes.width = width;
1899           attributes.height = height;
1900           tree_view->priv->drag_highlight_window = gdk_window_new (NULL, &attributes, attributes_mask);
1901           gdk_window_set_user_data (tree_view->priv->drag_highlight_window, GTK_WIDGET (tree_view));
1902
1903           mask = gdk_pixmap_new (tree_view->priv->drag_highlight_window, width, height, 1);
1904           gc = gdk_gc_new (mask);
1905           col.pixel = 1;
1906           gdk_gc_set_foreground (gc, &col);
1907           gdk_draw_rectangle (mask, gc, TRUE, 0, 0, width, height);
1908
1909           /* Draw the 2 arrows as per above */
1910           col.pixel = 0;
1911           gdk_gc_set_foreground (gc, &col);
1912           for (i = 0; i < width; i ++)
1913             {
1914               if (i == (width/2 - 1))
1915                 continue;
1916               gdk_draw_line (mask, gc, i, j, i, height - j);
1917               if (i < (width/2 - 1))
1918                 j++;
1919               else
1920                 j--;
1921             }
1922           gdk_gc_destroy (gc);
1923           gdk_window_shape_combine_mask (tree_view->priv->drag_highlight_window,
1924                                          mask, 0, 0);
1925           if (mask) gdk_pixmap_unref (mask);
1926         }
1927
1928       tree_view->priv->drag_column_window_state = DRAG_COLUMN_WINDOW_STATE_ARROW;
1929       gdk_window_move (tree_view->priv->drag_highlight_window, x, y);
1930     }
1931   else if (arrow_type == DRAG_COLUMN_WINDOW_STATE_ARROW_LEFT ||
1932            arrow_type == DRAG_COLUMN_WINDOW_STATE_ARROW_RIGHT)
1933     {
1934       gint i, j = 1;
1935       GdkGC *gc;
1936       GdkColor col;
1937       gint expander_height;
1938
1939       gtk_widget_style_get (widget,
1940                             "expander_height", &expander_height,
1941                             "expander_width", &width,
1942                             NULL);
1943
1944       /* Get x, y, width, height of arrow */
1945       width = width/2; /* remember, the arrow only takes half the available width */
1946       gdk_window_get_origin (widget->window, &x, &y);
1947       if (arrow_type == DRAG_COLUMN_WINDOW_STATE_ARROW_RIGHT)
1948         x += widget->allocation.width - width;
1949
1950       if (reorder->left_column)
1951         height = reorder->left_column->button->allocation.height;
1952       else
1953         height = reorder->right_column->button->allocation.height;
1954
1955       y -= expander_height;
1956       height += 2*expander_height;
1957
1958       /* Create the new window */
1959       if (tree_view->priv->drag_column_window_state != DRAG_COLUMN_WINDOW_STATE_ARROW_LEFT &&
1960           tree_view->priv->drag_column_window_state != DRAG_COLUMN_WINDOW_STATE_ARROW_RIGHT)
1961         {
1962           if (tree_view->priv->drag_highlight_window)
1963             gdk_window_destroy (tree_view->priv->drag_highlight_window);
1964
1965           attributes.window_type = GDK_WINDOW_TEMP;
1966           attributes.wclass = GDK_INPUT_OUTPUT;
1967           attributes.visual = gtk_widget_get_visual (GTK_WIDGET (tree_view));
1968           attributes.colormap = gtk_widget_get_colormap (GTK_WIDGET (tree_view));
1969           attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK;
1970           attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
1971           attributes.width = width;
1972           attributes.height = height;
1973           tree_view->priv->drag_highlight_window = gdk_window_new (NULL, &attributes, attributes_mask);
1974           gdk_window_set_user_data (tree_view->priv->drag_highlight_window, GTK_WIDGET (tree_view));
1975
1976           mask = gdk_pixmap_new (tree_view->priv->drag_highlight_window, width, height, 1);
1977           gc = gdk_gc_new (mask);
1978           col.pixel = 1;
1979           gdk_gc_set_foreground (gc, &col);
1980           gdk_draw_rectangle (mask, gc, TRUE, 0, 0, width, height);
1981
1982           /* Draw the 2 arrows as per above */
1983           col.pixel = 0;
1984           gdk_gc_set_foreground (gc, &col);
1985           j = expander_height;
1986           for (i = 0; i < width; i ++)
1987             {
1988               gint k;
1989               if (arrow_type == DRAG_COLUMN_WINDOW_STATE_ARROW_LEFT)
1990                 k = width - i - 1;
1991               else
1992                 k = i;
1993               gdk_draw_line (mask, gc, k, j, k, height - j);
1994               gdk_draw_line (mask, gc, k, 0, k, expander_height - j);
1995               gdk_draw_line (mask, gc, k, height, k, height - expander_height + j);
1996               j--;
1997             }
1998           gdk_gc_destroy (gc);
1999           gdk_window_shape_combine_mask (tree_view->priv->drag_highlight_window,
2000                                          mask, 0, 0);
2001           if (mask) gdk_pixmap_unref (mask);
2002         }
2003
2004       tree_view->priv->drag_column_window_state = arrow_type;
2005       gdk_window_move (tree_view->priv->drag_highlight_window, x, y);
2006    }
2007   else
2008     {
2009       g_warning (G_STRLOC"Invalid GtkTreeViewColumnReorder struct");
2010       gdk_window_hide (tree_view->priv->drag_highlight_window);
2011       return;
2012     }
2013
2014   gdk_window_show (tree_view->priv->drag_highlight_window);
2015   gdk_window_raise (tree_view->priv->drag_highlight_window);
2016 }
2017
2018 static gboolean
2019 gtk_tree_view_motion_resize_column (GtkWidget      *widget,
2020                                     GdkEventMotion *event)
2021 {
2022   gint x;
2023   gint new_width;
2024
2025   if (event->is_hint || event->window != widget->window)
2026     gtk_widget_get_pointer (widget, &x, NULL);
2027   else
2028     x = event->x;
2029
2030   new_width = gtk_tree_view_new_column_width (GTK_TREE_VIEW (widget),
2031                                               GTK_TREE_VIEW (widget)->priv->drag_pos, &x);
2032   if (x != GTK_TREE_VIEW (widget)->priv->x_drag)
2033     _gtk_tree_view_column_set_width (gtk_tree_view_get_column (GTK_TREE_VIEW (widget), GTK_TREE_VIEW (widget)->priv->drag_pos), new_width);
2034
2035   /* FIXME: Do we need to scroll */
2036   _gtk_tree_view_update_size (GTK_TREE_VIEW (widget));
2037   return FALSE;
2038 }
2039
2040
2041 static void
2042 gtk_tree_view_update_current_reorder (GtkTreeView *tree_view)
2043 {
2044   GtkTreeViewColumnReorder *reorder = NULL;
2045   GList *list;
2046   gint mouse_x;
2047
2048   gdk_window_get_pointer (tree_view->priv->bin_window, &mouse_x, NULL, NULL);
2049
2050   for (list = tree_view->priv->column_drag_info; list; list = list->next)
2051     {
2052       reorder = (GtkTreeViewColumnReorder *) list->data;
2053       if (mouse_x >= reorder->left_align && mouse_x < reorder->right_align)
2054         break;
2055       reorder = NULL;
2056     }
2057
2058   /*  if (reorder && reorder == tree_view->priv->cur_reorder)
2059       return;*/
2060
2061   tree_view->priv->cur_reorder = reorder;
2062   gtk_tree_view_motion_draw_column_motion_arrow (tree_view);
2063 }
2064
2065 static gboolean
2066 gtk_tree_view_horizontal_autoscroll (GtkTreeView *tree_view)
2067 {
2068   GdkRectangle visible_rect;
2069   gint x;
2070   gint offset;
2071   gfloat value;
2072
2073   gdk_window_get_pointer (tree_view->priv->bin_window, &x, NULL, NULL);
2074
2075   gtk_tree_view_get_visible_rect (tree_view, &visible_rect);
2076
2077   /* See if we are near the edge. */
2078   offset = x - (visible_rect.x + SCROLL_EDGE_SIZE);
2079   if (offset > 0)
2080     {
2081       offset = x - (visible_rect.x + visible_rect.width - SCROLL_EDGE_SIZE);
2082       if (offset < 0)
2083         return TRUE;
2084     }
2085   offset = offset/3;
2086
2087   value = CLAMP (tree_view->priv->hadjustment->value + offset,
2088                  0.0, tree_view->priv->hadjustment->upper - tree_view->priv->hadjustment->page_size);
2089   gtk_adjustment_set_value (tree_view->priv->hadjustment, value);
2090
2091   return TRUE;
2092
2093 }
2094
2095 static gboolean
2096 gtk_tree_view_motion_drag_column (GtkWidget      *widget,
2097                                   GdkEventMotion *event)
2098 {
2099   GtkTreeView *tree_view = (GtkTreeView *) widget;
2100   GtkTreeViewColumn *column = tree_view->priv->drag_column;
2101   gint x, y;
2102
2103   /* Sanity Check */
2104   if ((column == NULL) ||
2105       (event->window != tree_view->priv->drag_window))
2106     return FALSE;
2107
2108   /* Handle moving the header */
2109   gdk_window_get_position (tree_view->priv->drag_window, &x, &y);
2110   x = CLAMP (x + (gint)event->x - column->drag_x, 0,
2111              MAX (tree_view->priv->width, GTK_WIDGET (tree_view)->allocation.width) - column->button->allocation.width);
2112   gdk_window_move (tree_view->priv->drag_window, x, y);
2113
2114   /* autoscroll, if needed */
2115   gtk_tree_view_horizontal_autoscroll (tree_view);
2116   /* Update the current reorder position and arrow; */
2117   gtk_tree_view_update_current_reorder (tree_view);
2118
2119   return TRUE;
2120 }
2121
2122 static gboolean
2123 gtk_tree_view_motion_bin_window (GtkWidget      *widget,
2124                                  GdkEventMotion *event)
2125 {
2126   GtkTreeView *tree_view;
2127   GtkRBTree *tree;
2128   GtkRBNode *node;
2129   gint new_y;
2130   GtkRBTree *old_prelight_tree;
2131   GtkRBNode *old_prelight_node;
2132
2133   tree_view = (GtkTreeView *) widget;
2134
2135   if (tree_view->priv->tree == NULL)
2136     return FALSE;
2137
2138   gtk_tree_view_maybe_begin_dragging_row (tree_view, event);
2139
2140   old_prelight_tree = tree_view->priv->prelight_tree;
2141   old_prelight_node = tree_view->priv->prelight_node;
2142
2143   do_unprelight (tree_view, event->x, event->y);
2144
2145   new_y = ((gint)event->y<TREE_VIEW_HEADER_HEIGHT (tree_view))?TREE_VIEW_HEADER_HEIGHT (tree_view):(gint)event->y;
2146
2147   _gtk_rbtree_find_offset (tree_view->priv->tree,
2148                            TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, new_y),
2149                            &tree,
2150                            &node);
2151
2152   if (tree == NULL)
2153     return TRUE;
2154
2155   /* If we are currently pressing down a button, we don't want to prelight anything else. */
2156   if ((tree_view->priv->button_pressed_node != NULL) &&
2157       (tree_view->priv->button_pressed_node != node))
2158     return TRUE;
2159
2160
2161   do_prelight (tree_view, tree, node, event->x, new_y);
2162
2163   if (old_prelight_node != tree_view->priv->prelight_node)
2164     {
2165       if (old_prelight_node)
2166         gtk_tree_view_queue_draw_node (tree_view,
2167                                        old_prelight_tree,
2168                                        old_prelight_node,
2169                                        NULL);
2170
2171       if (tree_view->priv->prelight_node)
2172         gtk_tree_view_queue_draw_node (tree_view,
2173                                        tree_view->priv->prelight_tree,
2174                                        tree_view->priv->prelight_node,
2175                                        NULL);
2176     }
2177
2178   return TRUE;
2179 }
2180
2181 static gboolean
2182 gtk_tree_view_motion (GtkWidget      *widget,
2183                       GdkEventMotion *event)
2184 {
2185   GtkTreeView *tree_view;
2186
2187   tree_view = (GtkTreeView *) widget;
2188
2189   /* Resizing a column */
2190   if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_IN_COLUMN_RESIZE))
2191     return gtk_tree_view_motion_resize_column (widget, event);
2192
2193   /* Drag column */
2194   if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_IN_COLUMN_DRAG))
2195     return gtk_tree_view_motion_drag_column (widget, event);
2196
2197   /* Sanity check it */
2198   if (event->window == tree_view->priv->bin_window)
2199     return gtk_tree_view_motion_bin_window (widget, event);
2200
2201   return FALSE;
2202 }
2203
2204
2205 static void
2206 gtk_tree_view_draw_focus (GtkWidget *widget)
2207 {
2208   GtkTreeView *tree_view;
2209   GtkTreePath *cursor_path;
2210   GtkRBTree *tree = NULL;
2211   GtkRBNode *node = NULL;
2212   gint x, y;
2213   gint width, height;
2214   gint vertical_separator;
2215
2216   g_return_if_fail (GTK_IS_TREE_VIEW (widget));
2217
2218   tree_view = GTK_TREE_VIEW (widget);
2219
2220   gtk_widget_style_get (widget, "vertical_separator", &vertical_separator, NULL);
2221
2222   if (! GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_DRAW_KEYFOCUS))
2223     return;
2224
2225   if (tree_view->priv->cursor == NULL)
2226     return;
2227
2228   cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
2229   if (cursor_path == NULL)
2230     return;
2231
2232   _gtk_tree_view_find_node (tree_view, cursor_path, &tree, &node);
2233
2234   if (tree == NULL)
2235     {
2236       gtk_tree_path_free (cursor_path);
2237       return;
2238     }
2239
2240   gdk_drawable_get_size (tree_view->priv->bin_window,
2241                          &width, NULL);
2242
2243
2244   x = 0;
2245   y = BACKGROUND_FIRST_PIXEL (tree_view, tree, node);
2246   gdk_drawable_get_size (tree_view->priv->bin_window,
2247                          &width, NULL);
2248   width = width - 1;
2249   height = BACKGROUND_HEIGHT (node) - 1;
2250   if (tree_view->priv->focus_column != NULL)
2251     {
2252       gboolean visible;
2253       gboolean can_focus;
2254
2255       g_object_get (G_OBJECT (tree_view->priv->focus_column->cell),
2256                     "can_activate", &can_focus,
2257                     "visible", &visible,
2258                     NULL);
2259       if (can_focus && visible)
2260         {
2261           GtkTreeIter iter;
2262           GdkRectangle cell_area;
2263           gint x_offset;
2264           gint y_offset;
2265
2266           cell_area.x = tree_view->priv->focus_column->button->allocation.x;
2267           cell_area.y = y;
2268           cell_area.width = tree_view->priv->focus_column->displayed_width;
2269           cell_area.height = CELL_HEIGHT (node, vertical_separator);
2270
2271           gtk_tree_model_get_iter (tree_view->priv->model, &iter, cursor_path);
2272           gtk_tree_view_column_cell_set_cell_data (tree_view->priv->focus_column, tree_view->priv->model, &iter);
2273
2274           gtk_cell_renderer_get_size (tree_view->priv->focus_column->cell, GTK_WIDGET (tree_view), &cell_area, &x_offset, &y_offset, &width, &height);
2275           width += 2;
2276           height += 2;
2277           x = cell_area.x + x_offset - 1;
2278           y = cell_area.y + y_offset - 1 + vertical_separator/2;
2279         }
2280     }
2281
2282   gtk_paint_focus (widget->style,
2283                    tree_view->priv->bin_window,
2284                    NULL,
2285                    widget,
2286                    "add-mode",
2287                    x, y, width, height);
2288
2289   gtk_tree_path_free (cursor_path);
2290 }
2291
2292 /* Warning: Very scary function.
2293  * Modify at your own risk
2294  */
2295 static gboolean
2296 gtk_tree_view_bin_expose (GtkWidget      *widget,
2297                           GdkEventExpose *event)
2298 {
2299   GtkTreeView *tree_view;
2300   GtkTreePath *path;
2301   GtkRBTree *tree;
2302   GList *list;
2303   GtkRBNode *node;
2304   GtkRBNode *cursor = NULL;
2305   GtkRBTree *cursor_tree = NULL;
2306   GtkRBNode *drag_highlight = NULL;
2307   GtkRBTree *drag_highlight_tree = NULL;
2308   GtkTreeIter iter;
2309   gint new_y;
2310   gint y_offset, x_offset, cell_offset;
2311   gint i, max_height;
2312   gint depth;
2313   GdkRectangle background_area;
2314   GdkRectangle cell_area;
2315   guint flags;
2316   gint highlight_x;
2317   gint bin_window_width;
2318   GtkTreePath *cursor_path;
2319   GtkTreePath *drag_dest_path;
2320   GList *last_column;
2321   gint vertical_separator;
2322
2323   g_return_val_if_fail (GTK_IS_TREE_VIEW (widget), FALSE);
2324
2325   tree_view = GTK_TREE_VIEW (widget);
2326   gtk_widget_style_get (widget, "vertical_separator", &vertical_separator, NULL);
2327
2328   if (tree_view->priv->tree == NULL)
2329     return TRUE;
2330
2331   gtk_tree_view_check_dirty (GTK_TREE_VIEW (widget));
2332   /* we want to account for a potential HEADER offset.
2333    * That is, if the header exists, we want to offset our event by its
2334    * height to find the right node.
2335    */
2336   new_y = (event->area.y<TREE_VIEW_HEADER_HEIGHT (tree_view))?TREE_VIEW_HEADER_HEIGHT (tree_view):event->area.y;
2337
2338   /* y_offset is the */
2339
2340   y_offset = -_gtk_rbtree_find_offset (tree_view->priv->tree,
2341                                        TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, new_y),
2342                                        &tree,
2343                                        &node) + new_y - event->area.y;
2344   if (node == NULL)
2345     return TRUE;
2346
2347   /* find the path for the node */
2348   path = _gtk_tree_view_find_path ((GtkTreeView *)widget,
2349                                    tree,
2350                                    node);
2351   gtk_tree_model_get_iter (tree_view->priv->model,
2352                            &iter,
2353                            path);
2354   depth = gtk_tree_path_get_depth (path);
2355   gtk_tree_path_free (path);
2356
2357   cursor_path = NULL;
2358   drag_dest_path = NULL;
2359
2360   if (tree_view->priv->cursor)
2361     cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
2362
2363   if (cursor_path)
2364     _gtk_tree_view_find_node (tree_view, cursor_path,
2365                               &cursor_tree, &cursor);
2366
2367   if (tree_view->priv->drag_dest_row)
2368     drag_dest_path = gtk_tree_row_reference_get_path (tree_view->priv->drag_dest_row);
2369
2370   if (drag_dest_path)
2371     _gtk_tree_view_find_node (tree_view, drag_dest_path,
2372                               &drag_highlight_tree, &drag_highlight);
2373
2374   gdk_drawable_get_size (tree_view->priv->bin_window,
2375                          &bin_window_width, NULL);
2376
2377   for (last_column = g_list_last (tree_view->priv->columns);
2378        last_column &&
2379          !(GTK_TREE_VIEW_COLUMN (last_column->data)->visible) &&
2380          GTK_WIDGET_CAN_FOCUS (GTK_TREE_VIEW_COLUMN (last_column->data)->button);
2381        last_column = last_column->prev)
2382     ;
2383
2384   /* Actually process the expose event.  To do this, we want to
2385    * start at the first node of the event, and walk the tree in
2386    * order, drawing each successive node.
2387    */
2388
2389   do
2390     {
2391       gboolean parity;
2392
2393       max_height = BACKGROUND_HEIGHT (node);
2394
2395       x_offset = -event->area.x;
2396       cell_offset = 0;
2397       highlight_x = 0; /* should match x coord of first cell */
2398
2399       background_area.y = y_offset + event->area.y;
2400       background_area.height = max_height;
2401       flags = 0;
2402
2403       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PRELIT))
2404         flags |= GTK_CELL_RENDERER_PRELIT;
2405
2406       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
2407         flags |= GTK_CELL_RENDERER_SELECTED;
2408
2409       parity = _gtk_rbtree_node_find_parity (tree, node);
2410
2411       for (i = 0, list = tree_view->priv->columns; i < tree_view->priv->n_columns; i++, list = list->next)
2412         {
2413           GtkTreeViewColumn *column = list->data;
2414           const gchar *detail = NULL;
2415
2416           if (!column->visible)
2417             continue;
2418
2419           if (cell_offset > event->area.x + event->area.width ||
2420               cell_offset + column->displayed_width < event->area.x)
2421             {
2422               cell_offset += column->displayed_width;
2423               continue;
2424             }
2425
2426           if (column->show_sort_indicator)
2427             flags |= GTK_CELL_RENDERER_SORTED;
2428           else
2429             flags &= ~GTK_CELL_RENDERER_SORTED;
2430
2431           gtk_tree_view_column_cell_set_cell_data (column,
2432                                                    tree_view->priv->model,
2433                                                    &iter);
2434
2435           background_area.x = cell_offset;
2436           background_area.width = column->displayed_width;
2437
2438           cell_area = background_area;
2439           cell_area.y += vertical_separator / 2;
2440           cell_area.height -= vertical_separator;
2441
2442           /* Select the detail for drawing the cell.  relevant
2443            * factors are parity, sortedness, and whether to
2444            * display rules.
2445            */
2446
2447           /* FIXME when we have style properties, clean this up.
2448            */
2449
2450           if (tree_view->priv->has_rules)
2451             {
2452               if (flags & GTK_CELL_RENDERER_SORTED)
2453                 {
2454                   if (parity)
2455                     detail = "cell_odd_ruled_sorted";
2456                   else
2457                     detail = "cell_even_ruled_sorted";
2458                 }
2459               else
2460                 {
2461                   if (parity)
2462                     detail = "cell_odd_ruled";
2463                   else
2464                     detail = "cell_even_ruled";
2465                 }
2466             }
2467           else
2468             {
2469               if (flags & GTK_CELL_RENDERER_SORTED)
2470                 {
2471                   if (parity)
2472                     detail = "cell_odd_sorted";
2473                   else
2474                     detail = "cell_even_sorted";
2475                 }
2476               else
2477                 {
2478                   if (parity)
2479                     detail = "cell_odd";
2480                   else
2481                     detail = "cell_even";
2482                 }
2483             }
2484
2485           g_assert (detail);
2486
2487           /* Draw background */
2488           gtk_paint_flat_box (widget->style,
2489                               event->window,
2490                               (flags & GTK_CELL_RENDERER_SELECTED) ?
2491                               GTK_STATE_SELECTED : GTK_STATE_NORMAL,
2492                               GTK_SHADOW_NONE,
2493                               &event->area,
2494                               widget,
2495                               detail,
2496                               background_area.x,
2497                               background_area.y,
2498                               background_area.width,
2499                               background_area.height);
2500
2501           if (i == tree_view->priv->expander_column &&
2502               TREE_VIEW_DRAW_EXPANDERS(tree_view))
2503             {
2504               cell_area.x += depth*tree_view->priv->tab_offset;
2505               cell_area.width -= depth*tree_view->priv->tab_offset;
2506
2507               /* If we have an expander column, the highlight underline
2508                * starts with that column, so that it indicates which
2509                * level of the tree we're dropping at.
2510                */
2511               highlight_x = cell_area.x;
2512
2513               gtk_tree_view_column_cell_render (column,
2514                                                 event->window,
2515                                                 &background_area,
2516                                                 &cell_area,
2517                                                 &event->area,
2518                                                 flags);
2519               if ((node->flags & GTK_RBNODE_IS_PARENT) == GTK_RBNODE_IS_PARENT)
2520                 {
2521                   gint x, y;
2522                   gdk_window_get_pointer (tree_view->priv->bin_window, &x, &y, 0);
2523                   gtk_tree_view_draw_arrow (GTK_TREE_VIEW (widget),
2524                                             tree,
2525                                             node,
2526                                             x, y);
2527                 }
2528             }
2529           else
2530             {
2531               gtk_tree_view_column_cell_render (column,
2532                                                 event->window,
2533                                                 &background_area,
2534                                                 &cell_area,
2535                                                 &event->area,
2536                                                 flags);
2537             }
2538           cell_offset += column->displayed_width;
2539         }
2540
2541       if (node == cursor && GTK_WIDGET_HAS_FOCUS (widget))
2542         gtk_tree_view_draw_focus (widget);
2543
2544       if (node == drag_highlight)
2545         {
2546           /* Draw indicator for the drop
2547            */
2548           gint highlight_y = -1;
2549           GtkRBTree *tree = NULL;
2550           GtkRBNode *node = NULL;
2551           gint width;
2552
2553           switch (tree_view->priv->drag_dest_pos)
2554             {
2555             case GTK_TREE_VIEW_DROP_BEFORE:
2556               highlight_y = background_area.y - vertical_separator/2;
2557               break;
2558
2559             case GTK_TREE_VIEW_DROP_AFTER:
2560               highlight_y = background_area.y + background_area.height + vertical_separator/2;
2561               break;
2562
2563             case GTK_TREE_VIEW_DROP_INTO_OR_BEFORE:
2564             case GTK_TREE_VIEW_DROP_INTO_OR_AFTER:
2565               _gtk_tree_view_find_node (tree_view, drag_dest_path, &tree, &node);
2566
2567               if (tree == NULL)
2568                 break;
2569               gdk_drawable_get_size (tree_view->priv->bin_window,
2570                                      &width, NULL);
2571               gtk_paint_focus (widget->style,
2572                                tree_view->priv->bin_window,
2573                                NULL,
2574                                widget,
2575                                "add-mode",
2576                                0, BACKGROUND_FIRST_PIXEL (tree_view, tree, node),
2577                                width - 1, BACKGROUND_HEIGHT (node) - 1);
2578
2579               break;
2580             }
2581
2582           if (highlight_y >= 0)
2583             {
2584               gdk_draw_line (event->window,
2585                              widget->style->black_gc,
2586                              highlight_x,
2587                              highlight_y,
2588                              bin_window_width - highlight_x,
2589                              highlight_y);
2590             }
2591         }
2592
2593       y_offset += max_height;
2594       if (node->children)
2595         {
2596           GtkTreeIter parent = iter;
2597           gboolean has_child;
2598
2599           tree = node->children;
2600           node = tree->root;
2601
2602           g_assert (node != tree->nil);
2603
2604           while (node->left != tree->nil)
2605             node = node->left;
2606           has_child = gtk_tree_model_iter_children (tree_view->priv->model,
2607                                                     &iter,
2608                                                     &parent);
2609           depth++;
2610
2611           /* Sanity Check! */
2612           TREE_VIEW_INTERNAL_ASSERT (has_child, FALSE);
2613         }
2614       else
2615         {
2616           gboolean done = FALSE;
2617           do
2618             {
2619               node = _gtk_rbtree_next (tree, node);
2620               if (node != NULL)
2621                 {
2622                   gboolean has_next = gtk_tree_model_iter_next (tree_view->priv->model, &iter);
2623                   done = TRUE;
2624
2625                   /* Sanity Check! */
2626                   TREE_VIEW_INTERNAL_ASSERT (has_next, FALSE);
2627                 }
2628               else
2629                 {
2630                   GtkTreeIter parent_iter = iter;
2631                   gboolean has_parent;
2632
2633                   node = tree->parent_node;
2634                   tree = tree->parent_tree;
2635                   if (tree == NULL)
2636                     /* we've run out of tree.  It's okay to return though, as
2637                      * we'd only break out of the while loop below. */
2638                     return TRUE;
2639                   has_parent = gtk_tree_model_iter_parent (tree_view->priv->model,
2640                                                            &iter,
2641                                                            &parent_iter);
2642                   depth--;
2643
2644                   /* Sanity check */
2645                   TREE_VIEW_INTERNAL_ASSERT (has_parent, FALSE);
2646                 }
2647             }
2648           while (!done);
2649         }
2650     }
2651   while (y_offset < event->area.height);
2652
2653   if (cursor_path)
2654     gtk_tree_path_free (cursor_path);
2655
2656   if (drag_dest_path)
2657     gtk_tree_path_free (drag_dest_path);
2658
2659   return TRUE;
2660 }
2661
2662 static gboolean
2663 gtk_tree_view_expose (GtkWidget      *widget,
2664                       GdkEventExpose *event)
2665 {
2666   GtkTreeView *tree_view;
2667
2668   g_return_val_if_fail (GTK_IS_TREE_VIEW (widget), FALSE);
2669
2670   tree_view = GTK_TREE_VIEW (widget);
2671
2672   if (event->window == tree_view->priv->bin_window)
2673     return gtk_tree_view_bin_expose (widget, event);
2674
2675   return TRUE;
2676 }
2677
2678 static gboolean
2679 gtk_tree_view_key_press (GtkWidget   *widget,
2680                          GdkEventKey *event)
2681 {
2682   GtkTreeView *tree_view = (GtkTreeView *) widget;
2683
2684   if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_IN_COLUMN_DRAG))
2685     {
2686       if (event->keyval == GDK_Escape)
2687         {
2688           tree_view->priv->cur_reorder = NULL;
2689           gtk_tree_view_button_release_drag_column (widget, NULL);
2690         }
2691       return TRUE;
2692     }
2693   return (* GTK_WIDGET_CLASS (parent_class)->key_press_event) (widget, event);
2694 }
2695
2696 /* FIXME Is this function necessary? Can I get an enter_notify event
2697  * w/o either an expose event or a mouse motion event?
2698  */
2699 static gboolean
2700 gtk_tree_view_enter_notify (GtkWidget        *widget,
2701                             GdkEventCrossing *event)
2702 {
2703   GtkTreeView *tree_view;
2704   GtkRBTree *tree;
2705   GtkRBNode *node;
2706   gint new_y;
2707
2708   g_return_val_if_fail (GTK_IS_TREE_VIEW (widget), FALSE);
2709
2710   tree_view = GTK_TREE_VIEW (widget);
2711
2712   /* Sanity check it */
2713   if (event->window != tree_view->priv->bin_window)
2714     return FALSE;
2715
2716   if (tree_view->priv->tree == NULL)
2717     return FALSE;
2718
2719   if ((tree_view->priv->button_pressed_node != NULL) &&
2720       (tree_view->priv->button_pressed_node != node))
2721     return TRUE;
2722
2723   /* find the node internally */
2724   new_y = ((gint)event->y<TREE_VIEW_HEADER_HEIGHT (tree_view))?TREE_VIEW_HEADER_HEIGHT (tree_view):(gint)event->y;
2725
2726   _gtk_rbtree_find_offset (tree_view->priv->tree,
2727                            TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, new_y),
2728                            &tree,
2729                            &node);
2730
2731   if (node == NULL)
2732     return FALSE;
2733
2734   do_prelight (tree_view, tree, node, event->x, new_y);
2735
2736   if (tree_view->priv->prelight_node)
2737     gtk_tree_view_queue_draw_node (tree_view,
2738                                    tree_view->priv->prelight_tree,
2739                                    tree_view->priv->prelight_node,
2740                                    NULL);
2741
2742   return TRUE;
2743 }
2744
2745 static gboolean
2746 gtk_tree_view_leave_notify (GtkWidget        *widget,
2747                             GdkEventCrossing *event)
2748 {
2749   GtkTreeView *tree_view;
2750
2751   g_return_val_if_fail (GTK_IS_TREE_VIEW (widget), FALSE);
2752
2753   tree_view = GTK_TREE_VIEW (widget);
2754
2755   if (tree_view->priv->prelight_node)
2756     gtk_tree_view_queue_draw_node (tree_view,
2757                                    tree_view->priv->prelight_tree,
2758                                    tree_view->priv->prelight_node,
2759                                    NULL);
2760
2761   ensure_unprelighted (tree_view);
2762
2763   return TRUE;
2764 }
2765
2766
2767 static gint
2768 gtk_tree_view_focus_in (GtkWidget     *widget,
2769                         GdkEventFocus *event)
2770 {
2771   GtkTreeView *tree_view;
2772
2773   g_return_val_if_fail (GTK_IS_TREE_VIEW (widget), FALSE);
2774   g_return_val_if_fail (event != NULL, FALSE);
2775
2776   tree_view = GTK_TREE_VIEW (widget);
2777
2778   GTK_WIDGET_SET_FLAGS (widget, GTK_HAS_FOCUS);
2779
2780   /* FIXME don't redraw so much */
2781   gtk_widget_queue_draw (widget);
2782
2783   return FALSE;
2784 }
2785
2786
2787 static gint
2788 gtk_tree_view_focus_out (GtkWidget     *widget,
2789                          GdkEventFocus *event)
2790 {
2791   g_return_val_if_fail (GTK_IS_TREE_VIEW (widget), FALSE);
2792   g_return_val_if_fail (event != NULL, FALSE);
2793
2794   GTK_WIDGET_UNSET_FLAGS (widget, GTK_HAS_FOCUS);
2795
2796   /* FIXME don't redraw so much */
2797   gtk_widget_queue_draw (widget);
2798
2799   return FALSE;
2800 }
2801
2802
2803 /* Drag-and-drop */
2804
2805 static void
2806 set_source_row (GdkDragContext *context,
2807                 GtkTreeModel   *model,
2808                 GtkTreePath    *source_row)
2809 {
2810   g_object_set_data_full (G_OBJECT (context),
2811                           "gtk-tree-view-source-row",
2812                           source_row ? gtk_tree_row_reference_new (model, source_row) : NULL,
2813                           (GDestroyNotify) (source_row ? gtk_tree_row_reference_free : NULL));
2814 }
2815
2816 static GtkTreePath*
2817 get_source_row (GdkDragContext *context)
2818 {
2819   GtkTreeRowReference *ref =
2820     g_object_get_data (G_OBJECT (context), "gtk-tree-view-source-row");
2821
2822   if (ref)
2823     return gtk_tree_row_reference_get_path (ref);
2824   else
2825     return NULL;
2826 }
2827
2828
2829 static void
2830 set_dest_row (GdkDragContext *context,
2831               GtkTreeModel   *model,
2832               GtkTreePath    *dest_row)
2833 {
2834   g_object_set_data_full (G_OBJECT (context),
2835                           "gtk-tree-view-dest-row",
2836                           dest_row ? gtk_tree_row_reference_new (model, dest_row) : NULL,
2837                           (GDestroyNotify) (dest_row ? gtk_tree_row_reference_free : NULL));
2838 }
2839
2840 static GtkTreePath*
2841 get_dest_row (GdkDragContext *context)
2842 {
2843   GtkTreeRowReference *ref =
2844     g_object_get_data (G_OBJECT (context), "gtk-tree-view-dest-row");
2845
2846   if (ref)
2847     return gtk_tree_row_reference_get_path (ref);
2848   else
2849     return NULL;
2850 }
2851
2852 /* Get/set whether drag_motion requested the drag data and
2853  * drag_data_received should thus not actually insert the data,
2854  * since the data doesn't result from a drop.
2855  */
2856 static void
2857 set_status_pending (GdkDragContext *context,
2858                     GdkDragAction   suggested_action)
2859 {
2860   g_object_set_data (G_OBJECT (context),
2861                      "gtk-tree-view-status-pending",
2862                      GINT_TO_POINTER (suggested_action));
2863 }
2864
2865 static GdkDragAction
2866 get_status_pending (GdkDragContext *context)
2867 {
2868   return GPOINTER_TO_INT (g_object_get_data (G_OBJECT (context),
2869                                              "gtk-tree-view-status-pending"));
2870 }
2871
2872 static TreeViewDragInfo*
2873 get_info (GtkTreeView *tree_view)
2874 {
2875   return g_object_get_data (G_OBJECT (tree_view), "gtk-tree-view-drag-info");
2876 }
2877
2878 static void
2879 clear_source_info (TreeViewDragInfo *di)
2880 {
2881   if (di->source_target_list)
2882     gtk_target_list_unref (di->source_target_list);
2883
2884   if (di->row_draggable_closure)
2885     g_closure_unref (di->row_draggable_closure);
2886
2887   di->source_target_list = NULL;
2888   di->row_draggable_closure = NULL;
2889 }
2890
2891 static void
2892 clear_dest_info (TreeViewDragInfo *di)
2893 {
2894   if (di->location_droppable_closure)
2895     g_closure_unref (di->location_droppable_closure);
2896
2897   if (di->dest_target_list)
2898     gtk_target_list_unref (di->dest_target_list);
2899
2900   di->location_droppable_closure = NULL;
2901   di->dest_target_list = NULL;
2902 }
2903
2904 static void
2905 destroy_info (TreeViewDragInfo *di)
2906 {
2907   clear_source_info (di);
2908   clear_dest_info (di);
2909   g_free (di);
2910 }
2911
2912 static TreeViewDragInfo*
2913 ensure_info (GtkTreeView *tree_view)
2914 {
2915   TreeViewDragInfo *di;
2916
2917   di = get_info (tree_view);
2918
2919   if (di == NULL)
2920     {
2921       di = g_new0 (TreeViewDragInfo, 1);
2922
2923       g_object_set_data_full (G_OBJECT (tree_view),
2924                               "gtk-tree-view-drag-info",
2925                               di,
2926                               (GDestroyNotify) destroy_info);
2927     }
2928
2929   return di;
2930 }
2931
2932 static void
2933 remove_info (GtkTreeView *tree_view)
2934 {
2935   g_object_set_data (G_OBJECT (tree_view), "gtk-tree-view-drag-info", NULL);
2936 }
2937
2938 static gint
2939 drag_scan_timeout (gpointer data)
2940 {
2941   GtkTreeView *tree_view;
2942   gint x, y;
2943   GdkModifierType state;
2944   GtkTreePath *path = NULL;
2945   GtkTreeViewColumn *column = NULL;
2946   GdkRectangle visible_rect;
2947
2948   tree_view = GTK_TREE_VIEW (data);
2949
2950   gdk_window_get_pointer (tree_view->priv->bin_window,
2951                           &x, &y, &state);
2952
2953   gtk_tree_view_get_visible_rect (tree_view, &visible_rect);
2954
2955   /* See if we are near the edge. */
2956   if ((x - visible_rect.x) < SCROLL_EDGE_SIZE ||
2957       (visible_rect.x + visible_rect.width - x) < SCROLL_EDGE_SIZE ||
2958       (y - visible_rect.y) < SCROLL_EDGE_SIZE ||
2959       (visible_rect.y + visible_rect.height - y) < SCROLL_EDGE_SIZE)
2960     {
2961       gtk_tree_view_get_path_at_pos (tree_view,
2962                                      tree_view->priv->bin_window,
2963                                      x, y,
2964                                      &path,
2965                                      &column,
2966                                      NULL,
2967                                      NULL);
2968
2969       if (path != NULL)
2970         {
2971           gtk_tree_view_scroll_to_cell (tree_view,
2972                                         path,
2973                                         column,
2974                                         0.5, 0.5);
2975
2976           gtk_tree_path_free (path);
2977         }
2978     }
2979
2980   return TRUE;
2981 }
2982
2983
2984 static void
2985 remove_scroll_timeout (GtkTreeView *tree_view)
2986 {
2987   if (tree_view->priv->scroll_timeout != 0)
2988     {
2989       gtk_timeout_remove (tree_view->priv->scroll_timeout);
2990       tree_view->priv->scroll_timeout = 0;
2991     }
2992 }
2993 static gboolean
2994 check_model_dnd (GtkTreeModel *model,
2995                  GType         required_iface,
2996                  const gchar  *signal)
2997 {
2998   if (model == NULL || !G_TYPE_CHECK_INSTANCE_TYPE ((model), required_iface))
2999     {
3000       g_warning ("You must override the default '%s' handler "
3001                  "on GtkTreeView when using models that don't support "
3002                  "the %s interface and enabling drag-and-drop. The simplest way to do this "
3003                  "is to connect to '%s' and call "
3004                  "gtk_signal_emit_stop_by_name() in your signal handler to prevent "
3005                  "the default handler from running. Look at the source code "
3006                  "for the default handler in gtktreeview.c to get an idea what "
3007                  "your handler should do. (gtktreeview.c is in the GTK source "
3008                  "code.) If you're using GTK from a language other than C, "
3009                  "there may be a more natural way to override default handlers, e.g. via derivation.",
3010                  signal, g_type_name (required_iface), signal);
3011       return FALSE;
3012     }
3013   else
3014     return TRUE;
3015 }
3016
3017 static void
3018 remove_open_timeout (GtkTreeView *tree_view)
3019 {
3020   if (tree_view->priv->open_dest_timeout != 0)
3021     {
3022       gtk_timeout_remove (tree_view->priv->open_dest_timeout);
3023       tree_view->priv->open_dest_timeout = 0;
3024     }
3025 }
3026
3027
3028 static gint
3029 open_row_timeout (gpointer data)
3030 {
3031   GtkTreeView *tree_view = data;
3032   GtkTreePath *dest_path = NULL;
3033   GtkTreeViewDropPosition pos;
3034
3035   gtk_tree_view_get_drag_dest_row (tree_view,
3036                                    &dest_path,
3037                                    &pos);
3038
3039   if (dest_path &&
3040       (pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER ||
3041        pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE))
3042     {
3043       gtk_tree_view_expand_row (tree_view, dest_path, FALSE);
3044       tree_view->priv->open_dest_timeout = 0;
3045
3046       gtk_tree_path_free (dest_path);
3047
3048       return FALSE;
3049     }
3050   else
3051     {
3052       if (dest_path)
3053         gtk_tree_path_free (dest_path);
3054       return TRUE;
3055     }
3056 }
3057
3058 /* Returns TRUE if event should not be propagated to parent widgets */
3059 static gboolean
3060 set_destination_row (GtkTreeView    *tree_view,
3061                      GdkDragContext *context,
3062                      gint            x,
3063                      gint            y,
3064                      GdkDragAction  *suggested_action,
3065                      GdkAtom        *target)
3066 {
3067   GtkTreePath *path = NULL;
3068   GtkTreeViewDropPosition pos;
3069   GtkTreeViewDropPosition old_pos;
3070   TreeViewDragInfo *di;
3071   GtkWidget *widget;
3072   GtkTreePath *old_dest_path = NULL;
3073
3074   *suggested_action = 0;
3075   *target = GDK_NONE;
3076
3077   widget = GTK_WIDGET (tree_view);
3078
3079   di = get_info (tree_view);
3080
3081   if (di == NULL)
3082     {
3083       /* someone unset us as a drag dest, note that if
3084        * we return FALSE drag_leave isn't called
3085        */
3086
3087       gtk_tree_view_set_drag_dest_row (tree_view,
3088                                        NULL,
3089                                        GTK_TREE_VIEW_DROP_BEFORE);
3090
3091       remove_scroll_timeout (GTK_TREE_VIEW (widget));
3092       remove_open_timeout (GTK_TREE_VIEW (widget));
3093
3094       return FALSE; /* no longer a drop site */
3095     }
3096
3097   *target = gtk_drag_dest_find_target (widget, context, di->dest_target_list);
3098   if (*target == GDK_NONE)
3099     {
3100       return FALSE;
3101     }
3102
3103   if (!gtk_tree_view_get_dest_row_at_pos (tree_view,
3104                                           x, y,
3105                                           &path,
3106                                           &pos))
3107     {
3108       /* can't drop here */
3109       remove_open_timeout (tree_view);
3110
3111       gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
3112                                        NULL,
3113                                        GTK_TREE_VIEW_DROP_BEFORE);
3114
3115       /* don't propagate to parent though */
3116       return TRUE;
3117     }
3118
3119   g_assert (path);
3120
3121   /* If we left the current row's "open" zone, unset the timeout for
3122    * opening the row
3123    */
3124   gtk_tree_view_get_drag_dest_row (tree_view,
3125                                    &old_dest_path,
3126                                    &old_pos);
3127
3128   if (old_dest_path &&
3129       (gtk_tree_path_compare (path, old_dest_path) != 0 ||
3130        !(pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER ||
3131          pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE)))
3132     remove_open_timeout (tree_view);
3133
3134   if (old_dest_path)
3135     gtk_tree_path_free (old_dest_path);
3136
3137   if (TRUE /* FIXME if the location droppable predicate */)
3138     {
3139       GtkWidget *source_widget;
3140
3141       *suggested_action = context->suggested_action;
3142
3143       source_widget = gtk_drag_get_source_widget (context);
3144
3145       if (source_widget == widget)
3146         {
3147           /* Default to MOVE, unless the user has
3148            * pressed ctrl or alt to affect available actions
3149            */
3150           if ((context->actions & GDK_ACTION_MOVE) != 0)
3151             *suggested_action = GDK_ACTION_MOVE;
3152         }
3153
3154       gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
3155                                        path, pos);
3156     }
3157   else
3158     {
3159       /* can't drop here */
3160       remove_open_timeout (tree_view);
3161
3162       gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
3163                                        NULL,
3164                                        GTK_TREE_VIEW_DROP_BEFORE);
3165     }
3166
3167   return TRUE;
3168 }
3169 static GtkTreePath*
3170 get_logical_dest_row (GtkTreeView *tree_view)
3171
3172 {
3173   /* adjust path to point to the row the drop goes in front of */
3174   GtkTreePath *path = NULL;
3175   GtkTreeViewDropPosition pos;
3176
3177   gtk_tree_view_get_drag_dest_row (tree_view, &path, &pos);
3178
3179   if (path == NULL)
3180     return NULL;
3181
3182   if (pos == GTK_TREE_VIEW_DROP_BEFORE)
3183     ; /* do nothing */
3184   else if (pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE ||
3185            pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER)
3186     {
3187       /* get first child, drop before it */
3188       gtk_tree_path_append_index (path, 0);
3189     }
3190   else
3191     {
3192       g_assert (pos == GTK_TREE_VIEW_DROP_AFTER);
3193       gtk_tree_path_next (path);
3194     }
3195
3196   return path;
3197 }
3198
3199 static gboolean
3200 gtk_tree_view_maybe_begin_dragging_row (GtkTreeView      *tree_view,
3201                                         GdkEventMotion   *event)
3202 {
3203   GdkDragContext *context;
3204   TreeViewDragInfo *di;
3205   GtkTreePath *path = NULL;
3206   gint button;
3207   gint cell_x, cell_y;
3208   GtkTreeModel *model;
3209
3210   di = get_info (tree_view);
3211
3212   if (di == NULL)
3213     return FALSE;
3214
3215   if (tree_view->priv->pressed_button < 0)
3216     return FALSE;
3217
3218   if (!gtk_drag_check_threshold (GTK_WIDGET (tree_view),
3219                                  tree_view->priv->press_start_x,
3220                                  tree_view->priv->press_start_y,
3221                                  event->x, event->y))
3222     return FALSE;
3223
3224   model = gtk_tree_view_get_model (tree_view);
3225
3226   if (model == NULL)
3227     return FALSE;
3228
3229   button = tree_view->priv->pressed_button;
3230   tree_view->priv->pressed_button = -1;
3231
3232   gtk_tree_view_get_path_at_pos (tree_view,
3233                                  tree_view->priv->bin_window,
3234                                  tree_view->priv->press_start_x,
3235                                  tree_view->priv->press_start_y,
3236                                  &path,
3237                                  NULL,
3238                                  &cell_x,
3239                                  &cell_y);
3240
3241   if (path == NULL)
3242     return FALSE;
3243
3244   /* FIXME if the path doesn't match the row_draggable predicate,
3245    * return FALSE and free path
3246    */
3247
3248   /* FIXME Check whether we're a start button, if not return FALSE and
3249    * free path
3250    */
3251
3252   context = gtk_drag_begin (GTK_WIDGET (tree_view),
3253                             di->source_target_list,
3254                             di->source_actions,
3255                             button,
3256                             (GdkEvent*)event);
3257
3258   gtk_drag_set_icon_default (context);
3259
3260   {
3261     GdkPixmap *row_pix;
3262
3263     row_pix = gtk_tree_view_create_row_drag_icon (tree_view,
3264                                                   path);
3265
3266     gtk_drag_set_icon_pixmap (context,
3267                               gdk_drawable_get_colormap (row_pix),
3268                               row_pix,
3269                               NULL,
3270                               /* the + 1 is for the black border in the icon */
3271                               tree_view->priv->press_start_x + 1,
3272                               cell_y + 1);
3273
3274     gdk_pixmap_unref (row_pix);
3275   }
3276
3277   set_source_row (context, model, path);
3278   gtk_tree_path_free (path);
3279
3280   return TRUE;
3281 }
3282
3283
3284 static void
3285 gtk_tree_view_drag_begin (GtkWidget      *widget,
3286                           GdkDragContext *context)
3287 {
3288   /* do nothing */
3289 }
3290
3291 static void
3292 gtk_tree_view_drag_end (GtkWidget      *widget,
3293                         GdkDragContext *context)
3294 {
3295   /* do nothing */
3296 }
3297
3298 /* Default signal implementations for the drag signals */
3299 static void
3300 gtk_tree_view_drag_data_get (GtkWidget        *widget,
3301                              GdkDragContext   *context,
3302                              GtkSelectionData *selection_data,
3303                              guint             info,
3304                              guint             time)
3305 {
3306   GtkTreeView *tree_view;
3307   GtkTreeModel *model;
3308   TreeViewDragInfo *di;
3309   GtkTreePath *source_row;
3310
3311   tree_view = GTK_TREE_VIEW (widget);
3312
3313   model = gtk_tree_view_get_model (tree_view);
3314
3315   if (model == NULL)
3316     return;
3317
3318   di = get_info (GTK_TREE_VIEW (widget));
3319
3320   if (di == NULL)
3321     return;
3322
3323   source_row = get_source_row (context);
3324
3325   if (source_row == NULL)
3326     return;
3327
3328   /* We can implement the GTK_TREE_MODEL_ROW target generically for
3329    * any model; for DragSource models there are some other targets
3330    * we also support.
3331    */
3332
3333   if (GTK_IS_TREE_DRAG_SOURCE (model) &&
3334       gtk_tree_drag_source_drag_data_get (GTK_TREE_DRAG_SOURCE (model),
3335                                           source_row,
3336                                           selection_data))
3337     goto done;
3338
3339   /* If drag_data_get does nothing, try providing row data. */
3340   if (selection_data->target == gdk_atom_intern ("GTK_TREE_MODEL_ROW", FALSE))
3341     {
3342       gtk_selection_data_set_tree_row (selection_data,
3343                                        model,
3344                                        source_row);
3345     }
3346
3347  done:
3348   gtk_tree_path_free (source_row);
3349 }
3350
3351
3352 static void
3353 gtk_tree_view_drag_data_delete (GtkWidget      *widget,
3354                                 GdkDragContext *context)
3355 {
3356   TreeViewDragInfo *di;
3357   GtkTreeModel *model;
3358   GtkTreeView *tree_view;
3359   GtkTreePath *source_row;
3360
3361   tree_view = GTK_TREE_VIEW (widget);
3362   model = gtk_tree_view_get_model (tree_view);
3363
3364   if (!check_model_dnd (model, GTK_TYPE_TREE_DRAG_SOURCE, "drag_data_delete"))
3365     return;
3366
3367   di = get_info (tree_view);
3368
3369   if (di == NULL)
3370     return;
3371
3372   source_row = get_source_row (context);
3373
3374   if (source_row == NULL)
3375     return;
3376
3377   gtk_tree_drag_source_drag_data_delete (GTK_TREE_DRAG_SOURCE (model),
3378                                          source_row);
3379
3380   gtk_tree_path_free (source_row);
3381
3382   set_source_row (context, NULL, NULL);
3383 }
3384
3385 static void
3386 gtk_tree_view_drag_leave (GtkWidget      *widget,
3387                           GdkDragContext *context,
3388                           guint             time)
3389 {
3390   TreeViewDragInfo *di;
3391
3392   di = get_info (GTK_TREE_VIEW (widget));
3393
3394   /* unset any highlight row */
3395   gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
3396                                    NULL,
3397                                    GTK_TREE_VIEW_DROP_BEFORE);
3398
3399   remove_scroll_timeout (GTK_TREE_VIEW (widget));
3400   remove_open_timeout (GTK_TREE_VIEW (widget));
3401 }
3402
3403
3404 static gboolean
3405 gtk_tree_view_drag_motion (GtkWidget        *widget,
3406                            GdkDragContext   *context,
3407                            gint              x,
3408                            gint              y,
3409                            guint             time)
3410 {
3411   GtkTreePath *path = NULL;
3412   GtkTreeViewDropPosition pos;
3413   GtkTreeView *tree_view;
3414   GdkDragAction suggested_action = 0;
3415   GdkAtom target;
3416
3417   tree_view = GTK_TREE_VIEW (widget);
3418
3419   if (!set_destination_row (tree_view, context, x, y, &suggested_action, &target))
3420     return FALSE;
3421
3422   //  gtk_tree_view_ensure_scroll_timeout (tree_view);
3423
3424   gtk_tree_view_get_drag_dest_row (tree_view, &path, &pos);
3425
3426   if (path == NULL)
3427     {
3428       /* Can't drop here. */
3429       gdk_drag_status (context, 0, time);
3430     }
3431   else
3432     {
3433       if (tree_view->priv->open_dest_timeout == 0 &&
3434           (pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER ||
3435            pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE))
3436         {
3437           tree_view->priv->open_dest_timeout =
3438             gtk_timeout_add (500, open_row_timeout, tree_view);
3439         }
3440
3441       if (target == gdk_atom_intern ("GTK_TREE_MODEL_ROW", FALSE))
3442         {
3443           /* Request data so we can use the source row when
3444            * determining whether to accept the drop
3445            */
3446           set_status_pending (context, suggested_action);
3447           gtk_drag_get_data (widget, context, target, time);
3448         }
3449       else
3450         {
3451           set_status_pending (context, 0);
3452           gdk_drag_status (context, suggested_action, time);
3453         }
3454     }
3455
3456   if (path)
3457     gtk_tree_path_free (path);
3458
3459   return TRUE;
3460 }
3461
3462
3463 static gboolean
3464 gtk_tree_view_drag_drop (GtkWidget        *widget,
3465                          GdkDragContext   *context,
3466                          gint              x,
3467                          gint              y,
3468                          guint             time)
3469 {
3470   GtkTreeView *tree_view;
3471   GtkTreePath *path;
3472   GdkDragAction suggested_action = 0;
3473   GdkAtom target = GDK_NONE;
3474   TreeViewDragInfo *di;
3475   GtkTreeModel *model;
3476
3477   tree_view = GTK_TREE_VIEW (widget);
3478
3479   model = gtk_tree_view_get_model (tree_view);
3480
3481   remove_scroll_timeout (GTK_TREE_VIEW (widget));
3482   remove_open_timeout (GTK_TREE_VIEW (widget));
3483
3484   di = get_info (tree_view);
3485
3486   if (di == NULL)
3487     return FALSE;
3488
3489   if (!check_model_dnd (model, GTK_TYPE_TREE_DRAG_DEST, "drag_drop"))
3490     return FALSE;
3491
3492   if (!set_destination_row (tree_view, context, x, y, &suggested_action, &target))
3493     return FALSE;
3494
3495   path = get_logical_dest_row (tree_view);
3496
3497   if (target != GDK_NONE && path != NULL)
3498     {
3499       /* in case a motion had requested drag data, change things so we
3500        * treat drag data receives as a drop.
3501        */
3502       set_status_pending (context, 0);
3503
3504       set_dest_row (context, model, path);
3505     }
3506
3507   if (path)
3508     gtk_tree_path_free (path);
3509
3510   /* Unset this thing */
3511   gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
3512                                    NULL,
3513                                    GTK_TREE_VIEW_DROP_BEFORE);
3514
3515   if (target != GDK_NONE)
3516     {
3517       gtk_drag_get_data (widget, context, target, time);
3518       return TRUE;
3519     }
3520   else
3521     return FALSE;
3522 }
3523
3524 static void
3525 gtk_tree_view_drag_data_received (GtkWidget        *widget,
3526                                   GdkDragContext   *context,
3527                                   gint              x,
3528                                   gint              y,
3529                                   GtkSelectionData *selection_data,
3530                                   guint             info,
3531                                   guint             time)
3532 {
3533   GtkTreePath *path;
3534   TreeViewDragInfo *di;
3535   gboolean accepted = FALSE;
3536   GtkTreeModel *model;
3537   GtkTreeView *tree_view;
3538   GtkTreePath *dest_row;
3539   GdkDragAction suggested_action;
3540
3541   tree_view = GTK_TREE_VIEW (widget);
3542
3543   model = gtk_tree_view_get_model (tree_view);
3544
3545   if (!check_model_dnd (model, GTK_TYPE_TREE_DRAG_DEST, "drag_data_received"))
3546     return;
3547
3548   di = get_info (tree_view);
3549
3550   if (di == NULL)
3551     return;
3552
3553   suggested_action = get_status_pending (context);
3554
3555   if (suggested_action)
3556     {
3557       /* We are getting this data due to a request in drag_motion,
3558        * rather than due to a request in drag_drop, so we are just
3559        * supposed to call drag_status, not actually paste in the
3560        * data.
3561        */
3562       path = get_logical_dest_row (tree_view);
3563
3564       if (path == NULL)
3565         suggested_action = 0;
3566
3567       if (suggested_action)
3568         {
3569           GtkTreeModel *src_model = NULL;
3570           GtkTreePath *src_path = NULL;
3571
3572           if (!gtk_selection_data_get_tree_row (selection_data,
3573                                                 &src_model,
3574                                                 &src_path))
3575             suggested_action = 0;
3576
3577           if (suggested_action)
3578             {
3579               if (!gtk_tree_drag_dest_row_drop_possible (GTK_TREE_DRAG_DEST (model),
3580                                                          src_model,
3581                                                          src_path,
3582                                                          path))
3583                 suggested_action = 0;
3584
3585               gtk_tree_path_free (src_path);
3586             }
3587         }
3588
3589       gdk_drag_status (context, suggested_action, time);
3590
3591       if (path)
3592         gtk_tree_path_free (path);
3593
3594       /* If you can't drop, remove user drop indicator until the next motion */
3595       if (suggested_action == 0)
3596         gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
3597                                          NULL,
3598                                          GTK_TREE_VIEW_DROP_BEFORE);
3599
3600       return;
3601     }
3602
3603   dest_row = get_dest_row (context);
3604
3605   if (dest_row == NULL)
3606     return;
3607
3608   if (selection_data->length >= 0)
3609     {
3610       if (gtk_tree_drag_dest_drag_data_received (GTK_TREE_DRAG_DEST (model),
3611                                                  dest_row,
3612                                                  selection_data))
3613         accepted = TRUE;
3614     }
3615
3616   gtk_drag_finish (context,
3617                    accepted,
3618                    (context->action == GDK_ACTION_MOVE),
3619                    time);
3620
3621   gtk_tree_path_free (dest_row);
3622
3623   /* drop dest_row */
3624   set_dest_row (context, NULL, NULL);
3625 }
3626
3627
3628
3629 /* GtkContainer Methods
3630  */
3631
3632
3633 static void
3634 gtk_tree_view_remove (GtkContainer *container,
3635                       GtkWidget    *widget)
3636 {
3637   GtkTreeView *tree_view;
3638   GtkTreeViewChild *child = NULL;
3639   GList *tmp_list;
3640
3641   g_return_if_fail (GTK_IS_TREE_VIEW (container));
3642
3643   tree_view = GTK_TREE_VIEW (container);
3644
3645   tmp_list = tree_view->priv->children;
3646   while (tmp_list)
3647     {
3648       child = tmp_list->data;
3649       if (child->widget == widget)
3650         {
3651           gtk_widget_unparent (widget);
3652
3653           tree_view->priv->children = g_list_remove_link (tree_view->priv->children, tmp_list);
3654           g_list_free_1 (tmp_list);
3655           g_free (child);
3656           return;
3657         }
3658
3659       tmp_list = tmp_list->next;
3660     }
3661
3662   tmp_list = tree_view->priv->columns;
3663
3664   while (tmp_list)
3665     {
3666       GtkTreeViewColumn *column;
3667       column = tmp_list->data;
3668       if (column->button == widget)
3669         {
3670           gtk_widget_unparent (widget);
3671           return;
3672         }
3673       tmp_list = tmp_list->next;
3674     }
3675
3676 }
3677
3678 static void
3679 gtk_tree_view_forall (GtkContainer *container,
3680                       gboolean      include_internals,
3681                       GtkCallback   callback,
3682                       gpointer      callback_data)
3683 {
3684   GtkTreeView *tree_view;
3685   GtkTreeViewChild *child = NULL;
3686   GtkTreeViewColumn *column;
3687   GList *tmp_list;
3688
3689   g_return_if_fail (GTK_IS_TREE_VIEW (container));
3690   g_return_if_fail (callback != NULL);
3691
3692   tree_view = GTK_TREE_VIEW (container);
3693
3694   tmp_list = tree_view->priv->children;
3695   while (tmp_list)
3696     {
3697       child = tmp_list->data;
3698       tmp_list = tmp_list->next;
3699
3700       (* callback) (child->widget, callback_data);
3701     }
3702   if (include_internals == FALSE)
3703     return;
3704
3705   for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list = tmp_list->next)
3706     {
3707       column = tmp_list->data;
3708
3709       if (column->button)
3710         (* callback) (column->button, callback_data);
3711     }
3712 }
3713
3714 /* Returns TRUE if the focus is within the headers, after the focus operation is
3715  * done
3716  */
3717 static gboolean
3718 gtk_tree_view_header_focus (GtkTreeView      *tree_view,
3719                             GtkDirectionType  dir)
3720 {
3721   GtkWidget *focus_child;
3722   GtkContainer *container;
3723
3724   GList *last_column, *first_column;
3725   GList *tmp_list;
3726
3727   if (! GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_HEADERS_VISIBLE))
3728     return FALSE;
3729
3730   focus_child = GTK_CONTAINER (tree_view)->focus_child;
3731   container = GTK_CONTAINER (tree_view);
3732
3733   last_column = g_list_last (tree_view->priv->columns);
3734   while (last_column)
3735     {
3736       if (GTK_WIDGET_CAN_FOCUS (GTK_TREE_VIEW_COLUMN (last_column->data)->button) &&
3737           GTK_TREE_VIEW_COLUMN (last_column->data)->visible)
3738         break;
3739       last_column = last_column->prev;
3740     }
3741
3742   /* No headers are visible, or are focusable.  We can't focus in or out.
3743    */
3744   if (last_column == NULL)
3745     return FALSE;
3746
3747   first_column = tree_view->priv->columns;
3748   while (first_column)
3749     {
3750       if (GTK_WIDGET_CAN_FOCUS (GTK_TREE_VIEW_COLUMN (first_column->data)->button) &&
3751           GTK_TREE_VIEW_COLUMN (first_column->data)->visible)
3752         break;
3753       first_column = first_column->next;
3754     }
3755
3756   switch (dir)
3757     {
3758     case GTK_DIR_TAB_BACKWARD:
3759     case GTK_DIR_TAB_FORWARD:
3760     case GTK_DIR_UP:
3761     case GTK_DIR_DOWN:
3762       if (focus_child == NULL)
3763         {
3764           if (tree_view->priv->focus_column != NULL)
3765             focus_child = tree_view->priv->focus_column->button;
3766           else
3767             focus_child = GTK_TREE_VIEW_COLUMN (first_column->data)->button;
3768           gtk_widget_grab_focus (focus_child);
3769           break;
3770         }
3771       return FALSE;
3772
3773     case GTK_DIR_LEFT:
3774     case GTK_DIR_RIGHT:
3775       if (focus_child == NULL)
3776         {
3777           if (tree_view->priv->focus_column != NULL)
3778             focus_child = tree_view->priv->focus_column->button;
3779           else if (dir == GTK_DIR_LEFT)
3780             focus_child = GTK_TREE_VIEW_COLUMN (last_column->data)->button;
3781           else
3782             focus_child = GTK_TREE_VIEW_COLUMN (first_column->data)->button;
3783           gtk_widget_grab_focus (focus_child);
3784           break;
3785         }
3786
3787       if (gtk_container_focus (GTK_CONTAINER (focus_child), dir))
3788         {
3789           /* The focus moves inside the button. */
3790           /* This is probably a great example of bad UI */
3791           break;
3792         }
3793
3794       /* We need to move the focus among the row of buttons. */
3795       for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list = tmp_list->next)
3796         if (GTK_TREE_VIEW_COLUMN (tmp_list->data)->button == focus_child)
3797           break;
3798
3799       if (tmp_list == first_column && dir == GTK_DIR_LEFT)
3800         {
3801           focus_child = GTK_TREE_VIEW_COLUMN (last_column->data)->button;
3802           gtk_widget_grab_focus (focus_child);
3803           break;
3804         }
3805       else if (tmp_list == last_column && dir == GTK_DIR_RIGHT)
3806         {
3807           focus_child = GTK_TREE_VIEW_COLUMN (first_column->data)->button;
3808           gtk_widget_grab_focus (focus_child);
3809           break;
3810         }
3811
3812       while (tmp_list)
3813         {
3814           GtkTreeViewColumn *column;
3815
3816           if (dir == GTK_DIR_RIGHT)
3817             tmp_list = tmp_list->next;
3818           else
3819             tmp_list = tmp_list->prev;
3820
3821           if (tmp_list == NULL)
3822             {
3823               g_warning ("Internal button not found");
3824               break;
3825             }
3826           column = tmp_list->data;
3827           if (column->button &&
3828               column->visible &&
3829               GTK_WIDGET_CAN_FOCUS (column->button))
3830             {
3831               focus_child = column->button;
3832               gtk_widget_grab_focus (column->button);
3833               break;
3834             }
3835         }
3836       break;
3837     default:
3838       g_assert_not_reached ();
3839       break;
3840     }
3841
3842   /* if focus child is non-null, we assume it's been set to the current focus child
3843    */
3844   if (focus_child)
3845     {
3846       for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list = tmp_list->next)
3847         if (GTK_TREE_VIEW_COLUMN (tmp_list->data)->button == focus_child)
3848           break;
3849
3850       tree_view->priv->focus_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
3851
3852       /* If the following isn't true, then the view is smaller then the scrollpane.
3853        */
3854       if ((focus_child->allocation.x + focus_child->allocation.width) <=
3855           (tree_view->priv->hadjustment->upper))
3856         {
3857           /* Scroll to the button, if needed */
3858           if ((tree_view->priv->hadjustment->value + tree_view->priv->hadjustment->page_size) <
3859               (focus_child->allocation.x + focus_child->allocation.width))
3860             gtk_adjustment_set_value (tree_view->priv->hadjustment,
3861                                       focus_child->allocation.x + focus_child->allocation.width -
3862                                       tree_view->priv->hadjustment->page_size);
3863           else if (tree_view->priv->hadjustment->value > focus_child->allocation.x)
3864             gtk_adjustment_set_value (tree_view->priv->hadjustment,
3865                                       focus_child->allocation.x);
3866         }
3867     }
3868
3869   return (focus_child != NULL);
3870 }
3871
3872 /* We make the assumption that if container->focus_child != NULL, the focus must
3873  * be in the header.  For now, this is accurate.  It may not be in the future.
3874  */
3875
3876 /* The sordid relationship between focus_column and scroll_column:
3877  *
3878  * The focus_column represents the column that currently has keyboard focus, and
3879  * is used when navigating columns by keyboard.  scroll_column is used for
3880  * handling scrolling by keyboard, such that in cases.
3881  */
3882 static gint
3883 gtk_tree_view_focus (GtkContainer     *container,
3884                      GtkDirectionType  direction)
3885 {
3886   GtkTreeView *tree_view;
3887   GtkWidget *focus_child;
3888   GdkEvent *event;
3889   GtkRBTree *cursor_tree;
3890   GtkRBNode *cursor_node;
3891   GtkTreePath *cursor_path;
3892
3893   g_return_val_if_fail (GTK_IS_TREE_VIEW (container), FALSE);
3894   g_return_val_if_fail (GTK_WIDGET_VISIBLE (container), FALSE);
3895
3896   tree_view = GTK_TREE_VIEW (container);
3897
3898   if (!GTK_WIDGET_IS_SENSITIVE (container))
3899     return FALSE;
3900
3901   focus_child = container->focus_child;
3902
3903   /* Case 1.  Headers currently have focus. */
3904   if (focus_child)
3905     {
3906       switch (direction)
3907         {
3908         case GTK_DIR_LEFT:
3909         case GTK_DIR_RIGHT:
3910           gtk_tree_view_header_focus (tree_view, direction);
3911           return TRUE;
3912         case GTK_DIR_TAB_BACKWARD:
3913         case GTK_DIR_UP:
3914           return FALSE;
3915         case GTK_DIR_TAB_FORWARD:
3916         case GTK_DIR_DOWN:
3917           if (tree_view->priv->tree == NULL)
3918             return FALSE;
3919           gtk_tree_view_set_cursor_focus (tree_view);
3920           return TRUE;
3921         }
3922     }
3923
3924   /* Case 2. We don't have focus at all. */
3925   if (!GTK_WIDGET_HAS_FOCUS (container))
3926     {
3927       if (tree_view->priv->tree == NULL &&
3928           (direction == GTK_DIR_TAB_BACKWARD ||
3929            direction == GTK_DIR_UP))
3930         return gtk_tree_view_header_focus (tree_view, direction);
3931       if (((direction == GTK_DIR_TAB_FORWARD) ||
3932            (direction == GTK_DIR_RIGHT) ||
3933            (direction == GTK_DIR_DOWN) ||
3934            (direction == GTK_DIR_LEFT)) &&
3935           gtk_tree_view_header_focus (tree_view, direction))
3936         return TRUE;
3937
3938       if (tree_view->priv->tree == NULL)
3939         return FALSE;
3940       gtk_tree_view_set_cursor_focus (tree_view);
3941       return TRUE;
3942     }
3943
3944   /* Case 3. We have focus already. */
3945   if (tree_view->priv->tree == NULL)
3946     return gtk_tree_view_header_focus (tree_view, direction);
3947
3948   if (direction == GTK_DIR_TAB_BACKWARD)
3949     return (gtk_tree_view_header_focus (tree_view, direction));
3950   else if (direction == GTK_DIR_TAB_FORWARD)
3951     return FALSE;
3952
3953   /* Other directions caught by the keybindings */
3954   gtk_tree_view_set_cursor_focus (tree_view);
3955   return TRUE;
3956 }
3957
3958
3959 static void
3960 gtk_tree_view_set_focus_child (GtkContainer *container,
3961                                GtkWidget    *child)
3962 {
3963   GtkTreeView *tree_view = GTK_TREE_VIEW (container);
3964   GList *list;
3965
3966   for (list = tree_view->priv->columns; list; list = list->next)
3967     {
3968       if (GTK_TREE_VIEW_COLUMN (list->data)->button == child)
3969         {
3970           tree_view->priv->focus_column = GTK_TREE_VIEW_COLUMN (list->data);
3971           break;
3972         }
3973     }
3974
3975   (* parent_class->set_focus_child) (container, child);
3976 }
3977
3978 static void
3979 gtk_tree_view_set_adjustments (GtkTreeView   *tree_view,
3980                                GtkAdjustment *hadj,
3981                                GtkAdjustment *vadj)
3982 {
3983   gboolean need_adjust = FALSE;
3984
3985   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
3986
3987   if (hadj)
3988     g_return_if_fail (GTK_IS_ADJUSTMENT (hadj));
3989   else
3990     hadj = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 0.0, 0.0, 0.0, 0.0));
3991   if (vadj)
3992     g_return_if_fail (GTK_IS_ADJUSTMENT (vadj));
3993   else
3994     vadj = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 0.0, 0.0, 0.0, 0.0));
3995
3996   if (tree_view->priv->hadjustment && (tree_view->priv->hadjustment != hadj))
3997     {
3998       gtk_signal_disconnect_by_data (GTK_OBJECT (tree_view->priv->hadjustment), tree_view);
3999       gtk_object_unref (GTK_OBJECT (tree_view->priv->hadjustment));
4000     }
4001
4002   if (tree_view->priv->vadjustment && (tree_view->priv->vadjustment != vadj))
4003     {
4004       gtk_signal_disconnect_by_data (GTK_OBJECT (tree_view->priv->vadjustment), tree_view);
4005       gtk_object_unref (GTK_OBJECT (tree_view->priv->vadjustment));
4006     }
4007
4008   if (tree_view->priv->hadjustment != hadj)
4009     {
4010       tree_view->priv->hadjustment = hadj;
4011       gtk_object_ref (GTK_OBJECT (tree_view->priv->hadjustment));
4012       gtk_object_sink (GTK_OBJECT (tree_view->priv->hadjustment));
4013
4014       gtk_signal_connect (GTK_OBJECT (tree_view->priv->hadjustment), "value_changed",
4015                           (GtkSignalFunc) gtk_tree_view_adjustment_changed,
4016                           tree_view);
4017       need_adjust = TRUE;
4018     }
4019
4020   if (tree_view->priv->vadjustment != vadj)
4021     {
4022       tree_view->priv->vadjustment = vadj;
4023       gtk_object_ref (GTK_OBJECT (tree_view->priv->vadjustment));
4024       gtk_object_sink (GTK_OBJECT (tree_view->priv->vadjustment));
4025
4026       gtk_signal_connect (GTK_OBJECT (tree_view->priv->vadjustment), "value_changed",
4027                           (GtkSignalFunc) gtk_tree_view_adjustment_changed,
4028                           tree_view);
4029       need_adjust = TRUE;
4030     }
4031
4032   if (need_adjust)
4033     gtk_tree_view_adjustment_changed (NULL, tree_view);
4034 }
4035
4036 static void
4037 gtk_tree_view_real_move_cursor (GtkTreeView       *tree_view,
4038                                 GtkMovementStep    step,
4039                                 gint               count,
4040                                 gboolean           extend_selection)
4041 {
4042   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
4043   g_return_if_fail (step == GTK_MOVEMENT_LOGICAL_POSITIONS ||
4044                     step == GTK_MOVEMENT_VISUAL_POSITIONS ||
4045                     step == GTK_MOVEMENT_DISPLAY_LINES ||
4046                     step == GTK_MOVEMENT_PAGES ||
4047                     step == GTK_MOVEMENT_BUFFER_ENDS);
4048
4049   if (tree_view->priv->tree == NULL)
4050     return;
4051
4052   switch (step)
4053     {
4054       /* currently we make no distinction.  When we go bi-di, we need to */
4055     case GTK_MOVEMENT_LOGICAL_POSITIONS:
4056     case GTK_MOVEMENT_VISUAL_POSITIONS:
4057       gtk_tree_view_move_cursor_left_right (tree_view, count);
4058       break;
4059     case GTK_MOVEMENT_DISPLAY_LINES:
4060       gtk_tree_view_move_cursor_up_down (tree_view, count, extend_selection);
4061       break;
4062     case GTK_MOVEMENT_PAGES:
4063       gtk_tree_view_move_cursor_page_up_down (tree_view, count, extend_selection);
4064       break;
4065     case GTK_MOVEMENT_BUFFER_ENDS:
4066       gtk_tree_view_move_cursor_start_end (tree_view, count, extend_selection);
4067       break;
4068     default:
4069       g_assert_not_reached ();
4070     }
4071 }
4072
4073 /* TreeModel Callbacks
4074  */
4075
4076 static void
4077 gtk_tree_view_range_changed (GtkTreeModel *model,
4078                              GtkTreePath  *path,
4079                              GtkTreeIter  *iter,
4080                              GtkTreePath  *end_path,
4081                              GtkTreeIter  *end_iter,
4082                              gpointer      data)
4083 {
4084   GtkTreeView *tree_view = (GtkTreeView *)data;
4085   GtkRBTree *tree;
4086   GtkRBNode *node;
4087   gint height;
4088   gboolean dirty_marked;
4089   gboolean free_path = FALSE;
4090   gint vertical_separator;
4091
4092
4093   g_return_if_fail (path != NULL || iter != NULL);
4094
4095   gtk_widget_style_get (GTK_WIDGET (data), "vertical_separator", &vertical_separator, NULL);
4096
4097   if (path == NULL)
4098     {
4099       path = gtk_tree_model_get_path (model, iter);
4100       free_path = TRUE;
4101     }
4102   else if (iter == NULL)
4103     gtk_tree_model_get_iter (model, iter, path);
4104
4105   if (_gtk_tree_view_find_node (tree_view,
4106                                 path,
4107                                 &tree,
4108                                 &node))
4109     /* We aren't actually showing the node */
4110     goto done;
4111
4112   if (tree == NULL)
4113     goto done;
4114
4115   dirty_marked = gtk_tree_view_discover_dirty_iter (tree_view,
4116                                                     iter,
4117                                                     gtk_tree_path_get_depth (path),
4118                                                     &height);
4119
4120   if (GTK_RBNODE_GET_HEIGHT (node) != height + vertical_separator)
4121     {
4122       _gtk_rbtree_node_set_height (tree, node, height + vertical_separator);
4123       gtk_widget_queue_resize (GTK_WIDGET (data));
4124       goto done;
4125     }
4126   if (dirty_marked)
4127     gtk_widget_queue_resize (GTK_WIDGET (data));
4128   else
4129     gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
4130
4131  done:
4132   if (free_path)
4133     gtk_tree_path_free (path);
4134 }
4135
4136 static void
4137 gtk_tree_view_inserted (GtkTreeModel *model,
4138                         GtkTreePath  *path,
4139                         GtkTreeIter  *iter,
4140                         gpointer      data)
4141 {
4142   GtkTreeView *tree_view = (GtkTreeView *) data;
4143   gint *indices;
4144   GtkRBTree *tmptree, *tree;
4145   GtkRBNode *tmpnode = NULL;
4146   gint max_height;
4147   gint depth;
4148   gint i = 0;
4149   gboolean free_path = FALSE;
4150
4151   if (tree_view->priv->tree == NULL)
4152     tree_view->priv->tree = _gtk_rbtree_new ();
4153
4154   tmptree = tree = tree_view->priv->tree;
4155   g_return_if_fail (path != NULL || iter != NULL);
4156
4157   if (path == NULL)
4158     {
4159       path = gtk_tree_model_get_path (model, iter);
4160       free_path = TRUE;
4161     }
4162   else if (iter == NULL)
4163     gtk_tree_model_get_iter (model, iter, path);
4164
4165   /* Update all row-references */
4166   gtk_tree_row_reference_inserted (G_OBJECT (data), path);
4167
4168   depth = gtk_tree_path_get_depth (path);
4169   indices = gtk_tree_path_get_indices (path);
4170
4171   /* First, find the parent tree */
4172   while (i < depth - 1)
4173     {
4174       if (tmptree == NULL)
4175         {
4176           /* We aren't showing the node */
4177           goto done;
4178         }
4179
4180       tmpnode = _gtk_rbtree_find_count (tmptree, indices[i] + 1);
4181       if (tmpnode == NULL)
4182         {
4183           g_warning ("A node was inserted with a parent that's not in the tree.\n" \
4184                      "This possibly means that a GtkTreeModel inserted a child node\n" \
4185                      "before the parent was inserted.");
4186           goto done;
4187         }
4188       else if (!GTK_RBNODE_FLAG_SET (tmpnode, GTK_RBNODE_IS_PARENT))
4189         {
4190           /* FIXME enforce correct behavior on model, probably */
4191           /* In theory, the model should have emitted has_child_toggled here.  We
4192            * try to catch it anyway, just to be safe, in case the model hasn't.
4193            */
4194           GtkTreePath *tmppath = _gtk_tree_view_find_path (tree_view,
4195                                                            tree,
4196                                                            tmpnode);
4197           gtk_tree_view_has_child_toggled (model, tmppath, NULL, data);
4198           gtk_tree_path_free (tmppath);
4199           goto done;
4200         }
4201
4202       tmptree = tmpnode->children;
4203       tree = tmptree;
4204       i++;
4205     }
4206
4207   if (tree == NULL)
4208     goto done;
4209
4210   /* ref the node */
4211   gtk_tree_model_ref_node (tree_view->priv->model, iter);
4212   max_height = gtk_tree_view_insert_iter_height (tree_view,
4213                                                  tree,
4214                                                  iter,
4215                                                  depth);
4216   if (indices[depth - 1] == 0)
4217     {
4218       tmpnode = _gtk_rbtree_find_count (tree, 1);
4219       _gtk_rbtree_insert_before (tree, tmpnode, max_height);
4220     }
4221   else
4222     {
4223       tmpnode = _gtk_rbtree_find_count (tree, indices[depth - 1]);
4224       _gtk_rbtree_insert_after (tree, tmpnode, max_height);
4225     }
4226
4227   _gtk_tree_view_update_size (tree_view);
4228
4229  done:
4230   if (free_path)
4231     gtk_tree_path_free (path);
4232 }
4233
4234 static void
4235 gtk_tree_view_has_child_toggled (GtkTreeModel *model,
4236                                  GtkTreePath  *path,
4237                                  GtkTreeIter  *iter,
4238                                  gpointer      data)
4239 {
4240   GtkTreeView *tree_view = (GtkTreeView *)data;
4241   GtkTreeIter real_iter;
4242   gboolean has_child;
4243   GtkRBTree *tree;
4244   GtkRBNode *node;
4245   gboolean free_path = FALSE;
4246
4247   g_return_if_fail (path != NULL || iter != NULL);
4248
4249   if (iter)
4250     real_iter = *iter;
4251
4252   if (path == NULL)
4253     {
4254       path = gtk_tree_model_get_path (model, iter);
4255       free_path = TRUE;
4256     }
4257   else if (iter == NULL)
4258     gtk_tree_model_get_iter (model, &real_iter, path);
4259
4260   if (_gtk_tree_view_find_node (tree_view,
4261                                 path,
4262                                 &tree,
4263                                 &node))
4264     /* We aren't actually showing the node */
4265     goto done;
4266
4267   if (tree == NULL)
4268     goto done;
4269
4270   has_child = gtk_tree_model_iter_has_child (model, &real_iter);
4271   /* Sanity check.
4272    */
4273   if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT) == has_child)
4274     goto done;
4275
4276   if (has_child)
4277     GTK_RBNODE_SET_FLAG (node, GTK_RBNODE_IS_PARENT);
4278   else
4279     GTK_RBNODE_UNSET_FLAG (node, GTK_RBNODE_IS_PARENT);
4280
4281   if (has_child && GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_IS_LIST))
4282     {
4283       GTK_TREE_VIEW_UNSET_FLAG (tree_view, GTK_TREE_VIEW_IS_LIST);
4284       if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_SHOW_EXPANDERS))
4285         {
4286           GList *list;
4287
4288           for (list = tree_view->priv->columns; list; list = list->next)
4289             if (GTK_TREE_VIEW_COLUMN (list->data)->visible)
4290               {
4291                 GTK_TREE_VIEW_COLUMN (list->data)->dirty = TRUE;
4292                 break;
4293               }
4294         }
4295       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
4296     }
4297   else
4298     {
4299       /* FIXME: Just redraw the node */
4300       gtk_widget_queue_draw (GTK_WIDGET (tree_view));
4301     }
4302
4303  done:
4304   if (free_path)
4305     gtk_tree_path_free (path);
4306 }
4307
4308 static void
4309 gtk_tree_view_deleted (GtkTreeModel *model,
4310                        GtkTreePath  *path,
4311                        gpointer      data)
4312 {
4313   GtkTreeView *tree_view = (GtkTreeView *)data;
4314   GtkRBTree *tree;
4315   GtkRBNode *node;
4316   GList *list;
4317
4318   g_return_if_fail (path != NULL);
4319
4320   if (_gtk_tree_view_find_node (tree_view, path, &tree, &node))
4321     return;
4322
4323   if (tree == NULL)
4324     return;
4325
4326   gtk_tree_row_reference_deleted (G_OBJECT (data), path);
4327
4328   /* next, update the selection */
4329   if (tree_view->priv->anchor)
4330     {
4331       GtkTreePath *anchor_path;
4332
4333       /* the row reference may not have been updated yet. If it has not,
4334        * then anchor_path and path being equal indicates that the anchor
4335        * row was deleted. If it has, then anchor_path == NULL indicates the
4336        * the anchor row was deleted.
4337        */
4338
4339       anchor_path = gtk_tree_row_reference_get_path (tree_view->priv->anchor);
4340
4341       if (anchor_path == NULL ||
4342           gtk_tree_path_compare (path, anchor_path) == 0)
4343         {
4344           if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED) &&
4345               tree_view->priv->selection)
4346             g_signal_emit_by_name (G_OBJECT (tree_view->priv->selection), "changed");
4347         }
4348
4349       if (anchor_path)
4350         gtk_tree_path_free (anchor_path);
4351     }
4352
4353   for (list = tree_view->priv->columns; list; list = list->next)
4354     if (((GtkTreeViewColumn *)list->data)->visible &&
4355         ((GtkTreeViewColumn *)list->data)->column_type == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
4356       ((GtkTreeViewColumn *)list->data)->dirty = TRUE;
4357
4358   /* Ensure we don't have a dangling pointer to a dead node */
4359   ensure_unprelighted (tree_view);
4360
4361   g_assert (tree_view->priv->prelight_node == NULL);
4362
4363   if (tree->root->count == 1)
4364     {
4365       if (tree_view->priv->tree == tree)
4366         tree_view->priv->tree = NULL;
4367
4368       _gtk_rbtree_remove (tree);
4369     }
4370   else
4371     {
4372       _gtk_rbtree_remove_node (tree, node);
4373     }
4374
4375   _gtk_tree_view_update_size (GTK_TREE_VIEW (data));
4376 }
4377
4378
4379 static void
4380 gtk_tree_view_reordered (GtkTreeModel *model,
4381                          GtkTreePath  *parent,
4382                          GtkTreeIter  *iter,
4383                          gint         *new_order,
4384                          gpointer      data)
4385 {
4386   GtkTreeView *tree_view = GTK_TREE_VIEW (data);
4387   GtkRBTree *tree;
4388   GtkRBNode *node;
4389   gint len;
4390
4391   len = gtk_tree_model_iter_n_children (model, iter);
4392
4393   if (len < 2)
4394     return;
4395
4396   gtk_tree_row_reference_reordered (G_OBJECT (data),
4397                                     parent,
4398                                     iter,
4399                                     new_order);
4400
4401   if (_gtk_tree_view_find_node (tree_view,
4402                                 parent,
4403                                 &tree,
4404                                 &node))
4405     return;
4406
4407   /* We need to special case the parent path */
4408   if (tree == NULL)
4409     tree = tree_view->priv->tree;
4410   else
4411     tree = node->children;
4412
4413   if (tree == NULL)
4414     return;
4415
4416   /* FIXME: we need to unprelight our tree, if it's prelit. */
4417   _gtk_rbtree_reorder (tree, new_order, len);
4418
4419   gtk_widget_queue_draw (GTK_WIDGET (tree_view));
4420 }
4421
4422
4423 /* Internal tree functions
4424  */
4425
4426
4427 static void
4428 gtk_tree_view_get_background_xrange (GtkTreeView       *tree_view,
4429                                      GtkRBTree         *tree,
4430                                      GtkTreeViewColumn *column,
4431                                      gint              *x1,
4432                                      gint              *x2)
4433 {
4434   GtkTreeViewColumn *tmp_column = NULL;
4435   gint total_width;
4436   GList *list;
4437
4438   if (x1)
4439     *x1 = 0;
4440
4441   if (x2)
4442     *x2 = 0;
4443
4444   total_width = 0;
4445   for (list = tree_view->priv->columns; list; list = list->next)
4446     {
4447       tmp_column = list->data;
4448
4449       if (tmp_column == column)
4450         break;
4451
4452       if (tmp_column->visible)
4453         total_width += tmp_column->width;
4454     }
4455
4456   if (tmp_column != column)
4457     {
4458       g_warning (G_STRLOC": passed-in column isn't in the tree");
4459       return;
4460     }
4461
4462   if (x1)
4463     *x1 = total_width;
4464
4465   if (x2)
4466     {
4467       if (column->visible)
4468         *x2 = total_width + column->width;
4469       else
4470         *x2 = total_width; /* width of 0 */
4471     }
4472 }
4473
4474 static void
4475 gtk_tree_view_get_cell_xrange (GtkTreeView       *tree_view,
4476                                GtkRBTree         *tree,
4477                                GtkTreeViewColumn *column,
4478                                gint              *x1,
4479                                gint              *x2)
4480 {
4481   GtkTreeViewColumn *tmp_column = NULL;
4482   gint total_width;
4483   GList *list;
4484   gint i;
4485
4486   if (x1)
4487     *x1 = 0;
4488
4489   if (x2)
4490     *x2 = 0;
4491
4492   i = 0;
4493   total_width = 0;
4494   for (list = tree_view->priv->columns; list; list = list->next)
4495     {
4496       tmp_column = list->data;
4497
4498       if (tmp_column == column)
4499         break;
4500
4501       if (tmp_column->visible)
4502         total_width += tmp_column->width;
4503
4504       ++i;
4505     }
4506
4507   if (tmp_column != column)
4508     {
4509       g_warning (G_STRLOC": passed-in column isn't in the tree");
4510       return;
4511     }
4512
4513   /* Remember we're getting the cell range, i.e. the cell_area passed
4514    * to the cell renderer.
4515    */
4516
4517   if (i == tree_view->priv->expander_column)
4518     total_width += tree_view->priv->tab_offset * _gtk_rbtree_get_depth (tree);
4519
4520   if (x1)
4521     *x1 = total_width;
4522
4523   if (x2)
4524     {
4525       if (column->visible)
4526         *x2 = total_width + column->displayed_width;
4527       else
4528         *x2 = total_width; /* width of 0 */
4529     }
4530 }
4531
4532 static void
4533 gtk_tree_view_get_arrow_xrange (GtkTreeView *tree_view,
4534                                 gint        *x1,
4535                                 gint        *x2)
4536 {
4537   gint x_offset = 0;
4538   GList *list;
4539   GtkTreeViewColumn *tmp_column = NULL;
4540   gint total_width;
4541   gint i;
4542
4543   i = 0;
4544   total_width = 0;
4545   for (list = tree_view->priv->columns; list; list = list->next)
4546     {
4547       tmp_column = list->data;
4548
4549       if (i == tree_view->priv->expander_column)
4550         {
4551           x_offset = total_width;
4552           break;
4553         }
4554
4555       if (tmp_column->visible)
4556         total_width += tmp_column->width;
4557
4558       ++i;
4559     }
4560
4561   if (x1)
4562     *x1 = x_offset;
4563
4564   if (tmp_column && tmp_column->visible)
4565     {
4566       /* +1 because x2 isn't included in the range. */
4567       if (x2)
4568         *x2 = x_offset + tree_view->priv->tab_offset + 1;
4569     }
4570   else
4571     {
4572       /* return an empty range, the expander column is hidden */
4573       if (x2)
4574         *x2 = x_offset;
4575     }
4576 }
4577
4578 static void
4579 gtk_tree_view_setup_model (GtkTreeView *tree_view)
4580 {
4581   GtkTreePath *path;
4582   GtkTreeIter iter;
4583
4584   tree_view->priv->tree = NULL;
4585
4586   g_signal_connectc (tree_view->priv->model,
4587                      "range_changed",
4588                      (GCallback) gtk_tree_view_range_changed,
4589                      tree_view,
4590                      FALSE);
4591   g_signal_connectc (tree_view->priv->model,
4592                      "inserted",
4593                      (GCallback) gtk_tree_view_inserted,
4594                      tree_view,
4595                      FALSE);
4596   g_signal_connectc (tree_view->priv->model,
4597                      "has_child_toggled",
4598                      (GCallback) gtk_tree_view_has_child_toggled,
4599                      tree_view,
4600                      FALSE);
4601   g_signal_connectc (tree_view->priv->model,
4602                      "deleted",
4603                      (GCallback) gtk_tree_view_deleted,
4604                      tree_view,
4605                      FALSE);
4606   g_signal_connectc (tree_view->priv->model,
4607                      "reordered",
4608                      (GCallback) gtk_tree_view_reordered,
4609                      tree_view,
4610                      FALSE);
4611
4612   if (tree_view->priv->columns == NULL)
4613     return;
4614
4615   path = gtk_tree_path_new_root ();
4616
4617   if (gtk_tree_model_get_iter (tree_view->priv->model, &iter, path))
4618     {
4619       tree_view->priv->tree = _gtk_rbtree_new ();
4620       gtk_tree_view_build_tree (tree_view, tree_view->priv->tree, &iter, 1, FALSE, GTK_WIDGET_REALIZED (tree_view));
4621     }
4622
4623   gtk_tree_path_free (path);
4624
4625   /*  FIXME: do I need to do this? gtk_tree_view_create_buttons (tree_view); */
4626
4627   GTK_TREE_VIEW_SET_FLAG (tree_view, GTK_TREE_VIEW_MODEL_SETUP);
4628 }
4629
4630 static gint
4631 gtk_tree_view_insert_iter_height (GtkTreeView *tree_view,
4632                                   GtkRBTree   *tree,
4633                                   GtkTreeIter *iter,
4634                                   gint         depth)
4635 {
4636   GtkTreeViewColumn *column;
4637   GList *list;
4638   gint max_height = 0;
4639   gint i;
4640   gint vertical_separator;
4641
4642   i = 0;
4643
4644   gtk_widget_style_get (GTK_WIDGET (tree_view), "vertical_separator", &vertical_separator, NULL);
4645   /* do stuff with node */
4646   for (list = tree_view->priv->columns; list; list = list->next)
4647     {
4648       gint height = 0, width = 0;
4649       column = list->data;
4650
4651       if (!column->visible)
4652         continue;
4653
4654       if (column->column_type == GTK_TREE_VIEW_COLUMN_FIXED)
4655         {
4656           ++i;
4657           continue;
4658         }
4659
4660       gtk_tree_view_column_cell_set_cell_data (column, tree_view->priv->model, iter);
4661
4662       gtk_tree_view_column_cell_get_size (column, NULL, NULL, NULL, &width, &height);
4663       max_height = MAX (max_height, vertical_separator + height);
4664
4665       if (i == tree_view->priv->expander_column &&
4666           TREE_VIEW_DRAW_EXPANDERS (tree_view))
4667         _gtk_tree_view_column_set_width (column,
4668                                         MAX (column->width, depth * tree_view->priv->tab_offset + width));
4669       else
4670         _gtk_tree_view_column_set_width (column,
4671                                         MAX (column->width, width));
4672
4673       ++i;
4674     }
4675   return max_height;
4676 }
4677
4678 static void
4679 gtk_tree_view_build_tree (GtkTreeView *tree_view,
4680                           GtkRBTree   *tree,
4681                           GtkTreeIter *iter,
4682                           gint         depth,
4683                           gboolean     recurse,
4684                           gboolean     calc_bounds)
4685 {
4686   GtkRBNode *temp = NULL;
4687   gint max_height;
4688
4689   do
4690     {
4691       max_height = 0;
4692       if (calc_bounds)
4693         max_height = gtk_tree_view_insert_iter_height (tree_view,
4694                                                        tree,
4695                                                        iter,
4696                                                        depth);
4697
4698       gtk_tree_model_ref_node (tree_view->priv->model, iter);
4699       temp = _gtk_rbtree_insert_after (tree, temp, max_height);
4700       if (recurse)
4701         {
4702           GtkTreeIter child;
4703
4704           if (gtk_tree_model_iter_children (tree_view->priv->model, &child, iter))
4705             {
4706               temp->children = _gtk_rbtree_new ();
4707               temp->children->parent_tree = tree;
4708               temp->children->parent_node = temp;
4709               gtk_tree_view_build_tree (tree_view, temp->children, &child, depth + 1, recurse, calc_bounds);
4710             }
4711         }
4712       if (gtk_tree_model_iter_has_child (tree_view->priv->model, iter))
4713         {
4714           if ((temp->flags&GTK_RBNODE_IS_PARENT) != GTK_RBNODE_IS_PARENT)
4715             temp->flags ^= GTK_RBNODE_IS_PARENT;
4716           GTK_TREE_VIEW_UNSET_FLAG (tree_view, GTK_TREE_VIEW_IS_LIST);
4717         }
4718     }
4719   while (gtk_tree_model_iter_next (tree_view->priv->model, iter));
4720 }
4721
4722 static void
4723 gtk_tree_view_calc_size (GtkTreeView *tree_view,
4724                          GtkRBTree   *tree,
4725                          GtkTreeIter *iter,
4726                          gint         depth)
4727 {
4728   GtkRBNode *temp;
4729   GtkTreeIter child;
4730   GList *list;
4731   GtkTreeViewColumn *column;
4732   gint max_height;
4733   gint vertical_separator;
4734   gint i;
4735
4736   TREE_VIEW_INTERNAL_ASSERT_VOID (tree != NULL);
4737
4738   gtk_widget_style_get (GTK_WIDGET (tree_view), "vertical_separator", &vertical_separator, NULL);
4739
4740   temp = tree->root;
4741   while (temp->left != tree->nil)
4742     temp = temp->left;
4743
4744   do
4745     {
4746       max_height = 0;
4747       /* Do stuff with node */
4748       for (list = tree_view->priv->columns, i = 0; i < tree_view->priv->n_columns; list = list->next, i++)
4749         {
4750           gint height = 0, width = 0;
4751           column = list->data;
4752
4753           if (!column->visible)
4754             continue;
4755
4756           gtk_tree_view_column_cell_set_cell_data (column, tree_view->priv->model, iter);
4757           gtk_tree_view_column_cell_get_size (column, NULL, NULL, NULL, &width, &height);
4758           max_height = MAX (max_height, vertical_separator + height);
4759
4760           /* FIXME: I'm getting the width of all nodes here. )-: */
4761           if (column->dirty == FALSE)
4762             continue;
4763
4764           if (column->column_type == GTK_TREE_VIEW_COLUMN_FIXED)
4765             {
4766               continue;
4767             }
4768           if (i == tree_view->priv->expander_column &&
4769               TREE_VIEW_DRAW_EXPANDERS (tree_view))
4770             _gtk_tree_view_column_set_width (column,
4771                                             MAX (column->width, depth * tree_view->priv->tab_offset + width));
4772           else
4773             _gtk_tree_view_column_set_width (column, MAX (column->width, width));
4774         }
4775
4776       _gtk_rbtree_node_set_height (tree, temp, max_height);
4777
4778       if (temp->children != NULL &&
4779           gtk_tree_model_iter_children (tree_view->priv->model, &child, iter))
4780         gtk_tree_view_calc_size (tree_view, temp->children, &child, depth + 1);
4781       temp = _gtk_rbtree_next (tree, temp);
4782     }
4783   while (gtk_tree_model_iter_next (tree_view->priv->model, iter));
4784 }
4785
4786 static gboolean
4787 gtk_tree_view_discover_dirty_iter (GtkTreeView *tree_view,
4788                                    GtkTreeIter *iter,
4789                                    gint         depth,
4790                                    gint        *height)
4791 {
4792   GtkTreeViewColumn *column;
4793   GList *list;
4794   gint i;
4795   gboolean retval = FALSE;
4796   gint tmpheight;
4797
4798   if (height)
4799     *height = 0;
4800
4801   for (i = 0, list = tree_view->priv->columns; list; list = list->next, i++)
4802     {
4803       gint width;
4804       column = list->data;
4805       if (column->dirty == TRUE || column->column_type == GTK_TREE_VIEW_COLUMN_FIXED)
4806         continue;
4807       if (!column->visible)
4808         continue;
4809
4810       gtk_tree_view_column_cell_set_cell_data (column, tree_view->priv->model, iter);
4811
4812       if (height)
4813         {
4814           gtk_tree_view_column_cell_get_size (column,
4815                                               NULL, NULL, NULL,
4816                                               &width, &tmpheight);
4817           *height = MAX (*height, tmpheight);
4818         }
4819       else
4820         {
4821           gtk_tree_view_column_cell_get_size (column,
4822                                               NULL, NULL, NULL,
4823                                               &width, NULL);
4824         }
4825       if (i == tree_view->priv->expander_column &&
4826           TREE_VIEW_DRAW_EXPANDERS (tree_view))
4827         {
4828           if (depth * tree_view->priv->tab_offset + width > column->width)
4829             {
4830               column->dirty = TRUE;
4831               retval = TRUE;
4832             }
4833         }
4834       else
4835         {
4836           if (width > column->width)
4837             {
4838               column->dirty = TRUE;
4839               retval = TRUE;
4840             }
4841         }
4842     }
4843
4844   return retval;
4845 }
4846
4847 static void
4848 gtk_tree_view_discover_dirty (GtkTreeView *tree_view,
4849                               GtkRBTree   *tree,
4850                               GtkTreeIter *iter,
4851                               gint         depth)
4852 {
4853   GtkRBNode *temp = tree->root;
4854   GtkTreeViewColumn *column;
4855   GList *list;
4856   GtkTreeIter child;
4857   gboolean is_all_dirty;
4858
4859   TREE_VIEW_INTERNAL_ASSERT_VOID (tree != NULL);
4860
4861   while (temp->left != tree->nil)
4862     temp = temp->left;
4863
4864   do
4865     {
4866       TREE_VIEW_INTERNAL_ASSERT_VOID (temp != NULL);
4867       is_all_dirty = TRUE;
4868       for (list = tree_view->priv->columns; list; list = list->next)
4869         {
4870           column = list->data;
4871           if (column->dirty == FALSE)
4872             {
4873               is_all_dirty = FALSE;
4874               break;
4875             }
4876         }
4877
4878       if (is_all_dirty)
4879         return;
4880
4881       gtk_tree_view_discover_dirty_iter (tree_view,
4882                                          iter,
4883                                          depth,
4884                                          FALSE);
4885       if (gtk_tree_model_iter_children (tree_view->priv->model, &child, iter) &&
4886           temp->children != NULL)
4887         gtk_tree_view_discover_dirty (tree_view, temp->children, &child, depth + 1);
4888       temp = _gtk_rbtree_next (tree, temp);
4889     }
4890   while (gtk_tree_model_iter_next (tree_view->priv->model, iter));
4891 }
4892
4893
4894 static void
4895 gtk_tree_view_check_dirty (GtkTreeView *tree_view)
4896 {
4897   GtkTreePath *path;
4898   gboolean dirty = FALSE;
4899   GList *list;
4900   GtkTreeViewColumn *column;
4901   GtkTreeIter iter;
4902
4903   if (!GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_MODEL_SETUP) &&
4904       tree_view->priv->model)
4905     gtk_tree_view_setup_model (tree_view);
4906
4907   for (list = tree_view->priv->columns; list; list = list->next)
4908     {
4909       column = list->data;
4910       if (column->dirty)
4911         {
4912           dirty = TRUE;
4913           if (column->column_type == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
4914             {
4915               gint w = 1;
4916
4917               if (column->button)
4918                 w = MAX (w, column->button->requisition.width);
4919
4920               _gtk_tree_view_column_set_width (column, w);
4921             }
4922         }
4923     }
4924
4925   if (dirty == FALSE)
4926     return;
4927
4928   if (tree_view->priv->model == NULL)
4929     return;
4930
4931   path = gtk_tree_path_new_root ();
4932   if (gtk_tree_model_get_iter (tree_view->priv->model, &iter, path))
4933     {
4934       gtk_tree_view_calc_size (tree_view, tree_view->priv->tree, &iter, 1);
4935       _gtk_tree_view_update_size (tree_view);
4936     }
4937
4938   gtk_tree_path_free (path);
4939
4940   for (list = tree_view->priv->columns; list; list = list->next)
4941     {
4942       column = list->data;
4943       column->dirty = FALSE;
4944     }
4945 }
4946
4947 /* Make sure the node is visible vertically */
4948 static void
4949 gtk_tree_view_clamp_node_visible (GtkTreeView *tree_view,
4950                                   GtkRBTree   *tree,
4951                                   GtkRBNode   *node)
4952 {
4953   gint offset;
4954
4955   offset = _gtk_rbtree_node_find_offset (tree, node);
4956
4957   /* we reverse the order, b/c in the unusual case of the
4958    * node's height being taller then the visible area, we'd rather
4959    * have the node flush to the top
4960    */
4961   if (offset + GTK_RBNODE_GET_HEIGHT (node) >
4962       tree_view->priv->vadjustment->value + tree_view->priv->vadjustment->page_size)
4963     gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment),
4964                               offset + GTK_RBNODE_GET_HEIGHT (node) -
4965                               tree_view->priv->vadjustment->page_size);
4966   if (offset < tree_view->priv->vadjustment->value)
4967     gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment),
4968                               offset);
4969 }
4970
4971 /* This function could be more efficient.
4972  * I'll optimize it if profiling seems to imply that
4973  * it's important
4974  */
4975 GtkTreePath *
4976 _gtk_tree_view_find_path (GtkTreeView *tree_view,
4977                           GtkRBTree   *tree,
4978                           GtkRBNode   *node)
4979 {
4980   GtkTreePath *path;
4981   GtkRBTree *tmp_tree;
4982   GtkRBNode *tmp_node, *last;
4983   gint count;
4984
4985   path = gtk_tree_path_new ();
4986
4987   g_return_val_if_fail (node != NULL, path);
4988   g_return_val_if_fail (node != tree->nil, path);
4989
4990   count = 1 + node->left->count;
4991
4992   last = node;
4993   tmp_node = node->parent;
4994   tmp_tree = tree;
4995   while (tmp_tree)
4996     {
4997       while (tmp_node != tmp_tree->nil)
4998         {
4999           if (tmp_node->right == last)
5000             count += 1 + tmp_node->left->count;
5001           last = tmp_node;
5002           tmp_node = tmp_node->parent;
5003         }
5004       gtk_tree_path_prepend_index (path, count - 1);
5005       last = tmp_tree->parent_node;
5006       tmp_tree = tmp_tree->parent_tree;
5007       if (last)
5008         {
5009           count = 1 + last->left->count;
5010           tmp_node = last->parent;
5011         }
5012     }
5013   return path;
5014 }
5015
5016 /* Returns TRUE if we ran out of tree before finding the path.
5017  */
5018 gboolean
5019 _gtk_tree_view_find_node (GtkTreeView  *tree_view,
5020                           GtkTreePath  *path,
5021                           GtkRBTree   **tree,
5022                           GtkRBNode   **node)
5023 {
5024   GtkRBNode *tmpnode = NULL;
5025   GtkRBTree *tmptree = tree_view->priv->tree;
5026   gint *indices = gtk_tree_path_get_indices (path);
5027   gint depth = gtk_tree_path_get_depth (path);
5028   gint i = 0;
5029
5030   *node = NULL;
5031   *tree = NULL;
5032
5033   if (depth == 0)
5034     return FALSE;
5035   do
5036     {
5037       if (tmptree == NULL)
5038         {
5039           *node = tmpnode;
5040           *tree = tmptree;
5041           return TRUE;
5042         }
5043       tmpnode = _gtk_rbtree_find_count (tmptree, indices[i] + 1);
5044       ++i;
5045       if (i >= depth)
5046         {
5047           *node = tmpnode;
5048           *tree = tmptree;
5049           return FALSE;
5050         }
5051       tmptree = tmpnode->children;
5052     }
5053   while (1);
5054 }
5055
5056 static void
5057 gtk_tree_view_add_move_binding (GtkBindingSet  *binding_set,
5058                                 guint           keyval,
5059                                 guint           modmask,
5060                                 GtkMovementStep step,
5061                                 gint            count)
5062 {
5063   g_return_if_fail ((modmask & GDK_SHIFT_MASK) == 0);
5064
5065   gtk_binding_entry_add_signal (binding_set, keyval, modmask,
5066                                 "move_cursor", 3,
5067                                 GTK_TYPE_ENUM, step,
5068                                 GTK_TYPE_INT, count,
5069                                 GTK_TYPE_BOOL, FALSE);
5070
5071   /* Selection-extending version */
5072   gtk_binding_entry_add_signal (binding_set, keyval, modmask | GDK_SHIFT_MASK,
5073                                 "move_cursor", 3,
5074                                 GTK_TYPE_ENUM, step,
5075                                 GTK_TYPE_INT, count,
5076                                 GTK_TYPE_BOOL, TRUE);
5077 }
5078
5079 static void
5080 gtk_tree_view_unref_tree_helper (GtkTreeModel *model,
5081                                  GtkTreeIter  *iter,
5082                                  GtkRBTree    *tree,
5083                                  GtkRBNode    *node)
5084 {
5085   do
5086     {
5087       g_return_if_fail (node != NULL);
5088
5089       if (node->children)
5090         {
5091           GtkTreeIter child;
5092           GtkRBTree *new_tree;
5093           GtkRBNode *new_node;
5094
5095           new_tree = node->children;
5096           new_node = new_tree->root;
5097
5098           while (new_node && new_node->left != new_tree->nil)
5099             new_node = new_node->left;
5100
5101           g_return_if_fail (gtk_tree_model_iter_children (model, &child, iter));
5102           gtk_tree_view_unref_tree_helper (model, &child, new_tree, new_node);
5103         }
5104
5105       gtk_tree_model_unref_node (model, iter);
5106       node = _gtk_rbtree_next (tree, node);
5107     }
5108   while (gtk_tree_model_iter_next (model, iter));
5109 }
5110
5111 static void
5112 gtk_tree_view_unref_tree (GtkTreeView *tree_view,
5113                           GtkRBTree   *tree)
5114 {
5115   GtkTreeIter iter;
5116   GtkTreePath *path;
5117   GtkRBNode *node;
5118
5119   node = tree->root;
5120   while (node && node->left != tree->nil)
5121     node = node->left;
5122
5123   g_return_if_fail (node != NULL);
5124   path = _gtk_tree_view_find_path (tree_view, tree, node);
5125   gtk_tree_model_get_iter (GTK_TREE_MODEL (tree_view->priv->model),
5126                            &iter, path);
5127   gtk_tree_view_unref_tree_helper (GTK_TREE_MODEL (tree_view->priv->model), &iter, tree, node);
5128   gtk_tree_path_free (path);
5129 }
5130
5131 static void
5132 gtk_tree_view_set_column_drag_info (GtkTreeView       *tree_view,
5133                                     GtkTreeViewColumn *column)
5134 {
5135   GtkTreeViewColumn *left_column;
5136   GtkTreeViewColumn *cur_column = NULL;
5137   GtkTreeViewColumnReorder *reorder;
5138
5139   GList *tmp_list;
5140   gint left;
5141
5142   /* We want to precalculate the motion list such that we know what column slots
5143    * are available.
5144    */
5145   left_column = NULL;
5146
5147   /* First, identify all possible drop spots */
5148   tmp_list = tree_view->priv->columns;
5149
5150   while (tmp_list)
5151     {
5152       g_assert (tmp_list);
5153
5154       cur_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
5155       tmp_list = tmp_list->next;
5156
5157       if (cur_column->visible == FALSE)
5158         continue;
5159
5160       /* If it's not the column moving and func tells us to skip over the column, we continue. */
5161       if (left_column != column && cur_column != column &&
5162           tree_view->priv->column_drop_func &&
5163           ! (* tree_view->priv->column_drop_func) (tree_view, column, left_column, cur_column, tree_view->priv->column_drop_func_data))
5164         {
5165           left_column = cur_column;
5166           continue;
5167         }
5168       reorder = g_new (GtkTreeViewColumnReorder, 1);
5169       reorder->left_column = left_column;
5170       left_column = reorder->right_column = cur_column;
5171
5172       tree_view->priv->column_drag_info = g_list_append (tree_view->priv->column_drag_info, reorder);
5173     }
5174
5175   /* Add the last one */
5176   if (tree_view->priv->column_drop_func == NULL ||
5177       ((left_column != column) &&
5178        (* tree_view->priv->column_drop_func) (tree_view, column, left_column, cur_column, tree_view->priv->column_drop_func_data)))
5179     {
5180       reorder = g_new (GtkTreeViewColumnReorder, 1);
5181       reorder->left_column = left_column;
5182       reorder->right_column = NULL;
5183       tree_view->priv->column_drag_info = g_list_append (tree_view->priv->column_drag_info, reorder);
5184     }
5185
5186   /* We quickly check to see if it even makes sense to reorder columns. */
5187   /* If there is nothing that can be moved, then we return */
5188
5189   if (tree_view->priv->column_drag_info == NULL)
5190     return;
5191
5192   /* We know there are always 2 slots possbile, as you can always return column. */
5193   /* If that's all there is, return */
5194   if (tree_view->priv->column_drag_info->next->next == NULL &&
5195       ((GtkTreeViewColumnReorder *)tree_view->priv->column_drag_info->data)->right_column == column &&
5196       ((GtkTreeViewColumnReorder *)tree_view->priv->column_drag_info->next->data)->left_column == column)
5197     {
5198       for (tmp_list = tree_view->priv->column_drag_info; tmp_list; tmp_list = tmp_list->next)
5199         g_free (tmp_list->data);
5200       g_list_free (tree_view->priv->column_drag_info);
5201       tree_view->priv->column_drag_info = NULL;
5202       return;
5203     }
5204   /* We fill in the ranges for the columns, now that we've isolated them */
5205   left = - TREE_VIEW_COLUMN_DRAG_DEAD_MULTIPLIER (tree_view);
5206
5207   for (tmp_list = tree_view->priv->column_drag_info; tmp_list; tmp_list = tmp_list->next)
5208     {
5209       reorder = (GtkTreeViewColumnReorder *) tmp_list->data;
5210
5211       reorder->left_align = left;
5212       if (tmp_list->next != NULL)
5213         {
5214           g_assert (tmp_list->next->data);
5215           left = reorder->right_align = (reorder->right_column->button->allocation.x +
5216                                          reorder->right_column->button->allocation.width +
5217                                          ((GtkTreeViewColumnReorder *)tmp_list->next->data)->left_column->button->allocation.x)/2;
5218         }
5219       else
5220         {
5221           gint width;
5222
5223           gdk_window_get_size (tree_view->priv->header_window, &width, NULL);
5224           reorder->right_align = width + TREE_VIEW_COLUMN_DRAG_DEAD_MULTIPLIER (tree_view);
5225         }
5226     }
5227 }
5228
5229 void
5230 _gtk_tree_view_column_start_drag (GtkTreeView       *tree_view,
5231                                   GtkTreeViewColumn *column)
5232 {
5233   GdkEvent send_event;
5234   GtkAllocation allocation;
5235   gint x, y, width, height;
5236
5237   g_return_if_fail (tree_view->priv->column_drag_info == NULL);
5238
5239   gtk_tree_view_set_column_drag_info (tree_view, column);
5240
5241   if (tree_view->priv->column_drag_info == NULL)
5242     return;
5243
5244   if (tree_view->priv->drag_window == NULL)
5245     {
5246       GdkWindowAttr attributes;
5247       guint attributes_mask;
5248
5249       attributes.window_type = GDK_WINDOW_CHILD;
5250       attributes.wclass = GDK_INPUT_OUTPUT;
5251       attributes.visual = gtk_widget_get_visual (GTK_WIDGET (tree_view));
5252       attributes.colormap = gtk_widget_get_colormap (GTK_WIDGET (tree_view));
5253       attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK;
5254       attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
5255
5256       tree_view->priv->drag_window = gdk_window_new (tree_view->priv->bin_window,
5257                                                      &attributes,
5258                                                      attributes_mask);
5259       gdk_window_set_user_data (tree_view->priv->drag_window, GTK_WIDGET (tree_view));
5260     }
5261
5262   gdk_pointer_ungrab (GDK_CURRENT_TIME);
5263   gdk_keyboard_ungrab (GDK_CURRENT_TIME);
5264
5265   gtk_grab_remove (column->button);
5266
5267   send_event.crossing.type = GDK_LEAVE_NOTIFY;
5268   send_event.crossing.send_event = TRUE;
5269   send_event.crossing.window = column->button->window;
5270   send_event.crossing.subwindow = NULL;
5271   send_event.crossing.detail = GDK_NOTIFY_ANCESTOR;
5272   send_event.crossing.time = GDK_CURRENT_TIME;
5273
5274   gtk_propagate_event (column->button, &send_event);
5275
5276   send_event.button.type = GDK_BUTTON_RELEASE;
5277   send_event.button.window = GDK_ROOT_PARENT ();
5278   send_event.button.send_event = TRUE;
5279   send_event.button.time = GDK_CURRENT_TIME;
5280   send_event.button.x = -1;
5281   send_event.button.y = -1;
5282   send_event.button.axes = NULL;
5283   send_event.button.state = 0;
5284   send_event.button.button = 1;
5285   send_event.button.device = gdk_core_pointer;
5286   send_event.button.x_root = 0;
5287   send_event.button.y_root = 0;
5288
5289   gtk_propagate_event (column->button, &send_event);
5290
5291   gdk_window_move_resize (tree_view->priv->drag_window,
5292                           column->button->allocation.x,
5293                           column->button->allocation.y + column->button->allocation.height,
5294                           column->button->allocation.width,
5295                           column->button->allocation.height);
5296   gdk_window_reparent (column->button->window, tree_view->priv->drag_window, 0, 0);
5297   tree_view->priv->drag_column_x = column->button->allocation.x;
5298   allocation = column->button->allocation;
5299   allocation.x = 0;
5300   gtk_widget_size_allocate (column->button, &allocation);
5301   gtk_widget_set_parent_window (column->button, tree_view->priv->drag_window);
5302
5303   tree_view->priv->drag_column = column;
5304   gdk_window_show (tree_view->priv->drag_window);
5305
5306   gdk_window_get_origin (tree_view->priv->header_window, &x, &y);
5307   gdk_window_get_size (tree_view->priv->header_window, &width, &height);
5308
5309   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
5310   while (gtk_events_pending ())
5311     gtk_main_iteration ();
5312
5313   GTK_TREE_VIEW_SET_FLAG (tree_view, GTK_TREE_VIEW_IN_COLUMN_DRAG);
5314   gdk_pointer_grab (tree_view->priv->drag_window,
5315                     FALSE,
5316                     GDK_POINTER_MOTION_MASK|GDK_BUTTON_RELEASE_MASK,
5317                     NULL, NULL, GDK_CURRENT_TIME);
5318   gdk_keyboard_grab (tree_view->priv->drag_window,
5319                      FALSE,
5320                      GDK_CURRENT_TIME);
5321
5322 }
5323
5324 static void
5325 gtk_tree_view_queue_draw_node (GtkTreeView  *tree_view,
5326                                GtkRBTree    *tree,
5327                                GtkRBNode    *node,
5328                                GdkRectangle *clip_rect)
5329 {
5330   GdkRectangle rect;
5331
5332   if (!GTK_WIDGET_REALIZED (tree_view))
5333     return;
5334
5335   rect.x = 0;
5336   rect.width = tree_view->priv->width;
5337
5338   rect.y = BACKGROUND_FIRST_PIXEL (tree_view, tree, node);
5339   rect.height = BACKGROUND_HEIGHT (node);
5340
5341   if (clip_rect)
5342     {
5343       GdkRectangle new_rect;
5344
5345       gdk_rectangle_intersect (clip_rect, &rect, &new_rect);
5346
5347       gdk_window_invalidate_rect (tree_view->priv->bin_window, &new_rect, TRUE);
5348     }
5349   else
5350     {
5351       gdk_window_invalidate_rect (tree_view->priv->bin_window, &rect, TRUE);
5352     }
5353 }
5354
5355 static void
5356 gtk_tree_view_queue_draw_path (GtkTreeView      *tree_view,
5357                                GtkTreePath      *path,
5358                                GdkRectangle     *clip_rect)
5359 {
5360   GtkRBTree *tree = NULL;
5361   GtkRBNode *node = NULL;
5362
5363   _gtk_tree_view_find_node (tree_view, path, &tree, &node);
5364
5365   if (tree)
5366     gtk_tree_view_queue_draw_node (tree_view, tree, node, clip_rect);
5367 }
5368
5369 /* x and y are the mouse position
5370  */
5371 static void
5372 gtk_tree_view_draw_arrow (GtkTreeView *tree_view,
5373                           GtkRBTree   *tree,
5374                           GtkRBNode   *node,
5375                           gint         x,
5376                           gint         y)
5377 {
5378   GdkRectangle area;
5379   GtkStateType state;
5380   GtkWidget *widget;
5381   gint x_offset = 0;
5382   gint vertical_separator;
5383   gint expander_height;
5384
5385   gtk_widget_style_get (GTK_WIDGET (tree_view),
5386                         "vertical_separator", &vertical_separator,
5387                         "expander_height", &expander_height,
5388                         NULL);
5389
5390   if (! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT))
5391     return;
5392
5393   widget = GTK_WIDGET (tree_view);
5394
5395   gtk_tree_view_get_arrow_xrange (tree_view, &x_offset, NULL);
5396
5397   area.x = x_offset;
5398   area.y = CELL_FIRST_PIXEL (tree_view, tree, node, vertical_separator);
5399   area.width = tree_view->priv->tab_offset - 2;
5400   area.height = CELL_HEIGHT (node, vertical_separator);
5401
5402   if (node == tree_view->priv->button_pressed_node)
5403     {
5404       if (x >= area.x && x <= (area.x + area.width) &&
5405           y >= area.y && y <= (area.y + area.height))
5406         state = GTK_STATE_ACTIVE;
5407       else
5408         state = GTK_STATE_NORMAL;
5409     }
5410   else
5411     {
5412       if (node == tree_view->priv->prelight_node &&
5413           GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_ARROW_PRELIT))
5414         state = GTK_STATE_PRELIGHT;
5415       else
5416         state = GTK_STATE_NORMAL;
5417     }
5418
5419   gtk_paint_expander (widget->style,
5420                       tree_view->priv->bin_window,
5421                       state,
5422                       &area,
5423                       widget,
5424                       "treeview",
5425                       area.x,
5426                       (area.y + (area.height - expander_height) / 2 - (area.height + 1) % 2),
5427                       node->children != NULL);
5428 }
5429
5430
5431 static void
5432 _gtk_tree_view_update_col_width (GtkTreeView *tree_view)
5433 {
5434   GList *list, *last_column;
5435   GtkTreeViewColumn *column;
5436   gint width = 0;
5437
5438   for (last_column = g_list_last (tree_view->priv->columns);
5439        last_column &&
5440          !(GTK_TREE_VIEW_COLUMN (last_column->data)->visible) &&
5441          GTK_WIDGET_CAN_FOCUS (GTK_TREE_VIEW_COLUMN (last_column->data)->button);
5442        last_column = last_column->prev)
5443     ;
5444
5445   if (last_column == NULL)
5446     return;
5447
5448   for (list = tree_view->priv->columns; list != last_column; list = list->next)
5449     {
5450       column = GTK_TREE_VIEW_COLUMN (list->data);
5451       if (! column->visible)
5452         continue;
5453
5454       width += column->width;
5455       column->displayed_width = (CLAMP (column->width, (column->min_width!=-1)?column->min_width:column->width, (column->max_width!=-1)?column->max_width:column->width));
5456     }
5457   column = GTK_TREE_VIEW_COLUMN (last_column->data);
5458   column->displayed_width = MAX (GTK_WIDGET (tree_view)->allocation.width, tree_view->priv->width) - width;
5459 }
5460
5461 static void
5462 gtk_tree_view_set_cursor_focus (GtkTreeView *tree_view)
5463
5464 {
5465   GtkTreePath *cursor_path;
5466
5467   if ((tree_view->priv->tree == NULL) ||
5468       (! GTK_WIDGET_REALIZED (tree_view)))
5469     return;
5470
5471   if (tree_view->priv->selection == NULL)
5472     tree_view->priv->selection =
5473       _gtk_tree_selection_new_with_tree_view (tree_view);
5474
5475   GTK_TREE_VIEW_SET_FLAG (tree_view, GTK_TREE_VIEW_DRAW_KEYFOCUS);
5476   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
5477
5478   cursor_path = NULL;
5479   if (tree_view->priv->cursor)
5480     cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
5481
5482   if (cursor_path == NULL)
5483     {
5484       GtkTreePath *tmp_path = gtk_tree_path_new_root ();
5485       /* FIXME: Get the first one visible!!! */
5486       if (tree_view->priv->cursor)
5487         gtk_tree_row_reference_free (tree_view->priv->cursor);
5488
5489       tree_view->priv->cursor =
5490         gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view), tree_view->priv->model, tmp_path);
5491       cursor_path = tmp_path;
5492     }
5493
5494   gtk_tree_selection_select_path (tree_view->priv->selection, cursor_path);
5495   gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
5496   gtk_tree_path_free (cursor_path);
5497
5498 }
5499
5500 static void
5501 gtk_tree_view_move_cursor_up_down (GtkTreeView *tree_view,
5502                                    gint         count,
5503                                    gboolean     extend_selection)
5504 {
5505   GtkRBTree *cursor_tree = NULL;
5506   GtkRBNode *cursor_node = NULL;
5507   GtkRBTree *new_cursor_tree = NULL;
5508   GtkRBNode *new_cursor_node = NULL;
5509   GtkTreePath *cursor_path = NULL;
5510
5511   cursor_path = NULL;
5512   if (tree_view->priv->cursor)
5513     cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
5514
5515   if (cursor_path == NULL)
5516     return;
5517
5518   _gtk_tree_view_find_node (tree_view, cursor_path,
5519                             &cursor_tree, &cursor_node);
5520
5521   if (count == -1)
5522     _gtk_rbtree_prev_full (cursor_tree, cursor_node,
5523                            &new_cursor_tree, &new_cursor_node);
5524   else
5525     _gtk_rbtree_next_full (cursor_tree, cursor_node,
5526                            &new_cursor_tree, &new_cursor_node);
5527
5528   if (new_cursor_node)
5529     {
5530       gtk_tree_path_free (cursor_path);
5531
5532       cursor_path = _gtk_tree_view_find_path (tree_view, new_cursor_tree, new_cursor_node);
5533       _gtk_tree_selection_internal_select_node (tree_view->priv->selection,
5534                                                 new_cursor_node,
5535                                                 new_cursor_tree,
5536                                                 cursor_path,
5537                                                 extend_selection?GDK_SHIFT_MASK:0);
5538       gtk_tree_row_reference_free (tree_view->priv->cursor);
5539       tree_view->priv->cursor = gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view), tree_view->priv->model, cursor_path);
5540       gtk_tree_view_clamp_node_visible (tree_view, new_cursor_tree, new_cursor_node);
5541     }
5542   else
5543     {
5544       gtk_tree_view_clamp_node_visible (tree_view, cursor_tree, cursor_node);
5545     }
5546
5547   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
5548   gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
5549   gtk_tree_path_free (cursor_path);
5550 }
5551
5552 static void
5553 gtk_tree_view_move_cursor_page_up_down (GtkTreeView *tree_view,
5554                                         gint         count,
5555                                         gboolean     extend_selection)
5556 {
5557   g_print ("gtk_tree_view_move_cursor_page_up_down\n");
5558 }
5559
5560 static void
5561 gtk_tree_view_move_cursor_left_right (GtkTreeView *tree_view,
5562                                       gint         count)
5563 {
5564   GtkRBTree *cursor_tree = NULL;
5565   GtkRBNode *cursor_node = NULL;
5566   GtkTreePath *cursor_path = NULL;
5567
5568   g_print ("gtk_tree_view_move_cursor_left_right\n");
5569
5570   cursor_path = NULL;
5571   if (tree_view->priv->cursor)
5572     cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
5573
5574   if (cursor_path == NULL)
5575     return;
5576
5577   _gtk_tree_view_find_node (tree_view, cursor_path,
5578                             &cursor_tree, &cursor_node);
5579   gtk_tree_path_free (cursor_path);
5580
5581
5582 }
5583
5584 static void
5585 gtk_tree_view_move_cursor_start_end (GtkTreeView *tree_view,
5586                                      gint         count,
5587                                      gboolean     extend_selection)
5588 {
5589   GtkRBTree *cursor_tree;
5590   GtkRBNode *cursor_node;
5591   GtkTreePath *path;
5592
5593   g_return_if_fail (tree_view->priv->tree != NULL);
5594
5595   if (count == -1)
5596     {
5597       cursor_tree = tree_view->priv->tree;
5598       cursor_node = cursor_tree->root;
5599       while (cursor_node && cursor_node->left != cursor_tree->nil)
5600         cursor_node = cursor_node->left;
5601     }
5602   else
5603     {
5604       cursor_tree = tree_view->priv->tree;
5605       cursor_node = cursor_tree->root;
5606       do
5607         {
5608           while (cursor_node && cursor_node->right != cursor_tree->nil)
5609             cursor_node = cursor_node->right;
5610           if (cursor_node->children == NULL)
5611             break;
5612
5613           cursor_tree = cursor_node->children;
5614           cursor_node = cursor_tree->root;
5615         }
5616       while (1);
5617     }
5618
5619   path = _gtk_tree_view_find_path (tree_view, cursor_tree, cursor_node);
5620   _gtk_tree_selection_internal_select_node (tree_view->priv->selection,
5621                                             cursor_node,
5622                                             cursor_tree,
5623                                             path,
5624                                             extend_selection?GDK_SHIFT_MASK:0);
5625
5626   gtk_tree_row_reference_free (tree_view->priv->cursor);
5627   tree_view->priv->cursor = gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view), tree_view->priv->model, path);
5628   gtk_tree_view_clamp_node_visible (tree_view, cursor_tree, cursor_node);
5629 }
5630
5631 static void
5632 gtk_tree_view_real_set_anchor (GtkTreeView *tree_view)
5633 {
5634
5635 }
5636
5637 static void
5638 gtk_tree_view_real_toggle_cursor_row (GtkTreeView *tree_view)
5639 {
5640   GtkRBTree *cursor_tree = NULL;
5641   GtkRBNode *cursor_node = NULL;
5642   GtkTreePath *cursor_path = NULL;
5643
5644   cursor_path = NULL;
5645   if (tree_view->priv->cursor)
5646     cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
5647
5648   if (cursor_path == NULL)
5649     return;
5650
5651   _gtk_tree_view_find_node (tree_view, cursor_path,
5652                             &cursor_tree, &cursor_node);
5653   if (cursor_tree == NULL)
5654     return;
5655
5656   _gtk_tree_selection_internal_select_node (tree_view->priv->selection,
5657                                             cursor_node,
5658                                             cursor_tree,
5659                                             cursor_path,
5660                                             GDK_CONTROL_MASK);
5661
5662   gtk_tree_view_clamp_node_visible (tree_view, cursor_tree, cursor_node);
5663
5664   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
5665   gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
5666   gtk_tree_path_free (cursor_path);
5667 }
5668
5669
5670
5671 static void
5672 gtk_tree_view_real_expand_collapse_cursor_row (GtkTreeView *tree_view,
5673                                                gboolean     logical,
5674                                                gboolean     expand,
5675                                                gboolean     open_all)
5676 {
5677   GtkTreePath *cursor_path = NULL;
5678
5679   g_print ("in gtk_tree_view_real_expand_collapse_cursor_row\n");
5680   cursor_path = NULL;
5681   if (tree_view->priv->cursor)
5682     cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
5683
5684   if (cursor_path == NULL)
5685     return;
5686
5687   if (expand)
5688     gtk_tree_view_expand_row (tree_view, cursor_path, open_all);
5689   else
5690     gtk_tree_view_collapse_row (tree_view, cursor_path);
5691
5692   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
5693   gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
5694   gtk_tree_path_free (cursor_path);
5695 }
5696
5697 static void
5698 gtk_tree_view_real_select_cursor_parent (GtkTreeView *tree_view)
5699 {
5700   GtkRBTree *cursor_tree = NULL;
5701   GtkRBNode *cursor_node = NULL;
5702   GtkTreePath *cursor_path = NULL;
5703
5704   cursor_path = NULL;
5705   if (tree_view->priv->cursor)
5706     cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
5707
5708   if (cursor_path == NULL)
5709     return;
5710
5711   _gtk_tree_view_find_node (tree_view, cursor_path,
5712                             &cursor_tree, &cursor_node);
5713   if (cursor_tree == NULL)
5714     return;
5715
5716   if (cursor_tree->parent_node)
5717     {
5718       gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
5719       cursor_node = cursor_tree->parent_node;
5720       cursor_tree = cursor_tree->parent_tree;
5721
5722       gtk_tree_path_up (cursor_path);
5723       gtk_tree_row_reference_free (tree_view->priv->cursor);
5724       tree_view->priv->cursor = gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view), tree_view->priv->model, cursor_path);
5725       _gtk_tree_selection_internal_select_node (tree_view->priv->selection,
5726                                                 cursor_node,
5727                                                 cursor_tree,
5728                                                 cursor_path,
5729                                                 0);
5730     }
5731
5732   gtk_tree_view_clamp_node_visible (tree_view, cursor_tree, cursor_node);
5733
5734   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
5735   gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
5736   gtk_tree_path_free (cursor_path);
5737 }
5738
5739 void
5740 _gtk_tree_view_update_size (GtkTreeView *tree_view)
5741 {
5742   gint width, height;
5743   GList *list;
5744   GtkTreeViewColumn *column;
5745   gint vertical_separator;
5746   gint i;
5747
5748   gtk_widget_style_get (GTK_WIDGET (tree_view), "vertical_separator", &vertical_separator, NULL);
5749
5750   if (tree_view->priv->model == NULL)
5751     {
5752       tree_view->priv->width = 0;
5753       tree_view->priv->height = 0;
5754       gtk_widget_queue_draw (GTK_WIDGET (tree_view));
5755       return;
5756     }
5757
5758   width = 0;
5759   for (list = tree_view->priv->columns, i = 0; list; list = list->next, i++)
5760     {
5761       column = list->data;
5762       if (!column->visible)
5763         continue;
5764       width += TREE_VIEW_COLUMN_WIDTH (column);
5765     }
5766
5767   if (tree_view->priv->tree == NULL)
5768     height = 0;
5769   else
5770     height = tree_view->priv->tree->root->offset + vertical_separator;
5771
5772   if (tree_view->priv->width != width)
5773     {
5774       tree_view->priv->width = width;
5775       tree_view->priv->hadjustment->upper = width;
5776       gtk_signal_emit_by_name (GTK_OBJECT (tree_view->priv->hadjustment), "changed");
5777     }
5778
5779   if (tree_view->priv->height != height)
5780     {
5781       tree_view->priv->height = height;
5782       tree_view->priv->vadjustment->upper = tree_view->priv->height;
5783       gtk_signal_emit_by_name (GTK_OBJECT (tree_view->priv->vadjustment), "changed");
5784     }
5785
5786   if (GTK_WIDGET_REALIZED (tree_view))
5787     {
5788       gdk_window_resize (tree_view->priv->bin_window, MAX (width, GTK_WIDGET (tree_view)->allocation.width), height + TREE_VIEW_HEADER_HEIGHT (tree_view));
5789       gdk_window_resize (tree_view->priv->header_window, MAX (width, GTK_WIDGET (tree_view)->allocation.width), tree_view->priv->header_height);
5790
5791       _gtk_tree_view_update_col_width (tree_view);
5792     }
5793
5794   gtk_widget_queue_resize (GTK_WIDGET (tree_view));
5795 }
5796
5797 /* this function returns the new width of the column being resized given
5798  * the column and x position of the cursor; the x cursor position is passed
5799  * in as a pointer and automagicly corrected if it's beyond min/max limits
5800  */
5801 static gint
5802 gtk_tree_view_new_column_width (GtkTreeView *tree_view,
5803                                 gint       i,
5804                                 gint      *x)
5805 {
5806   GtkTreeViewColumn *column;
5807   gint width;
5808
5809   /* first translate the x position from widget->window
5810    * to clist->clist_window
5811    */
5812
5813   column = g_list_nth (tree_view->priv->columns, i)->data;
5814   width = *x - column->button->allocation.x;
5815
5816   /* Clamp down the value */
5817   if (column->min_width == -1)
5818     width = MAX (column->button->requisition.width,
5819                  width);
5820   else
5821     width = MAX (column->min_width,
5822                  width);
5823   if (column->max_width != -1)
5824     width = MIN (width, column->max_width != -1);
5825   *x = column->button->allocation.x + width;
5826
5827   return width;
5828 }
5829
5830
5831 /* Callbacks */
5832 static void
5833 gtk_tree_view_adjustment_changed (GtkAdjustment *adjustment,
5834                                   GtkTreeView   *tree_view)
5835 {
5836   if (GTK_WIDGET_REALIZED (tree_view))
5837     {
5838       gdk_window_move (tree_view->priv->bin_window,
5839                        - tree_view->priv->hadjustment->value,
5840                        - tree_view->priv->vadjustment->value);
5841       gdk_window_move (tree_view->priv->header_window,
5842                        - tree_view->priv->hadjustment->value,
5843                        0);
5844
5845       gdk_window_process_updates (tree_view->priv->bin_window, TRUE);
5846       gdk_window_process_updates (tree_view->priv->header_window, TRUE);
5847     }
5848 }
5849
5850 \f
5851
5852 /* Public methods
5853  */
5854
5855 /**
5856  * gtk_tree_view_new:
5857  *
5858  * Creates a new #GtkTreeView widget.
5859  *
5860  * Return value: A newly created #GtkTreeView widget.
5861  **/
5862 GtkWidget *
5863 gtk_tree_view_new (void)
5864 {
5865   GtkTreeView *tree_view;
5866
5867   tree_view = GTK_TREE_VIEW (gtk_type_new (gtk_tree_view_get_type ()));
5868
5869   return GTK_WIDGET (tree_view);
5870 }
5871
5872 /**
5873  * gtk_tree_view_new_with_model:
5874  * @model: the model.
5875  *
5876  * Creates a new #GtkTreeView widget with the model initialized to @model.
5877  *
5878  * Return value: A newly created #GtkTreeView widget.
5879  **/
5880 GtkWidget *
5881 gtk_tree_view_new_with_model (GtkTreeModel *model)
5882 {
5883   GtkTreeView *tree_view;
5884
5885   tree_view = GTK_TREE_VIEW (gtk_type_new (gtk_tree_view_get_type ()));
5886   gtk_tree_view_set_model (tree_view, model);
5887
5888   return GTK_WIDGET (tree_view);
5889 }
5890
5891 /* Public Accessors
5892  */
5893
5894 /**
5895  * gtk_tree_view_get_model:
5896  * @tree_view: a #GtkTreeView
5897  *
5898  * Returns the model the the #GtkTreeView is based on.  Returns NULL if the
5899  * model is unset.
5900  *
5901  * Return value: A #GtkTreeModel, or NULL if none is currently being used.
5902  **/
5903 GtkTreeModel *
5904 gtk_tree_view_get_model (GtkTreeView *tree_view)
5905 {
5906   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
5907
5908   return tree_view->priv->model;
5909 }
5910
5911 /**
5912  * gtk_tree_view_set_model:
5913  * @tree_view: A #GtkTreeNode.
5914  * @model: The model.
5915  *
5916  * Sets the model for a #GtkTreeView.  If the @tree_view already has a model
5917  * set, it will remove it before setting the new model.  If @model is NULL, then
5918  * it will unset the old model.
5919  **/
5920 void
5921 gtk_tree_view_set_model (GtkTreeView  *tree_view,
5922                          GtkTreeModel *model)
5923 {
5924   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
5925
5926   if (model == tree_view->priv->model)
5927     return;
5928
5929   if (model != NULL)
5930     g_object_ref (model);
5931
5932   if (tree_view->priv->model != NULL)
5933     {
5934       if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_MODEL_SETUP))
5935         {
5936           g_signal_handlers_disconnect_matched (G_OBJECT (tree_view->priv->model),
5937                                                 G_SIGNAL_MATCH_DATA,
5938                                                 0, 0, NULL,
5939                                                 NULL, tree_view);
5940           g_signal_handlers_disconnect_matched (G_OBJECT (tree_view->priv->model),
5941                                                 G_SIGNAL_MATCH_DATA,
5942                                                 0, 0, NULL,
5943                                                 NULL, tree_view);
5944           g_signal_handlers_disconnect_matched (G_OBJECT (tree_view->priv->model),
5945                                                 G_SIGNAL_MATCH_DATA,
5946                                                 0, 0, NULL,
5947                                                 NULL, tree_view);
5948           g_signal_handlers_disconnect_matched (G_OBJECT (tree_view->priv->model),
5949                                                 G_SIGNAL_MATCH_DATA,
5950                                                 0, 0, NULL,
5951                                                 NULL, tree_view);
5952           g_signal_handlers_disconnect_matched (G_OBJECT (tree_view->priv->model),
5953                                                 G_SIGNAL_MATCH_DATA,
5954                                                 0, 0, NULL,
5955                                                 NULL, tree_view);
5956           if (tree_view->priv->tree)
5957             _gtk_rbtree_free (tree_view->priv->tree);
5958         }
5959
5960       if (tree_view->priv->drag_dest_row)
5961         gtk_tree_row_reference_free (tree_view->priv->drag_dest_row);
5962
5963       GTK_TREE_VIEW_UNSET_FLAG (tree_view, GTK_TREE_VIEW_MODEL_SETUP);
5964       g_object_unref (tree_view->priv->model);
5965     }
5966
5967   tree_view->priv->model = model;
5968
5969   if (model == NULL)
5970     {
5971       tree_view->priv->tree = NULL;
5972       if (GTK_WIDGET_REALIZED (tree_view))
5973         _gtk_tree_view_update_size (tree_view);
5974     }
5975   else if (GTK_WIDGET_REALIZED (tree_view))
5976     {
5977       gtk_tree_view_setup_model (tree_view);
5978       _gtk_tree_view_update_size (tree_view);
5979     }
5980
5981   g_object_notify (G_OBJECT (tree_view), "model");
5982 }
5983
5984 /**
5985  * gtk_tree_view_get_selection:
5986  * @tree_view: A #GtkTreeView.
5987  *
5988  * Gets the #GtkTreeSelection associated with @tree_view.
5989  *
5990  * Return value: A #GtkTreeSelection object.
5991  **/
5992 GtkTreeSelection *
5993 gtk_tree_view_get_selection (GtkTreeView *tree_view)
5994 {
5995   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
5996
5997   if (tree_view->priv->selection == NULL)
5998     tree_view->priv->selection = _gtk_tree_selection_new_with_tree_view (tree_view);
5999
6000   return tree_view->priv->selection;
6001 }
6002
6003 /**
6004  * gtk_tree_view_get_hadjustment:
6005  * @tree_view: A #GtkTreeView
6006  *
6007  * Gets the #GtkAdjustment currently being used for the horizontal aspect.
6008  *
6009  * Return value: A #GtkAdjustment object, or NULL if none is currently being
6010  * used.
6011  **/
6012 GtkAdjustment *
6013 gtk_tree_view_get_hadjustment (GtkTreeView *tree_view)
6014 {
6015   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
6016
6017   if (tree_view->priv->hadjustment == NULL)
6018     gtk_tree_view_set_hadjustment (tree_view, NULL);
6019
6020   return tree_view->priv->hadjustment;
6021 }
6022
6023 /**
6024  * gtk_tree_view_set_hadjustment:
6025  * @tree_view: A #GtkTreeView
6026  * @adjustment: The #GtkAdjustment to set, or NULL
6027  *
6028  * Sets the #GtkAdjustment for the current horizontal aspect.
6029  **/
6030 void
6031 gtk_tree_view_set_hadjustment (GtkTreeView   *tree_view,
6032                                GtkAdjustment *adjustment)
6033 {
6034   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
6035
6036   gtk_tree_view_set_adjustments (tree_view,
6037                                  adjustment,
6038                                  tree_view->priv->vadjustment);
6039
6040   g_object_notify (G_OBJECT (tree_view), "hadjustment");
6041 }
6042
6043 /**
6044  * gtk_tree_view_get_vadjustment:
6045  * @tree_view: A #GtkTreeView
6046  *
6047  * Gets the #GtkAdjustment currently being used for the vertical aspect.
6048  *
6049  * Return value: A #GtkAdjustment object, or NULL if none is currently being
6050  * used.
6051  **/
6052 GtkAdjustment *
6053 gtk_tree_view_get_vadjustment (GtkTreeView *tree_view)
6054 {
6055   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
6056
6057   if (tree_view->priv->vadjustment == NULL)
6058     gtk_tree_view_set_vadjustment (tree_view, NULL);
6059
6060   return tree_view->priv->vadjustment;
6061 }
6062
6063 /**
6064  * gtk_tree_view_set_vadjustment:
6065  * @tree_view: A #GtkTreeView
6066  * @adjustment: The #GtkAdjustment to set, or NULL
6067  *
6068  * Sets the #GtkAdjustment for the current vertical aspect.
6069  **/
6070 void
6071 gtk_tree_view_set_vadjustment (GtkTreeView   *tree_view,
6072                                GtkAdjustment *adjustment)
6073 {
6074   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
6075
6076   gtk_tree_view_set_adjustments (tree_view,
6077                                  tree_view->priv->hadjustment,
6078                                  adjustment);
6079
6080   g_object_notify (G_OBJECT (tree_view), "vadjustment");
6081 }
6082
6083 /* Column and header operations */
6084
6085 /**
6086  * gtk_tree_view_get_headers_visible:
6087  * @tree_view: A #GtkTreeView.
6088  *
6089  * Returns TRUE if the headers on the @tree_view are visible.
6090  *
6091  * Return value: Whether the headers are visible or not.
6092  **/
6093 gboolean
6094 gtk_tree_view_get_headers_visible (GtkTreeView *tree_view)
6095 {
6096   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
6097
6098   return GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_HEADERS_VISIBLE);
6099 }
6100
6101 /**
6102  * gtk_tree_view_set_headers_visible:
6103  * @tree_view: A #GtkTreeView.
6104  * @headers_visible: TRUE if the headers are visible
6105  *
6106  * Sets the the visibility state of the headers.
6107  **/
6108 void
6109 gtk_tree_view_set_headers_visible (GtkTreeView *tree_view,
6110                                    gboolean     headers_visible)
6111 {
6112   gint x, y;
6113   GList *list;
6114   GtkTreeViewColumn *column;
6115
6116   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
6117
6118   headers_visible = !! headers_visible;
6119
6120   if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_HEADERS_VISIBLE) == headers_visible)
6121     return;
6122
6123   if (headers_visible)
6124     GTK_TREE_VIEW_SET_FLAG (tree_view, GTK_TREE_VIEW_HEADERS_VISIBLE);
6125   else
6126     GTK_TREE_VIEW_UNSET_FLAG (tree_view, GTK_TREE_VIEW_HEADERS_VISIBLE);
6127
6128   if (GTK_WIDGET_REALIZED (tree_view))
6129     {
6130       gdk_window_get_position (tree_view->priv->bin_window, &x, &y);
6131       if (headers_visible)
6132         {
6133           gdk_window_move_resize (tree_view->priv->bin_window, x, y, tree_view->priv->width, tree_view->priv->height + TREE_VIEW_HEADER_HEIGHT (tree_view));
6134
6135           if (GTK_WIDGET_MAPPED (tree_view))
6136             gtk_tree_view_map_buttons (tree_view);
6137         }
6138       else
6139         {
6140           gdk_window_move_resize (tree_view->priv->bin_window, x, y, tree_view->priv->width, tree_view->priv->height);
6141
6142           for (list = tree_view->priv->columns; list; list = list->next)
6143             {
6144               column = list->data;
6145               gtk_widget_unmap (column->button);
6146             }
6147           gdk_window_hide (tree_view->priv->header_window);
6148         }
6149     }
6150
6151   tree_view->priv->vadjustment->page_size = GTK_WIDGET (tree_view)->allocation.height - TREE_VIEW_HEADER_HEIGHT (tree_view);
6152   tree_view->priv->vadjustment->page_increment = (GTK_WIDGET (tree_view)->allocation.height - TREE_VIEW_HEADER_HEIGHT (tree_view)) / 2;
6153   tree_view->priv->vadjustment->lower = 0;
6154   tree_view->priv->vadjustment->upper = tree_view->priv->height;
6155   gtk_signal_emit_by_name (GTK_OBJECT (tree_view->priv->vadjustment), "changed");
6156
6157   gtk_widget_queue_resize (GTK_WIDGET (tree_view));
6158
6159   g_object_notify (G_OBJECT (tree_view), "headers_visible");
6160 }
6161
6162
6163 /**
6164  * gtk_tree_view_columns_autosize:
6165  * @tree_view: A #GtkTreeView.
6166  *
6167  * Resizes all columns to their optimal width.
6168  **/
6169 void
6170 gtk_tree_view_columns_autosize (GtkTreeView *tree_view)
6171 {
6172   gboolean dirty = FALSE;
6173   GList *list;
6174   GtkTreeViewColumn *column;
6175
6176   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
6177
6178   for (list = tree_view->priv->columns; list; list = list->next)
6179     {
6180       column = list->data;
6181       if (column->column_type == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
6182         continue;
6183       column->dirty = TRUE;
6184       dirty = TRUE;
6185     }
6186
6187   if (dirty)
6188     gtk_widget_queue_resize (GTK_WIDGET (tree_view));
6189 }
6190
6191 /**
6192  * gtk_tree_view_set_headers_clickable:
6193  * @tree_view: A #GtkTreeView.
6194  * @setting: TRUE if the columns are clickable.
6195  *
6196  * Allow the column title buttons to be clicked.
6197  **/
6198 void
6199 gtk_tree_view_set_headers_clickable (GtkTreeView *tree_view,
6200                                      gboolean   setting)
6201 {
6202   GList *list;
6203
6204   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
6205   g_return_if_fail (tree_view->priv->model != NULL);
6206
6207   for (list = tree_view->priv->columns; list; list = list->next)
6208     gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (list->data), setting);
6209
6210   g_object_notify (G_OBJECT (tree_view), "headers_clickable");
6211 }
6212
6213
6214 /**
6215  * gtk_tree_view_set_rules_hint
6216  * @tree_view: a #GtkTreeView
6217  * @setting: %TRUE if the tree requires reading across rows
6218  *
6219  * This function tells GTK+ that the user interface for your
6220  * application requires users to read across tree rows and associate
6221  * cells with one another. By default, GTK+ will then render the tree
6222  * with alternating row colors. <emphasis>DO NOT</emphasis> use it
6223  * just because you prefer the appearance of the ruled tree; that's a
6224  * question for the theme. Some themes will draw tree rows in
6225  * alternating colors even when rules are turned off, and users who
6226  * prefer that appearance all the time can choose those themes. You
6227  * should call this function only as a <emphasis>semantic</emphasis>
6228  * hint to the theme engine that your tree makes alternating colors
6229  * useful from a functional standpoint (since it has lots of columns,
6230  * generally).
6231  *
6232  **/
6233 void
6234 gtk_tree_view_set_rules_hint (GtkTreeView  *tree_view,
6235                               gboolean      setting)
6236 {
6237   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
6238
6239   setting = setting != FALSE;
6240
6241   if (tree_view->priv->has_rules != setting)
6242     {
6243       tree_view->priv->has_rules = setting;
6244       gtk_widget_queue_draw (GTK_WIDGET (tree_view));
6245     }
6246
6247   g_object_notify (G_OBJECT (tree_view), "rules_hint");
6248 }
6249
6250 /**
6251  * gtk_tree_view_get_rules_hint
6252  * @tree_view: a #GtkTreeView
6253  *
6254  * Gets the setting set by gtk_tree_view_set_rules_hint().
6255  *
6256  * Return value: %TRUE if rules are useful for the user of this tree
6257  **/
6258 gboolean
6259 gtk_tree_view_get_rules_hint (GtkTreeView  *tree_view)
6260 {
6261   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
6262
6263   return tree_view->priv->has_rules;
6264 }
6265
6266 /* Public Column functions
6267  */
6268
6269 /**
6270  * gtk_tree_view_append_column:
6271  * @tree_view: A #GtkTreeView.
6272  * @column: The #GtkTreeViewColumn to add.
6273  *
6274  * Appends @column to the list of columns.
6275  *
6276  * Return value: The number of columns in @tree_view after appending.
6277  **/
6278 gint
6279 gtk_tree_view_append_column (GtkTreeView       *tree_view,
6280                              GtkTreeViewColumn *column)
6281 {
6282   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
6283   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (column), -1);
6284   g_return_val_if_fail (column->tree_view == NULL, -1);
6285
6286   return gtk_tree_view_insert_column (tree_view, column, -1);
6287 }
6288
6289
6290 /**
6291  * gtk_tree_view_remove_column:
6292  * @tree_view: A #GtkTreeView.
6293  * @column: The #GtkTreeViewColumn to remove.
6294  *
6295  * Removes @column from @tree_view.
6296  *
6297  * Return value: The number of columns in @tree_view after removing.
6298  **/
6299 gint
6300 gtk_tree_view_remove_column (GtkTreeView       *tree_view,
6301                              GtkTreeViewColumn *column)
6302 {
6303   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
6304   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (column), -1);
6305   g_return_val_if_fail (column->tree_view == GTK_WIDGET (tree_view), -1);
6306
6307   _gtk_tree_view_column_unset_tree_view (column);
6308
6309   if (tree_view->priv->focus_column == column)
6310     tree_view->priv->focus_column = NULL;
6311
6312   tree_view->priv->columns = g_list_remove (tree_view->priv->columns, column);
6313
6314   tree_view->priv->n_columns--;
6315
6316   if (GTK_WIDGET_REALIZED (tree_view))
6317     {
6318       GList *list;
6319
6320       _gtk_tree_view_column_unrealize_button (column);
6321       for (list = tree_view->priv->columns; list; list = list->next)
6322         {
6323           column = GTK_TREE_VIEW_COLUMN (list->data);
6324           if (column->visible)
6325             column->dirty = TRUE;
6326         }
6327
6328       if (tree_view->priv->n_columns == 0 &&
6329           gtk_tree_view_get_headers_visible (tree_view))
6330         gdk_window_hide (tree_view->priv->header_window);
6331
6332       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
6333     }
6334
6335   g_object_unref (G_OBJECT (column));
6336   g_signal_emit (G_OBJECT (tree_view), tree_view_signals[COLUMNS_CHANGED], 0);
6337
6338   return tree_view->priv->n_columns;
6339 }
6340
6341 /**
6342  * gtk_tree_view_insert_column:
6343  * @tree_view: A #GtkTreeView.
6344  * @column: The #GtkTreeViewColumn to be inserted.
6345  * @position: The position to insert @column in.
6346  *
6347  * This inserts the @column into the @tree_view at @position.  If @position is
6348  * -1, then the column is inserted at the end.
6349  *
6350  * Return value: The number of columns in @tree_view after insertion.
6351  **/
6352 gint
6353 gtk_tree_view_insert_column (GtkTreeView       *tree_view,
6354                              GtkTreeViewColumn *column,
6355                              gint               position)
6356 {
6357   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
6358   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (column), -1);
6359   g_return_val_if_fail (column->tree_view == NULL, -1);
6360
6361   g_object_ref (G_OBJECT (column));
6362
6363   if (tree_view->priv->n_columns == 0 &&
6364       GTK_WIDGET_REALIZED (tree_view) &&
6365       gtk_tree_view_get_headers_visible (tree_view))
6366     {
6367       gdk_window_show (tree_view->priv->header_window);
6368     }
6369
6370   tree_view->priv->columns = g_list_insert (tree_view->priv->columns,
6371                                             column, position);
6372   tree_view->priv->n_columns++;
6373
6374   _gtk_tree_view_column_set_tree_view (column, tree_view);
6375
6376   if (GTK_WIDGET_REALIZED (tree_view))
6377     {
6378       GList *list;
6379
6380       _gtk_tree_view_column_realize_button (column);
6381
6382       for (list = tree_view->priv->columns; list; list = list->next)
6383         {
6384           column = GTK_TREE_VIEW_COLUMN (list->data);
6385           if (column->visible)
6386             column->dirty = TRUE;
6387         }
6388       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
6389     }
6390
6391   g_signal_emit (G_OBJECT (tree_view), tree_view_signals[COLUMNS_CHANGED], 0);
6392
6393   return tree_view->priv->n_columns;
6394 }
6395
6396 /**
6397  * gtk_tree_view_insert_column_with_attributes:
6398  * @tree_view: A #GtkTreeView
6399  * @position: The position to insert the new column in.
6400  * @title: The title to set the header to.
6401  * @cell: The #GtkCellRenderer.
6402  * @Varargs: A NULL terminated list of attributes.
6403  *
6404  * Creates a new #GtkTreeViewColumn and inserts it into the @tree_view at
6405  * @position.  If @position is -1, then the newly created column is inserted at
6406  * the end.  The column is initialized with the attributes given.
6407  *
6408  * Return value: The number of columns in @tree_view after insertion.
6409  **/
6410 gint
6411 gtk_tree_view_insert_column_with_attributes (GtkTreeView     *tree_view,
6412                                              gint             position,
6413                                              gchar           *title,
6414                                              GtkCellRenderer *cell,
6415                                              ...)
6416 {
6417   GtkTreeViewColumn *column;
6418   gchar *attribute;
6419   va_list args;
6420   gint column_id;
6421
6422   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
6423
6424   column = gtk_tree_view_column_new ();
6425
6426   gtk_tree_view_column_set_title (column, title);
6427   gtk_tree_view_column_set_cell_renderer (column, cell);
6428
6429   va_start (args, cell);
6430
6431   attribute = va_arg (args, gchar *);
6432
6433   while (attribute != NULL)
6434     {
6435       column_id = va_arg (args, gint);
6436       gtk_tree_view_column_add_attribute (column, attribute, column_id);
6437       attribute = va_arg (args, gchar *);
6438     }
6439
6440   va_end (args);
6441
6442   gtk_tree_view_insert_column (tree_view, column, position);
6443   g_object_unref (column);
6444
6445   return tree_view->priv->n_columns;
6446 }
6447
6448 /**
6449  * gtk_tree_view_insert_column_with_data_func:
6450  * @tree_view: a #GtkTreeView
6451  * @position: Position to insert, -1 for append
6452  * @title: column title
6453  * @cell: cell renderer for column
6454  * @func: function to set attributes of cell renderer
6455  * @data: data for @func
6456  * @dnotify: destroy notifier for @data
6457  *
6458  * Convenience function that inserts a new column into the #GtkTreeView
6459  * with the given cell renderer and a #GtkCellDataFunc to set cell renderer
6460  * attributes (normally using data from the model). See also
6461  * gtk_tree_view_column_set_cell_data_func(), gtk_tree_view_column_set_cell_renderer().
6462  *
6463  * Return value: number of columns in the tree view post-insert
6464  **/
6465 gint
6466 gtk_tree_view_insert_column_with_data_func  (GtkTreeView               *tree_view,
6467                                              gint                       position,
6468                                              gchar                     *title,
6469                                              GtkCellRenderer           *cell,
6470                                              GtkTreeCellDataFunc        func,
6471                                              gpointer                   data,
6472                                              GDestroyNotify             dnotify)
6473 {
6474   GtkTreeViewColumn *column;
6475
6476   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
6477
6478   column = gtk_tree_view_column_new ();
6479
6480   gtk_tree_view_column_set_title (column, title);
6481   gtk_tree_view_column_set_cell_renderer (column, cell);
6482   gtk_tree_view_column_set_cell_data_func (column, func, data, dnotify);
6483
6484   gtk_tree_view_insert_column (tree_view, column, position);
6485
6486   g_object_unref (column);
6487
6488   return tree_view->priv->n_columns;
6489 }
6490
6491 /**
6492  * gtk_tree_view_get_column:
6493  * @tree_view: A #GtkTreeView.
6494  * @n: The position of the column, counting from 0.
6495  *
6496  * Gets the #GtkTreeViewColumn at the given position in the #tree_view.
6497  *
6498  * Return value: The #GtkTreeViewColumn, or NULL if the position is outside the
6499  * range of columns.
6500  **/
6501 GtkTreeViewColumn *
6502 gtk_tree_view_get_column (GtkTreeView *tree_view,
6503                           gint         n)
6504 {
6505   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
6506
6507   if (n < 0 || n >= tree_view->priv->n_columns)
6508     return NULL;
6509
6510   if (tree_view->priv->columns == NULL)
6511     return NULL;
6512
6513   return GTK_TREE_VIEW_COLUMN (g_list_nth (tree_view->priv->columns, n)->data);
6514 }
6515
6516 /**
6517  * gtk_tree_view_get_columns:
6518  * @tree_view: A #GtkTreeView
6519  *
6520  * Returns a #GList of all the #GtkTreeViewColumn s currently in @tree_view.
6521  * The returned list must be freed with g_list_free ().
6522  *
6523  * Return value: A list of #GtkTreeViewColumn s
6524  **/
6525 GList *
6526 gtk_tree_view_get_columns (GtkTreeView *tree_view)
6527 {
6528   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
6529
6530   return g_list_copy (tree_view->priv->columns);
6531 }
6532
6533 /**
6534  * gtk_tree_view_move_column_after:
6535  * @tree_view: A #GtkTreeView
6536  * @column: The #GtkTreeViewColumn to be moved.
6537  * @base_column: The #GtkTreeViewColumn to be moved relative to.
6538  *
6539  * Moves @column to be after to @base_column.  If @base_column is NULL, then
6540  * @column is placed in the first position.
6541  **/
6542 void
6543 gtk_tree_view_move_column_after (GtkTreeView       *tree_view,
6544                                  GtkTreeViewColumn *column,
6545                                  GtkTreeViewColumn *base_column)
6546 {
6547   GList *column_list_el, *base_el = NULL;
6548
6549   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
6550
6551   column_list_el = g_list_find (tree_view->priv->columns, column);
6552   g_return_if_fail (column_list_el != NULL);
6553
6554   if (base_column)
6555     {
6556       base_el = g_list_find (tree_view->priv->columns, base_column);
6557       g_return_if_fail (base_el != NULL);
6558     }
6559
6560   if (column_list_el->prev == base_el)
6561     return;
6562
6563   tree_view->priv->columns = g_list_remove_link (tree_view->priv->columns, column_list_el);
6564   if (base_el == NULL)
6565     {
6566       column_list_el->prev = NULL;
6567       column_list_el->next = tree_view->priv->columns;
6568       if (column_list_el->next)
6569         column_list_el->next->prev = column_list_el;
6570       tree_view->priv->columns = column_list_el;
6571     }
6572   else
6573     {
6574       column_list_el->prev = base_el;
6575       column_list_el->next = base_el->next;
6576       if (column_list_el->next)
6577         column_list_el->next->prev = column_list_el;
6578       base_el->next = column_list_el;
6579     }
6580
6581   if (GTK_WIDGET_REALIZED (tree_view))
6582     {
6583       //gtk_widget_queue_resize (GTK_WIDGET (tree_view));
6584       _gtk_tree_view_update_size (tree_view);
6585       gtk_tree_view_size_allocate_buttons (GTK_WIDGET (tree_view));
6586     }
6587
6588   g_signal_emit (G_OBJECT (tree_view), tree_view_signals[COLUMNS_CHANGED], 0);
6589 }
6590
6591 /**
6592  * gtk_tree_view_set_expander_column:
6593  * @tree_view: A #GtkTreeView
6594  * @col: The column to draw the expander arrow at.
6595  *
6596  * Sets the column offset to draw the expander arrow at.
6597  **/
6598 void
6599 gtk_tree_view_set_expander_column (GtkTreeView *tree_view,
6600                                    gint         col)
6601 {
6602   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
6603
6604   if (tree_view->priv->expander_column != col)
6605     {
6606       tree_view->priv->expander_column = col;
6607
6608       g_object_notify (G_OBJECT (tree_view), "expander_column");
6609     }
6610 }
6611
6612 /**
6613  * gtk_tree_view_get_expander_column:
6614  * @tree_view:
6615  *
6616  * Returns the offset of the column that is the current expander column.  This
6617  * column has the expander arrow drawn next to it.
6618  *
6619  * Return value: The offset of the expander column.
6620  **/
6621 gint
6622 gtk_tree_view_get_expander_column (GtkTreeView *tree_view)
6623 {
6624   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
6625
6626   return tree_view->priv->expander_column;
6627 }
6628
6629
6630 /**
6631  * gtk_tree_view_set_column_drag_function:
6632  * @tree_view: A #GtkTreeView.
6633  * @func: A function to determine which columns are reorderable, or NULL.
6634  * @user_data: User data to be passed to @func, or NULL
6635  * @destroy: Destroy notifier for @user_data, or NULL
6636  *
6637  * Sets a user function for determining where a column may be dropped when
6638  * dragged.  This function is called on every column pair in turn at the
6639  * beginning of a column drag to determine where a drop can take place.  The
6640  * arguments passed to @func are: the @tree_view, the #GtkTreeViewColumn being
6641  * dragged, the two #GtkTreeViewColumn s determining the drop spot, and
6642  * @user_data.  If either of the #GtkTreeViewColumn arguments for the drop spot
6643  * are NULL, then they indicate an edge.  If @func is set to be NULL, then
6644  * @tree_view reverts to the default behavior of allowing all columns to be
6645  * dropped everywhere.
6646  **/
6647 void
6648 gtk_tree_view_set_column_drag_function (GtkTreeView               *tree_view,
6649                                         GtkTreeViewColumnDropFunc  func,
6650                                         gpointer                   user_data,
6651                                         GtkDestroyNotify           destroy)
6652 {
6653   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
6654
6655   if (tree_view->priv->column_drop_func_data_destroy)
6656     (* tree_view->priv->column_drop_func_data_destroy) (tree_view->priv->column_drop_func_data);
6657
6658   tree_view->priv->column_drop_func = func;
6659   tree_view->priv->column_drop_func_data = user_data;
6660   tree_view->priv->column_drop_func_data_destroy = destroy;
6661 }
6662
6663 /**
6664  * gtk_tree_view_scroll_to_point:
6665  * @tree_view: a #GtkTreeView
6666  * @tree_x: X coordinate of new top-left pixel of visible area
6667  * @tree_y: Y coordinate of new top-left pixel of visible area
6668  *
6669  * Scrolls the tree view such that the top-left corner of the visible
6670  * area is @tree_x, @tree_y, where @tree_x and @tree_y are specified
6671  * in tree window coordinates.  The @tree_view must be realized before
6672  * this function is called.  If it isn't, you probably want ot be
6673  * using gtk_tree_view_scroll_to_cell.
6674  **/
6675 void
6676 gtk_tree_view_scroll_to_point (GtkTreeView *tree_view,
6677                                gint         tree_x,
6678                                gint         tree_y)
6679 {
6680   GtkAdjustment *hadj;
6681   GtkAdjustment *vadj;
6682
6683   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
6684   g_return_if_fail (GTK_WIDGET_REALIZED (tree_view));
6685
6686   hadj = tree_view->priv->hadjustment;
6687   vadj = tree_view->priv->vadjustment;
6688
6689   gtk_adjustment_set_value (hadj, CLAMP (tree_x, hadj->lower, hadj->upper));
6690   gtk_adjustment_set_value (vadj, CLAMP (tree_y, vadj->lower, vadj->upper));
6691 }
6692
6693 /**
6694  * gtk_tree_view_scroll_to_cell
6695  * @tree_view: A #GtkTreeView.
6696  * @path: The path of the row to move to.
6697  * @column: The #GtkTreeViewColumn to move horizontally to.
6698  * @row_align: The vertical alignment of the row specified by @path.
6699  * @col_align: The horizontal alignment of the column specified by @column.
6700  *
6701  * Moves the alignments of @tree_view to the position specified by
6702  * @column and @path.  If @column is NULL, then no horizontal
6703  * scrolling occurs.  Likewise, if @path is NULL no vertical scrolling
6704  * occurs.  @row_align determines where the row is placed, and
6705  * @col_align determines where @column is placed.  Both are expected
6706  * to be between 0.0 and 1.0. 0.0 means left/top alignment, 1.0 means
6707  * right/bottom alignment, 0.5 means center.
6708  **/
6709 void
6710 gtk_tree_view_scroll_to_cell (GtkTreeView       *tree_view,
6711                               GtkTreePath       *path,
6712                               GtkTreeViewColumn *column,
6713                               gfloat             row_align,
6714                               gfloat             col_align)
6715 {
6716   GdkRectangle cell_rect;
6717   GdkRectangle vis_rect;
6718   gint dest_x, dest_y;
6719
6720   /* FIXME work on unmapped/unrealized trees? maybe implement when
6721    * we do incremental reflow for trees
6722    */
6723
6724   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
6725   g_return_if_fail (row_align >= 0.0);
6726   g_return_if_fail (row_align <= 1.0);
6727   g_return_if_fail (col_align >= 0.0);
6728   g_return_if_fail (col_align <= 1.0);
6729   g_return_if_fail (path != NULL || column != NULL);
6730
6731   row_align = CLAMP (row_align, 0.0, 1.0);
6732   col_align = CLAMP (col_align, 0.0, 1.0);
6733
6734   if (! GTK_WIDGET_REALIZED (tree_view))
6735     {
6736       if (path)
6737         tree_view->priv->scroll_to_path = gtk_tree_path_copy (path);
6738       if (column)
6739         tree_view->priv->scroll_to_column = column;
6740       tree_view->priv->scroll_to_row_align = row_align;
6741       tree_view->priv->scroll_to_col_align = col_align;
6742
6743       return;
6744     }
6745
6746   gtk_tree_view_get_cell_area (tree_view, path, column, &cell_rect);
6747   gtk_tree_view_get_visible_rect (tree_view, &vis_rect);
6748
6749   dest_x = vis_rect.x;
6750   dest_y = vis_rect.y;
6751
6752   if (path)
6753     {
6754       dest_x = cell_rect.x +
6755         cell_rect.width * row_align -
6756         vis_rect.width * row_align;
6757     }
6758
6759   if (column)
6760     {
6761       dest_y = cell_rect.y +
6762         cell_rect.height * col_align -
6763         vis_rect.height * col_align;
6764     }
6765
6766   gtk_tree_view_scroll_to_point (tree_view, dest_x, dest_y);
6767 }
6768
6769
6770 /**
6771  * gtk_tree_view_row_activated:
6772  * @tree_view: A #GtkTreeView
6773  * @path: The #GtkTreePath to be activated.
6774  * @column: The #GtkTreeViewColumn to be activated.
6775  *
6776  * Activates the cell determined by @path and @column.
6777  **/
6778 void
6779 gtk_tree_view_row_activated (GtkTreeView       *tree_view,
6780                              GtkTreePath       *path,
6781                              GtkTreeViewColumn *column)
6782 {
6783   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
6784
6785   /* FIXME: Actually activate the path internally, not just emit the signal */
6786   /*  g_warning ("FIXME: Actually activate the path internally, not just emit the signal\n"); */
6787   g_signal_emit (G_OBJECT(tree_view), tree_view_signals[ROW_ACTIVATED], 0, path, column);
6788 }
6789
6790
6791 static void
6792 gtk_tree_view_expand_all_helper (GtkRBTree  *tree,
6793                                  GtkRBNode  *node,
6794                                  gpointer  data)
6795 {
6796   GtkTreeView *tree_view = data;
6797
6798   if (node->children)
6799     _gtk_rbtree_traverse (node->children,
6800                           node->children->root,
6801                           G_PRE_ORDER,
6802                           gtk_tree_view_expand_all_helper,
6803                           data);
6804   else if ((node->flags & GTK_RBNODE_IS_PARENT) == GTK_RBNODE_IS_PARENT && node->children == NULL)
6805     {
6806       GtkTreePath *path;
6807       GtkTreeIter iter;
6808       GtkTreeIter child;
6809
6810       node->children = _gtk_rbtree_new ();
6811       node->children->parent_tree = tree;
6812       node->children->parent_node = node;
6813       path = _gtk_tree_view_find_path (tree_view, tree, node);
6814       gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
6815       gtk_tree_model_iter_children (tree_view->priv->model, &child, &iter);
6816       gtk_tree_view_build_tree (tree_view,
6817                                 node->children,
6818                                 &child,
6819                                 gtk_tree_path_get_depth (path) + 1,
6820                                 TRUE,
6821                                 GTK_WIDGET_REALIZED (tree_view));
6822       gtk_tree_path_free (path);
6823     }
6824 }
6825
6826 /**
6827  * gtk_tree_view_expand_all:
6828  * @tree_view: A #GtkTreeView.
6829  *
6830  * Recursively expands all nodes in the @tree_view.
6831  **/
6832 void
6833 gtk_tree_view_expand_all (GtkTreeView *tree_view)
6834 {
6835   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
6836   g_return_if_fail (tree_view->priv->tree != NULL);
6837
6838   _gtk_rbtree_traverse (tree_view->priv->tree,
6839                         tree_view->priv->tree->root,
6840                         G_PRE_ORDER,
6841                         gtk_tree_view_expand_all_helper,
6842                         tree_view);
6843
6844   _gtk_tree_view_update_size (tree_view);
6845 }
6846
6847 static void
6848 gtk_tree_view_collapse_all_helper (GtkRBTree  *tree,
6849                                    GtkRBNode  *node,
6850                                    gpointer    data)
6851 {
6852   if (node->children)
6853     {
6854       GtkTreePath *path;
6855       GtkTreeIter iter;
6856
6857       path = _gtk_tree_view_find_path (GTK_TREE_VIEW (data),
6858                                        node->children,
6859                                        node->children->root);
6860       gtk_tree_model_get_iter (GTK_TREE_VIEW (data)->priv->model,
6861                                &iter,
6862                                path);
6863       gtk_tree_view_discover_dirty (GTK_TREE_VIEW (data),
6864                                     node->children,
6865                                     &iter,
6866                                     gtk_tree_path_get_depth (path));
6867
6868       /* Ensure we don't have a dangling pointer to a dead node */
6869       ensure_unprelighted (GTK_TREE_VIEW (data));
6870
6871       _gtk_rbtree_remove (node->children);
6872       gtk_tree_path_free (path);
6873     }
6874 }
6875
6876 /**
6877  * gtk_tree_view_collapse_all:
6878  * @tree_view: A #GtkTreeView.
6879  *
6880  * Recursively collapses all visible, expanded nodes in @tree_view.
6881  **/
6882 void
6883 gtk_tree_view_collapse_all (GtkTreeView *tree_view)
6884 {
6885   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
6886   g_return_if_fail (tree_view->priv->tree != NULL);
6887
6888   _gtk_rbtree_traverse (tree_view->priv->tree,
6889                         tree_view->priv->tree->root,
6890                         G_PRE_ORDER,
6891                         gtk_tree_view_collapse_all_helper,
6892                         tree_view);
6893
6894   if (GTK_WIDGET_MAPPED (tree_view))
6895     gtk_widget_queue_draw (GTK_WIDGET (tree_view));
6896 }
6897
6898 /* FIXME the bool return values for expand_row and collapse_row are
6899  * not analagous; they should be TRUE if the row had children and
6900  * was not already in the requested state.
6901  */
6902
6903
6904 static gboolean
6905 gtk_tree_view_real_expand_row (GtkTreeView *tree_view,
6906                                GtkTreePath *path,
6907                                GtkRBTree   *tree,
6908                                GtkRBNode   *node,
6909                                gboolean     open_all)
6910 {
6911   GtkTreeIter iter;
6912   GtkTreeIter child;
6913   gboolean expand;
6914
6915   if (node->children)
6916     return TRUE;
6917
6918   gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
6919   if (! gtk_tree_model_iter_has_child (tree_view->priv->model, &iter))
6920     return FALSE;
6921
6922   g_signal_emit (G_OBJECT (tree_view), tree_view_signals[EXPAND_ROW], 0, &iter, path, &expand);
6923
6924   if (expand)
6925     return FALSE;
6926
6927   node->children = _gtk_rbtree_new ();
6928   node->children->parent_tree = tree;
6929   node->children->parent_node = node;
6930
6931   gtk_tree_model_iter_children (tree_view->priv->model, &child, &iter);
6932   gtk_tree_view_build_tree (tree_view,
6933                             node->children,
6934                             &child,
6935                             gtk_tree_path_get_depth (path) + 1,
6936                             open_all,
6937                             GTK_WIDGET_REALIZED (tree_view));
6938
6939   if (GTK_WIDGET_MAPPED (tree_view))
6940     {
6941       gtk_widget_queue_draw (GTK_WIDGET (tree_view));
6942       _gtk_tree_view_update_size (tree_view);
6943     }
6944   return TRUE;
6945 }
6946
6947 /**
6948  * gtk_tree_view_expand_row:
6949  * @tree_view: a #GtkTreeView
6950  * @path: path to a row
6951  * @open_all: whether to recursively expand, or just expand immediate children
6952  *
6953  * Opens the row so its children are visible
6954  *
6955  * Return value: %TRUE if the row existed and had children
6956  **/
6957 gboolean
6958 gtk_tree_view_expand_row (GtkTreeView *tree_view,
6959                           GtkTreePath *path,
6960                           gboolean     open_all)
6961 {
6962   GtkRBTree *tree;
6963   GtkRBNode *node;
6964
6965   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
6966   g_return_val_if_fail (tree_view->priv->model != NULL, FALSE);
6967   g_return_val_if_fail (path != NULL, FALSE);
6968
6969   if (_gtk_tree_view_find_node (tree_view,
6970                                 path,
6971                                 &tree,
6972                                 &node))
6973     return FALSE;
6974
6975   return gtk_tree_view_real_expand_row (tree_view, path, tree, node, open_all);
6976 }
6977
6978 static gboolean
6979 gtk_tree_view_real_collapse_row (GtkTreeView *tree_view,
6980                                  GtkTreePath *path,
6981                                  GtkRBTree   *tree,
6982                                  GtkRBNode   *node)
6983 {
6984   GtkTreeIter iter;
6985   gboolean collapse;
6986
6987   gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
6988
6989   g_signal_emit (G_OBJECT (tree_view), tree_view_signals[COLLAPSE_ROW], 0, &iter, path, &collapse);
6990
6991   if (collapse)
6992     return FALSE;
6993
6994   TREE_VIEW_INTERNAL_ASSERT (gtk_tree_model_iter_children (tree_view->priv->model,
6995                                                            &iter,
6996                                                            &iter),
6997                              FALSE);
6998   gtk_tree_view_discover_dirty (tree_view,
6999                                 node->children,
7000                                 &iter,
7001                                 gtk_tree_path_get_depth (path));
7002
7003   /* Ensure we don't have a dangling pointer to a dead node */
7004   ensure_unprelighted (tree_view);
7005
7006   g_assert (tree_view->priv->prelight_node == NULL);
7007
7008   gtk_tree_view_unref_tree (tree_view, node->children);
7009   _gtk_rbtree_remove (node->children);
7010
7011   if (GTK_WIDGET_MAPPED (tree_view))
7012     {
7013       gtk_widget_queue_draw (GTK_WIDGET (tree_view));
7014       _gtk_tree_view_update_size (tree_view);
7015     }
7016   return TRUE;
7017 }
7018
7019 /**
7020  * gtk_tree_view_collapse_row:
7021  * @tree_view: a #GtkTreeView
7022  * @path: path to a row in the @tree_view
7023  *
7024  * Collapses a row (hides its child rows, if they exist.)
7025  *
7026  * Return value: %TRUE if the row was collapsed.
7027  **/
7028 gboolean
7029 gtk_tree_view_collapse_row (GtkTreeView *tree_view,
7030                             GtkTreePath *path)
7031 {
7032   GtkRBTree *tree;
7033   GtkRBNode *node;
7034
7035   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
7036   g_return_val_if_fail (tree_view->priv->tree != NULL, FALSE);
7037   g_return_val_if_fail (path != NULL, FALSE);
7038
7039   if (_gtk_tree_view_find_node (tree_view,
7040                                 path,
7041                                 &tree,
7042                                 &node))
7043     return FALSE;
7044
7045   if (node->children == NULL)
7046     return FALSE;
7047
7048   return gtk_tree_view_real_collapse_row (tree_view, path, tree, node);
7049 }
7050
7051 static void
7052 gtk_tree_view_map_expanded_rows_helper (GtkTreeView            *tree_view,
7053                                         GtkRBTree              *tree,
7054                                         GtkTreePath            *path,
7055                                         GtkTreeViewMappingFunc  func,
7056                                         gpointer                user_data)
7057 {
7058   GtkRBNode *node;
7059   gint *indices;
7060   gint depth;
7061   gint i = 0;
7062
7063   if (tree == NULL || tree->root == NULL)
7064     return;
7065
7066   node = tree->root;
7067
7068   indices = gtk_tree_path_get_indices (path);
7069   depth = gtk_tree_path_get_depth (path);
7070
7071   while (node && node->left != tree->nil)
7072     node = node->left;
7073
7074   while (node)
7075     {
7076       if (node->children)
7077         {
7078           gtk_tree_path_append_index (path, 0);
7079           gtk_tree_view_map_expanded_rows_helper (tree_view, node->children, path, func, user_data);
7080           gtk_tree_path_up (path);
7081           (* func) (tree_view, path, user_data);
7082         }
7083       i++;
7084       indices[depth -1] = i;
7085       node = _gtk_rbtree_next (tree, node);
7086     }
7087 }
7088
7089 /**
7090  * gtk_tree_view_map_expanded_rows:
7091  * @tree_view: A #GtkTreeView
7092  * @func: A function to be called
7093  * @data: User data to be passed to the function.
7094  *
7095  * Calls @func on all expanded rows.
7096  **/
7097 void
7098 gtk_tree_view_map_expanded_rows (GtkTreeView            *tree_view,
7099                                  GtkTreeViewMappingFunc  func,
7100                                  gpointer                user_data)
7101 {
7102   GtkTreePath *path;
7103
7104   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
7105   g_return_if_fail (func != NULL);
7106
7107   path = gtk_tree_path_new_root ();
7108
7109   gtk_tree_view_map_expanded_rows_helper (tree_view,
7110                                           tree_view->priv->tree,
7111                                           path, func, user_data);
7112
7113   gtk_tree_path_free (path);
7114 }
7115
7116 static GtkTargetEntry row_targets[] = {
7117   { "GTK_TREE_MODEL_ROW", GTK_TARGET_SAME_WIDGET, 0 }
7118 };
7119
7120 /**
7121  * gtk_tree_view_set_reorderable:
7122  * @tree_view: A #GtkTreeView.
7123  * @reorderable: TRUE, if the tree can be reordered.
7124  *
7125  * This function is a convenience function to allow you to reorder models that
7126  * support the #GtkDragSourceIface and the #GtkDragDestIface.  Both
7127  * #GtkTreeStore and #GtkListStore support these.  If @reorderable is TRUE, then
7128  * the user can reorder the model by dragging and dropping columns.  The
7129  * developer will can listen to these changes by connecting to the model's
7130  * signals.
7131  *
7132  * This function does not give you any degree of control over the order -- any
7133  * reorderering is allowed.  If more control is needed, you should probably
7134  * handle drag and drop manually.
7135  **/
7136 void
7137 gtk_tree_view_set_reorderable (GtkTreeView *tree_view,
7138                                gboolean     reorderable)
7139 {
7140   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
7141
7142   if (tree_view->priv->reorderable == (reorderable?TRUE:FALSE))
7143     return;
7144
7145   gtk_tree_view_set_rows_drag_source (tree_view,
7146                                       GDK_BUTTON1_MASK,
7147                                       row_targets,
7148                                       G_N_ELEMENTS (row_targets),
7149                                       GDK_ACTION_MOVE,
7150                                       NULL, NULL);
7151   gtk_tree_view_set_rows_drag_dest (tree_view,
7152                                     row_targets,
7153                                     G_N_ELEMENTS (row_targets),
7154                                     GDK_ACTION_MOVE,
7155                                     NULL, NULL);
7156
7157   g_object_notify (G_OBJECT (tree_view), "reorderable");
7158 }
7159
7160
7161 /**
7162  * gtk_tree_view_get_path_at_pos:
7163  * @tree_view: A #GtkTreeView.
7164  * @window: The #GdkWindow to check against.
7165  * @x: The x position to be identified.
7166  * @y: The y position to be identified.
7167  * @path: A pointer to a #GtkTreePath pointer to be filled in, or %NULL
7168  * @column: A pointer to a #GtkTreeViewColumn pointer to be filled in, or %NULL
7169  * @cell_x: A pointer where the X coordinate relative to the cell can be placed, or %NULL
7170  * @cell_y: A pointer where the Y coordinate relative to the cell can be placed, or %NULL
7171  *
7172  * Finds the path at the point (@x, @y) relative to @window.  If @window is
7173  * NULL, then the point is found relative to the widget coordinates.  This
7174  * function is expected to be called after an event, with event->window being
7175  * passed in as @window.  It is primarily for things like popup menus.  If @path
7176  * is non-NULL, then it will be filled with the #GtkTreePath at that point.
7177  * This path should be freed with #gtk_tree_path_free.  If @column is non-NULL,
7178  * then it will be filled with the column at that point. @cell_x and @cell_y
7179  * return the coordinates relative to the cell background (i.e. the
7180  * background_area passed to gtk_cell_renderer_render()).  This function only
7181  * works if @tree_view is realized.
7182  *
7183  * Return value: TRUE if a row exists at that coordinate.
7184  **/
7185 gboolean
7186 gtk_tree_view_get_path_at_pos (GtkTreeView        *tree_view,
7187                                GdkWindow          *window,
7188                                gint                x,
7189                                gint                y,
7190                                GtkTreePath       **path,
7191                                GtkTreeViewColumn **column,
7192                                gint               *cell_x,
7193                                gint               *cell_y)
7194 {
7195   GtkRBTree *tree;
7196   GtkRBNode *node;
7197   gint y_offset;
7198
7199   g_return_val_if_fail (tree_view != NULL, FALSE);
7200   g_return_val_if_fail (tree_view->priv->tree != NULL, FALSE);
7201   g_return_val_if_fail (tree_view->priv->bin_window != NULL, FALSE);
7202
7203   if (window)
7204     g_return_val_if_fail (window == tree_view->priv->bin_window, FALSE);
7205
7206   if (path)
7207     *path = NULL;
7208   if (column)
7209     *column = NULL;
7210
7211   if (x > tree_view->priv->hadjustment->upper)
7212     return FALSE;
7213
7214   if (x < 0 || y < 0)
7215     return FALSE;
7216
7217   if (column || cell_x)
7218     {
7219       GtkTreeViewColumn *tmp_column;
7220       GtkTreeViewColumn *last_column = NULL;
7221       GList *list;
7222       gint remaining_x = x;
7223       gboolean found = FALSE;
7224
7225       for (list = tree_view->priv->columns; list; list = list->next)
7226         {
7227           tmp_column = list->data;
7228
7229           if (tmp_column->visible == FALSE)
7230             continue;
7231
7232           last_column = tmp_column;
7233           if (remaining_x <= tmp_column->width)
7234             {
7235               found = TRUE;
7236
7237               if (column)
7238                 *column = tmp_column;
7239
7240               if (cell_x)
7241                 *cell_x = remaining_x;
7242
7243               break;
7244             }
7245           remaining_x -= tmp_column->width;
7246         }
7247
7248       if (!found)
7249         {
7250           if (column)
7251             *column = last_column;
7252
7253           if (cell_x)
7254             *cell_x = last_column->width + remaining_x;
7255         }
7256     }
7257
7258   if (window)
7259     {
7260       y_offset = _gtk_rbtree_find_offset (tree_view->priv->tree,
7261                                           TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, y),
7262                                           &tree, &node);
7263     }
7264   else
7265     {
7266       if (y < TREE_VIEW_HEADER_HEIGHT (tree_view))
7267         return FALSE;
7268
7269       y_offset = _gtk_rbtree_find_offset (tree_view->priv->tree,
7270                                           TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, y + tree_view->priv->vadjustment->value),
7271                                           &tree, &node);
7272     }
7273
7274   if (tree == NULL)
7275     return FALSE;
7276
7277   if (cell_y)
7278     *cell_y = y_offset;
7279
7280   if (path)
7281     *path = _gtk_tree_view_find_path (tree_view, tree, node);
7282
7283   return TRUE;
7284 }
7285
7286
7287 /**
7288  * gtk_tree_view_get_cell_area:
7289  * @tree_view: a #GtkTreeView
7290  * @path: a #GtkTreePath for the row, or %NULL to get only horizontal coordinates
7291  * @column: a #GtkTreeViewColumn for the column, or %NULL to get only vertical coordiantes
7292  * @rect: rectangle to fill with cell rect
7293  *
7294  * Fills the bounding rectangle in tree window coordinates for the cell at the
7295  * row specified by @path and the column specified by @column.  If @path is
7296  * %NULL, the y and height fields of the rectangle will be filled with 0. If
7297  * @column is %NULL, the x and width fields will be filled with 0.  The sum of
7298  * all cell rects does not cover the entire tree; there are extra pixels in
7299  * between rows, for example. The returned rectangle is equivalent to the
7300  * @cell_area passed to gtk_cell_renderer_render().  This function is only valid
7301  * if #tree_view is realized.
7302  **/
7303 void
7304 gtk_tree_view_get_cell_area (GtkTreeView        *tree_view,
7305                              GtkTreePath        *path,
7306                              GtkTreeViewColumn  *column,
7307                              GdkRectangle       *rect)
7308 {
7309   GtkRBTree *tree = NULL;
7310   GtkRBNode *node = NULL;
7311   gint vertical_separator;
7312
7313   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
7314   g_return_if_fail (column == NULL || GTK_IS_TREE_VIEW_COLUMN (column));
7315   g_return_if_fail (rect != NULL);
7316
7317   gtk_widget_style_get (GTK_WIDGET (tree_view), "vertical_separator", &vertical_separator, NULL);
7318
7319   rect->x = 0;
7320   rect->y = 0;
7321   rect->width = 0;
7322   rect->height = 0;
7323
7324   if (path)
7325     {
7326       /* Get vertical coords */
7327
7328       _gtk_tree_view_find_node (tree_view, path, &tree, &node);
7329
7330       if (tree == NULL)
7331         {
7332           g_warning (G_STRLOC": no row corresponding to path");
7333           return;
7334         }
7335
7336       /* Remember that the rbtree stores node height including the vertical
7337        * separator, see comment at top of file.
7338        */
7339       rect->y = CELL_FIRST_PIXEL (tree_view, tree, node, vertical_separator);
7340
7341       rect->height = CELL_HEIGHT (node, vertical_separator);
7342     }
7343
7344   if (column)
7345     {
7346       gint x2 = 0;
7347
7348       gtk_tree_view_get_cell_xrange (tree_view, tree, column, &rect->x, &x2);
7349       rect->width = x2 - rect->x;
7350     }
7351 }
7352
7353 /**
7354  * gtk_tree_view_get_background_area:
7355  * @tree_view: a #GtkTreeView
7356  * @path: a #GtkTreePath for the row, or %NULL to get only horizontal coordinates
7357  * @column: a #GtkTreeViewColumn for the column, or %NULL to get only vertical coordiantes
7358  * @rect: rectangle to fill with cell background rect
7359  *
7360  * Fills the bounding rectangle in tree window coordinates for the
7361  * cell at the row specified by @path and the column specified by
7362  * @column.  If @path is %NULL, the y and height fields of the
7363  * rectangle will be filled with 0. If @column is %NULL, the x and
7364  * width fields will be filled with 0.  The returned rectangle is
7365  * equivalent to the @background_area passed to
7366  * gtk_cell_renderer_render().  These background areas tile to cover
7367  * the entire tree window (except for the area used for header
7368  * buttons). Contrast with the cell_area, returned by
7369  * gtk_tree_view_get_cell_area(), which returns only the cell itself,
7370  * excluding surrounding borders and the tree expander area.
7371  *
7372  **/
7373 void
7374 gtk_tree_view_get_background_area (GtkTreeView        *tree_view,
7375                                    GtkTreePath        *path,
7376                                    GtkTreeViewColumn  *column,
7377                                    GdkRectangle       *rect)
7378 {
7379   GtkRBTree *tree = NULL;
7380   GtkRBNode *node = NULL;
7381
7382   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
7383   g_return_if_fail (column == NULL || GTK_IS_TREE_VIEW_COLUMN (column));
7384   g_return_if_fail (rect != NULL);
7385
7386   rect->x = 0;
7387   rect->y = 0;
7388   rect->width = 0;
7389   rect->height = 0;
7390
7391   if (path)
7392     {
7393       /* Get vertical coords */
7394
7395       _gtk_tree_view_find_node (tree_view, path, &tree, &node);
7396
7397       if (tree == NULL)
7398         {
7399           g_warning (G_STRLOC": no row corresponding to path");
7400           return;
7401         }
7402
7403       rect->y = BACKGROUND_FIRST_PIXEL (tree_view, tree, node);
7404
7405       rect->height = BACKGROUND_HEIGHT (node);
7406     }
7407
7408   if (column)
7409     {
7410       gint x2 = 0;
7411
7412       gtk_tree_view_get_background_xrange (tree_view, tree, column, &rect->x, &x2);
7413       rect->width = x2 - rect->x;
7414     }
7415 }
7416
7417 /**
7418  * gtk_tree_view_get_visible_rect:
7419  * @tree_view: a #GtkTreeView
7420  * @visible_rect: rectangle to fill
7421  *
7422  * Fills @visible_rect with the currently-visible region of the
7423  * buffer, in tree coordinates. Convert to widget coordinates with
7424  * gtk_tree_view_tree_to_widget_coords(). Tree coordinates start at
7425  * 0,0 for row 0 of the tree, and cover the entire scrollable area of
7426  * the tree.
7427  **/
7428 void
7429 gtk_tree_view_get_visible_rect (GtkTreeView  *tree_view,
7430                                 GdkRectangle *visible_rect)
7431 {
7432   GtkWidget *widget;
7433
7434   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
7435
7436   widget = GTK_WIDGET (tree_view);
7437
7438   if (visible_rect)
7439     {
7440       visible_rect->x = tree_view->priv->hadjustment->value;
7441       visible_rect->y = tree_view->priv->vadjustment->value;
7442       visible_rect->width = widget->allocation.width;
7443       visible_rect->height = widget->allocation.height - TREE_VIEW_HEADER_HEIGHT (tree_view);
7444     }
7445 }
7446
7447 /**
7448  * gtk_tree_view_widget_to_tree_coords:
7449  * @tree_view: a #GtkTreeView
7450  * @wx: widget X coordinate
7451  * @wy: widget Y coordinate
7452  * @tx: return location for tree X coordinate
7453  * @ty: return location for tree Y coordinate
7454  *
7455  * Converts widget coordinates to coordinates for the
7456  * tree window (the full scrollable area of the tree).
7457  *
7458  **/
7459 void
7460 gtk_tree_view_widget_to_tree_coords (GtkTreeView *tree_view,
7461                                      gint         wx,
7462                                      gint         wy,
7463                                      gint        *tx,
7464                                      gint        *ty)
7465 {
7466   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
7467
7468   if (tx)
7469     {
7470       *tx = wx + tree_view->priv->hadjustment->value;
7471     }
7472
7473   if (ty)
7474     {
7475       *ty = wy + tree_view->priv->vadjustment->value;
7476     }
7477 }
7478
7479 /**
7480  * gtk_tree_view_tree_to_widget_coords:
7481  * @tree_view: a #GtkTreeView
7482  * @tx: tree X coordinate
7483  * @ty: tree Y coordinate
7484  * @wx: return location for widget X coordinate
7485  * @wy: return location for widget Y coordinate
7486  *
7487  * Converts tree coordinates (coordinates in full scrollable area of the tree)
7488  * to widget coordinates.
7489  *
7490  **/
7491 void
7492 gtk_tree_view_tree_to_widget_coords (GtkTreeView *tree_view,
7493                                      gint         tx,
7494                                      gint         ty,
7495                                      gint        *wx,
7496                                      gint        *wy)
7497 {
7498   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
7499
7500   if (wx)
7501     {
7502       *wx = tx - tree_view->priv->hadjustment->value;
7503     }
7504
7505   if (wy)
7506     {
7507       *wy = ty - tree_view->priv->vadjustment->value;
7508     }
7509 }
7510
7511
7512 void
7513 gtk_tree_view_set_rows_drag_source (GtkTreeView              *tree_view,
7514                                     GdkModifierType           start_button_mask,
7515                                     const GtkTargetEntry     *targets,
7516                                     gint                      n_targets,
7517                                     GdkDragAction             actions,
7518                                     GtkTreeViewDraggableFunc  row_draggable_func,
7519                                     gpointer                  user_data)
7520 {
7521   TreeViewDragInfo *di;
7522
7523   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
7524
7525   di = ensure_info (tree_view);
7526   clear_source_info (di);
7527
7528   di->start_button_mask = start_button_mask;
7529   di->source_target_list = gtk_target_list_new (targets, n_targets);
7530   di->source_actions = actions;
7531
7532   if (row_draggable_func)
7533     {
7534       di->row_draggable_closure = g_cclosure_new ((GCallback) row_draggable_func,
7535                                                   user_data, NULL);
7536       g_closure_ref (di->row_draggable_closure);
7537       g_closure_sink (di->row_draggable_closure);
7538     }
7539
7540   di->source_set = TRUE;
7541 }
7542
7543 void
7544 gtk_tree_view_set_rows_drag_dest (GtkTreeView              *tree_view,
7545                                   const GtkTargetEntry     *targets,
7546                                   gint                      n_targets,
7547                                   GdkDragAction             actions,
7548                                   GtkTreeViewDroppableFunc  location_droppable_func,
7549                                   gpointer                  user_data)
7550 {
7551   TreeViewDragInfo *di;
7552
7553   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
7554
7555   gtk_drag_dest_set (GTK_WIDGET (tree_view),
7556                      0,
7557                      NULL,
7558                      0,
7559                      actions);
7560
7561   di = ensure_info (tree_view);
7562   clear_dest_info (di);
7563
7564   if (targets)
7565     di->dest_target_list = gtk_target_list_new (targets, n_targets);
7566
7567   if (location_droppable_func)
7568     {
7569       di->location_droppable_closure = g_cclosure_new ((GCallback) location_droppable_func,
7570                                                        user_data, NULL);
7571       g_closure_ref (di->location_droppable_closure);
7572       g_closure_sink (di->location_droppable_closure);
7573     }
7574
7575   di->dest_set = TRUE;
7576 }
7577
7578 void
7579 gtk_tree_view_unset_rows_drag_source (GtkTreeView *tree_view)
7580 {
7581   TreeViewDragInfo *di;
7582
7583   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
7584
7585   di = get_info (tree_view);
7586
7587   if (di)
7588     {
7589       if (di->source_set)
7590         {
7591           clear_source_info (di);
7592           di->source_set = FALSE;
7593         }
7594
7595       if (!di->dest_set && !di->source_set)
7596         remove_info (tree_view);
7597     }
7598 }
7599
7600 void
7601 gtk_tree_view_unset_rows_drag_dest (GtkTreeView *tree_view)
7602 {
7603   TreeViewDragInfo *di;
7604
7605   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
7606
7607   di = get_info (tree_view);
7608
7609   if (di)
7610     {
7611       if (di->dest_set)
7612         {
7613           gtk_drag_dest_unset (GTK_WIDGET (tree_view));
7614           clear_dest_info (di);
7615           di->dest_set = FALSE;
7616         }
7617
7618       if (!di->dest_set && !di->source_set)
7619         remove_info (tree_view);
7620     }
7621 }
7622
7623 void
7624 gtk_tree_view_set_drag_dest_row (GtkTreeView            *tree_view,
7625                                  GtkTreePath            *path,
7626                                  GtkTreeViewDropPosition pos)
7627 {
7628   GtkTreePath *current_dest;
7629   /* Note; this function is exported to allow a custom DND
7630    * implementation, so it can't touch TreeViewDragInfo
7631    */
7632
7633   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
7634
7635   current_dest = NULL;
7636
7637   if (tree_view->priv->drag_dest_row)
7638     current_dest = gtk_tree_row_reference_get_path (tree_view->priv->drag_dest_row);
7639
7640   if (current_dest)
7641     {
7642       gtk_tree_view_queue_draw_path (tree_view, current_dest, NULL);
7643       gtk_tree_path_free (current_dest);
7644     }
7645
7646   if (tree_view->priv->drag_dest_row)
7647     gtk_tree_row_reference_free (tree_view->priv->drag_dest_row);
7648
7649   tree_view->priv->drag_dest_pos = pos;
7650
7651   if (path)
7652     {
7653       tree_view->priv->drag_dest_row =
7654         gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view), tree_view->priv->model, path);
7655       gtk_tree_view_queue_draw_path (tree_view, path, NULL);
7656     }
7657   else
7658     tree_view->priv->drag_dest_row = NULL;
7659 }
7660
7661 void
7662 gtk_tree_view_get_drag_dest_row (GtkTreeView              *tree_view,
7663                                  GtkTreePath             **path,
7664                                  GtkTreeViewDropPosition  *pos)
7665 {
7666   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
7667
7668   if (path)
7669     {
7670       if (tree_view->priv->drag_dest_row)
7671         *path = gtk_tree_row_reference_get_path (tree_view->priv->drag_dest_row);
7672       else
7673         *path = NULL;
7674     }
7675
7676   if (pos)
7677     *pos = tree_view->priv->drag_dest_pos;
7678 }
7679
7680 gboolean
7681 gtk_tree_view_get_dest_row_at_pos (GtkTreeView             *tree_view,
7682                                    gint                     drag_x,
7683                                    gint                     drag_y,
7684                                    GtkTreePath            **path,
7685                                    GtkTreeViewDropPosition *pos)
7686 {
7687   gint cell_y;
7688   gdouble offset_into_row;
7689   gdouble quarter;
7690   gint x, y;
7691   GdkRectangle cell;
7692   GtkTreeViewColumn *column = NULL;
7693   GtkTreePath *tmp_path = NULL;
7694
7695   /* Note; this function is exported to allow a custom DND
7696    * implementation, so it can't touch TreeViewDragInfo
7697    */
7698
7699   g_return_val_if_fail (tree_view != NULL, FALSE);
7700   g_return_val_if_fail (drag_x >= 0, FALSE);
7701   g_return_val_if_fail (drag_y >= 0, FALSE);
7702   g_return_val_if_fail (tree_view->priv->bin_window != NULL, FALSE);
7703
7704
7705   if (path)
7706     *path = NULL;
7707
7708   if (tree_view->priv->tree == NULL)
7709     return FALSE;
7710
7711   /* remember that drag_x and drag_y are in widget coords, convert to tree window */
7712
7713   gtk_tree_view_widget_to_tree_coords (tree_view, drag_x, drag_y,
7714                                        &x, &y);
7715
7716   /* If in the top quarter of a row, we drop before that row; if
7717    * in the bottom quarter, drop after that row; if in the middle,
7718    * and the row has children, drop into the row.
7719    */
7720
7721   if (!gtk_tree_view_get_path_at_pos (tree_view,
7722                                       tree_view->priv->bin_window,
7723                                       x, y,
7724                                       &tmp_path,
7725                                       &column,
7726                                       NULL,
7727                                       &cell_y))
7728     return FALSE;
7729
7730   gtk_tree_view_get_background_area (tree_view, tmp_path, column,
7731                                      &cell);
7732
7733   offset_into_row = cell_y;
7734
7735   if (path)
7736     *path = tmp_path;
7737   else
7738     gtk_tree_path_free (tmp_path);
7739
7740   tmp_path = NULL;
7741
7742   quarter = cell.height / 4.0;
7743
7744   if (pos)
7745     {
7746       if (offset_into_row < quarter)
7747         {
7748           *pos = GTK_TREE_VIEW_DROP_BEFORE;
7749         }
7750       else if (offset_into_row < quarter * 2)
7751         {
7752           *pos = GTK_TREE_VIEW_DROP_INTO_OR_BEFORE;
7753         }
7754       else if (offset_into_row < quarter * 3)
7755         {
7756           *pos = GTK_TREE_VIEW_DROP_INTO_OR_AFTER;
7757         }
7758       else
7759         {
7760           *pos = GTK_TREE_VIEW_DROP_AFTER;
7761         }
7762     }
7763
7764   return TRUE;
7765 }
7766
7767
7768
7769 /* KEEP IN SYNC WITH GTK_TREE_VIEW_BIN_EXPOSE */
7770 /**
7771  * gtk_tree_view_create_row_drag_icon:
7772  * @tree_view: a #GtkTreeView
7773  * @path: a #GtkTreePath in @tree_view
7774  *
7775  * Creates a GdkPixmap representation of the row at @path.  This image is used
7776  * for a drag icon.
7777  *
7778  * Return value: a newly allocatdd pixmap of the drag icon.
7779  **/
7780 GdkPixmap *
7781 gtk_tree_view_create_row_drag_icon (GtkTreeView  *tree_view,
7782                                     GtkTreePath  *path)
7783 {
7784   GtkTreeIter   iter;
7785   GtkRBTree    *tree;
7786   GtkRBNode    *node;
7787   GtkCellRenderer *cell;
7788   gint i;
7789   gint cell_offset;
7790   GList *list;
7791   GdkRectangle background_area;
7792   GtkWidget *widget;
7793   gint depth;
7794   /* start drawing inside the black outline */
7795   gint x = 1, y = 1;
7796   GdkDrawable *drawable;
7797   gint bin_window_width;
7798
7799   widget = GTK_WIDGET (tree_view);
7800
7801   depth = gtk_tree_path_get_depth (path);
7802
7803   _gtk_tree_view_find_node (tree_view,
7804                             path,
7805                             &tree,
7806                             &node);
7807
7808   if (tree == NULL)
7809     return NULL;
7810
7811   if (!gtk_tree_model_get_iter (tree_view->priv->model,
7812                                 &iter,
7813                                 path))
7814     return NULL;
7815
7816   cell_offset = x;
7817
7818   background_area.y = y;
7819   background_area.height = BACKGROUND_HEIGHT (node);
7820
7821   gdk_drawable_get_size (tree_view->priv->bin_window,
7822                          &bin_window_width, NULL);
7823
7824   drawable = gdk_pixmap_new (tree_view->priv->bin_window,
7825                              bin_window_width + 2,
7826                              background_area.height + 2,
7827                              -1);
7828
7829   gdk_draw_rectangle (drawable,
7830                       widget->style->base_gc[GTK_WIDGET_STATE (widget)],
7831                       TRUE,
7832                       0, 0,
7833                       bin_window_width + 2,
7834                       background_area.height + 2);
7835
7836   gdk_draw_rectangle (drawable,
7837                       widget->style->black_gc,
7838                       FALSE,
7839                       0, 0,
7840                       bin_window_width + 1,
7841                       background_area.height + 1);
7842
7843   for (i = 0, list = tree_view->priv->columns; i < tree_view->priv->n_columns; i++, list = list->next)
7844     {
7845       GtkTreeViewColumn *column = list->data;
7846       GdkRectangle cell_area;
7847       gboolean visible;
7848       gint vertical_separator;
7849
7850       if (!column->visible)
7851         continue;
7852
7853       cell = column->cell;
7854       gtk_tree_view_column_cell_set_cell_data (column,
7855                                                tree_view->priv->model,
7856                                                &iter);
7857
7858       background_area.x = cell_offset;
7859       background_area.width = column->displayed_width;
7860
7861       cell_area = background_area;
7862
7863       gtk_widget_style_get (widget, "vertical_separator", &vertical_separator, NULL);
7864       cell_area.y += vertical_separator / 2;
7865       cell_area.height -= vertical_separator;
7866
7867       if (i == tree_view->priv->expander_column &&
7868           TREE_VIEW_DRAW_EXPANDERS(tree_view))
7869         {
7870           cell_area.x += depth * tree_view->priv->tab_offset;
7871           cell_area.width -= depth * tree_view->priv->tab_offset;
7872         }
7873
7874       g_object_get (G_OBJECT (cell), "visible", &visible, NULL);
7875       if (visible)
7876         gtk_cell_renderer_render (cell,
7877                                   drawable,
7878                                   widget,
7879                                   &background_area,
7880                                   &cell_area,
7881                                   NULL,
7882                                   0);
7883
7884       cell_offset += column->displayed_width;
7885     }
7886
7887   return drawable;
7888 }
7889