Pileus Git - ~andy/gtk/blob - gtk/gtktreeviewcolumn.c

   1 /* gtktreeviewcolumn.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 #include "config.h"
  21
  22 #include "gtktreeviewcolumn.h"
  23
  24 #include <string.h>
  25
  26 #include "gtktreeview.h"
  27 #include "gtktreeprivate.h"
  28 #include "gtkcelllayout.h"
  29 #include "gtkbutton.h"
  30 #include "gtkalignment.h"
  31 #include "gtklabel.h"
  32 #include "gtkhbox.h"
  33 #include "gtkmarshalers.h"
  34 #include "gtkarrow.h"
  35 #include "gtkcellareacontext.h"
  36 #include "gtkcellareabox.h"
  37 #include "gtkprivate.h"
  38 #include "gtkintl.h"
  39
  40
  41 /**
  42  * SECTION:gtktreeviewcolumn
  43  * @Short_description: A visible column in a GtkTreeView widget
  44  * @Title: GtkTreeViewColumn
  45  * @See_also: #GtkTreeView, #GtkTreeSelection, #GtkTreeDnd, #GtkTreeMode, #GtkTreeSortable,
  46  *   #GtkTreeModelSort, #GtkListStore, #GtkTreeStore, #GtkCellRenderer, #GtkCellEditable,
  47  *   #GtkCellRendererPixbuf, #GtkCellRendererText, #GtkCellRendererToggle
  48  *
  49  * The GtkTreeViewColumn object represents a visible column in a #GtkTreeView widget.
  50  * It allows to set properties of the column header, and functions as a holding pen for
  51  * the cell renderers which determine how the data in the column is displayed.
  52  *
  53  * Please refer to the <link linkend="TreeWidget">tree widget conceptual overview</link>
  54  * for an overview of all the objects and data types related to the tree widget and how
  55  * they work together.
  56  */
  57
  58
  59 /* Type methods */
  60 static void gtk_tree_view_column_cell_layout_init              (GtkCellLayoutIface      *iface);
  61
  62 /* GObject methods */
  63 static void gtk_tree_view_column_set_property                  (GObject                 *object,
  64                                                                 guint                    prop_id,
  65                                                                 const GValue            *value,
  66                                                                 GParamSpec              *pspec);
  67 static void gtk_tree_view_column_get_property                  (GObject                 *object,
  68                                                                 guint                    prop_id,
  69                                                                 GValue                  *value,
  70                                                                 GParamSpec              *pspec);
  71 static void gtk_tree_view_column_finalize                      (GObject                 *object);
  72 static void gtk_tree_view_column_dispose                       (GObject                 *object);
  73 static GObject *gtk_tree_view_column_constructor               (GType                    type,
  74                                                                 guint                    n_construct_properties,
  75                                                                 GObjectConstructParam   *construct_properties);
  76
  77 /* GtkCellLayout implementation */
  78 static GtkCellArea *gtk_tree_view_column_cell_layout_get_area  (GtkCellLayout           *cell_layout);
  79
  80 /* Button handling code */
  81 static void gtk_tree_view_column_create_button                 (GtkTreeViewColumn       *tree_column);
  82 static void gtk_tree_view_column_update_button                 (GtkTreeViewColumn       *tree_column);
  83
  84 /* Button signal handlers */
  85 static gint gtk_tree_view_column_button_event                  (GtkWidget               *widget,
  86                                                                 GdkEvent                *event,
  87                                                                 gpointer                 data);
  88 static void gtk_tree_view_column_button_clicked                (GtkWidget               *widget,
  89                                                                 gpointer                 data);
  90 static gboolean gtk_tree_view_column_mnemonic_activate         (GtkWidget *widget,
  91                                                                 gboolean   group_cycling,
  92                                                                 gpointer   data);
  93
  94 /* Property handlers */
  95 static void gtk_tree_view_model_sort_column_changed            (GtkTreeSortable         *sortable,
  96                                                                 GtkTreeViewColumn       *tree_column);
  97
  98 /* GtkCellArea/GtkCellAreaContext callbacks */
  99 static void gtk_tree_view_column_context_changed               (GtkCellAreaContext      *context,
 100                                                                 GParamSpec              *pspec,
 101                                                                 GtkTreeViewColumn       *tree_column);
 102 static void gtk_tree_view_column_add_editable_callback         (GtkCellArea             *area,
 103                                                                 GtkCellRenderer         *renderer,
 104                                                                 GtkCellEditable         *edit_widget,
 105                                                                 GdkRectangle            *cell_area,
 106                                                                 const gchar             *path_string,
 107                                                                 gpointer                 user_data);
 108 static void gtk_tree_view_column_remove_editable_callback      (GtkCellArea             *area,
 109                                                                 GtkCellRenderer         *renderer,
 110                                                                 GtkCellEditable         *edit_widget,
 111                                                                 gpointer                 user_data);
 112
 113 /* Internal functions */
 114 static void gtk_tree_view_column_sort                          (GtkTreeViewColumn       *tree_column,
 115                                                                 gpointer                 data);
 116 static void gtk_tree_view_column_setup_sort_column_id_callback (GtkTreeViewColumn       *tree_column);
 117 static void gtk_tree_view_column_set_attributesv               (GtkTreeViewColumn       *tree_column,
 118                                                                 GtkCellRenderer         *cell_renderer,
 119                                                                 va_list                  args);
 120
 121 /* GtkBuildable implementation */
 122 static void gtk_tree_view_column_buildable_init                 (GtkBuildableIface     *iface);
 123
 124
 125 struct _GtkTreeViewColumnPrivate
 126 {
 127   GtkWidget *tree_view;
 128   GtkWidget *button;
 129   GtkWidget *child;
 130   GtkWidget *arrow;
 131   GtkWidget *alignment;
 132   GdkWindow *window;
 133   gfloat xalign;
 134   gulong property_changed_signal;
 135
 136   /* Sizing fields */
 137   /* see gtk+/doc/tree-column-sizing.txt for more information on them */
 138   GtkTreeViewColumnSizing column_type;
 139   gint requested_width;
 140   gint resized_width;
 141   gint width;
 142   gint fixed_width;
 143   gint min_width;
 144   gint max_width;
 145
 146   /* dragging columns */
 147   gint drag_x;
 148   gint drag_y;
 149
 150   gchar *title;
 151
 152   /* Sorting */
 153   gulong      sort_clicked_signal;
 154   gulong      sort_column_changed_signal;
 155   gint        sort_column_id;
 156   GtkSortType sort_order;
 157
 158   /* Cell area */
 159   GtkCellArea        *cell_area;
 160   GtkCellAreaContext *cell_area_context;
 161   gulong              add_editable_signal;
 162   gulong              remove_editable_signal;
 163   gulong              context_changed_signal;
 164
 165   /* Flags */
 166   guint visible             : 1;
 167   guint resizable           : 1;
 168   guint clickable           : 1;
 169   guint dirty               : 1;
 170   guint show_sort_indicator : 1;
 171   guint maybe_reordered     : 1;
 172   guint reorderable         : 1;
 173   guint use_resized_width   : 1;
 174   guint expand              : 1;
 175 };
 176
 177 enum
 178 {
 179   PROP_0,
 180   PROP_VISIBLE,
 181   PROP_RESIZABLE,
 182   PROP_WIDTH,
 183   PROP_SPACING,
 184   PROP_SIZING,
 185   PROP_FIXED_WIDTH,
 186   PROP_MIN_WIDTH,
 187   PROP_MAX_WIDTH,
 188   PROP_TITLE,
 189   PROP_EXPAND,
 190   PROP_CLICKABLE,
 191   PROP_WIDGET,
 192   PROP_ALIGNMENT,
 193   PROP_REORDERABLE,
 194   PROP_SORT_INDICATOR,
 195   PROP_SORT_ORDER,
 196   PROP_SORT_COLUMN_ID
 197 };
 198
 199 enum
 200 {
 201   CLICKED,
 202   LAST_SIGNAL
 203 };
 204
 205 static guint tree_column_signals[LAST_SIGNAL] = { 0 };
 206
 207 G_DEFINE_TYPE_WITH_CODE (GtkTreeViewColumn, gtk_tree_view_column, G_TYPE_INITIALLY_UNOWNED,
 208                          G_IMPLEMENT_INTERFACE (GTK_TYPE_CELL_LAYOUT,
 209                                                 gtk_tree_view_column_cell_layout_init)
 210                          G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE,
 211                                                 gtk_tree_view_column_buildable_init))
 212
 213
 214 static void
 215 gtk_tree_view_column_class_init (GtkTreeViewColumnClass *class)
 216 {
 217   GObjectClass *object_class;
 218
 219   object_class = (GObjectClass*) class;
 220
 221   class->clicked = NULL;
 222
 223   object_class->constructor = gtk_tree_view_column_constructor;
 224   object_class->finalize = gtk_tree_view_column_finalize;
 225   object_class->dispose = gtk_tree_view_column_dispose;
 226   object_class->set_property = gtk_tree_view_column_set_property;
 227   object_class->get_property = gtk_tree_view_column_get_property;
 228
 229   tree_column_signals[CLICKED] =
 230     g_signal_new (I_("clicked"),
 231                   G_OBJECT_CLASS_TYPE (object_class),
 232                   G_SIGNAL_RUN_LAST,
 233                   G_STRUCT_OFFSET (GtkTreeViewColumnClass, clicked),
 234                   NULL, NULL,
 235                   _gtk_marshal_VOID__VOID,
 236                   G_TYPE_NONE, 0);
 237
 238   g_object_class_install_property (object_class,
 239                                    PROP_VISIBLE,
 240                                    g_param_spec_boolean ("visible",
 241                                                         P_("Visible"),
 242                                                         P_("Whether to display the column"),
 243                                                          TRUE,
 244                                                          GTK_PARAM_READWRITE));
 245
 246   g_object_class_install_property (object_class,
 247                                    PROP_RESIZABLE,
 248                                    g_param_spec_boolean ("resizable",
 249                                                          P_("Resizable"),
 250                                                          P_("Column is user-resizable"),
 251                                                          FALSE,
 252                                                          GTK_PARAM_READWRITE));
 253
 254   g_object_class_install_property (object_class,
 255                                    PROP_WIDTH,
 256                                    g_param_spec_int ("width",
 257                                                      P_("Width"),
 258                                                      P_("Current width of the column"),
 259                                                      0,
 260                                                      G_MAXINT,
 261                                                      0,
 262                                                      GTK_PARAM_READABLE));
 263   g_object_class_install_property (object_class,
 264                                    PROP_SPACING,
 265                                    g_param_spec_int ("spacing",
 266                                                      P_("Spacing"),
 267                                                      P_("Space which is inserted between cells"),
 268                                                      0,
 269                                                      G_MAXINT,
 270                                                      0,
 271                                                      GTK_PARAM_READWRITE));
 272   g_object_class_install_property (object_class,
 273                                    PROP_SIZING,
 274                                    g_param_spec_enum ("sizing",
 275                                                       P_("Sizing"),
 276                                                       P_("Resize mode of the column"),
 277                                                       GTK_TYPE_TREE_VIEW_COLUMN_SIZING,
 278                                                       GTK_TREE_VIEW_COLUMN_GROW_ONLY,
 279                                                       GTK_PARAM_READWRITE));
 280
 281   g_object_class_install_property (object_class,
 282                                    PROP_FIXED_WIDTH,
 283                                    g_param_spec_int ("fixed-width",
 284                                                      P_("Fixed Width"),
 285                                                      P_("Current fixed width of the column"),
 286                                                      1,
 287                                                      G_MAXINT,
 288                                                      1, /* not useful */
 289                                                      GTK_PARAM_READWRITE));
 290
 291   g_object_class_install_property (object_class,
 292                                    PROP_MIN_WIDTH,
 293                                    g_param_spec_int ("min-width",
 294                                                      P_("Minimum Width"),
 295                                                      P_("Minimum allowed width of the column"),
 296                                                      -1,
 297                                                      G_MAXINT,
 298                                                      -1,
 299                                                      GTK_PARAM_READWRITE));
 300
 301   g_object_class_install_property (object_class,
 302                                    PROP_MAX_WIDTH,
 303                                    g_param_spec_int ("max-width",
 304                                                      P_("Maximum Width"),
 305                                                      P_("Maximum allowed width of the column"),
 306                                                      -1,
 307                                                      G_MAXINT,
 308                                                      -1,
 309                                                      GTK_PARAM_READWRITE));
 310
 311   g_object_class_install_property (object_class,
 312                                    PROP_TITLE,
 313                                    g_param_spec_string ("title",
 314                                                         P_("Title"),
 315                                                         P_("Title to appear in column header"),
 316                                                         "",
 317                                                         GTK_PARAM_READWRITE));
 318
 319   g_object_class_install_property (object_class,
 320                                    PROP_EXPAND,
 321                                    g_param_spec_boolean ("expand",
 322                                                          P_("Expand"),
 323                                                          P_("Column gets share of extra width allocated to the widget"),
 324                                                          FALSE,
 325                                                          GTK_PARAM_READWRITE));
 326
 327   g_object_class_install_property (object_class,
 328                                    PROP_CLICKABLE,
 329                                    g_param_spec_boolean ("clickable",
 330                                                         P_("Clickable"),
 331                                                         P_("Whether the header can be clicked"),
 332                                                          FALSE,
 333                                                          GTK_PARAM_READWRITE));
 334
 335
 336   g_object_class_install_property (object_class,
 337                                    PROP_WIDGET,
 338                                    g_param_spec_object ("widget",
 339                                                         P_("Widget"),
 340                                                         P_("Widget to put in column header button instead of column title"),
 341                                                         GTK_TYPE_WIDGET,
 342                                                         GTK_PARAM_READWRITE));
 343
 344   g_object_class_install_property (object_class,
 345                                    PROP_ALIGNMENT,
 346                                    g_param_spec_float ("alignment",
 347                                                        P_("Alignment"),
 348                                                        P_("X Alignment of the column header text or widget"),
 349                                                        0.0,
 350                                                        1.0,
 351                                                        0.0,
 352                                                        GTK_PARAM_READWRITE));
 353
 354   g_object_class_install_property (object_class,
 355                                    PROP_REORDERABLE,
 356                                    g_param_spec_boolean ("reorderable",
 357                                                          P_("Reorderable"),
 358                                                          P_("Whether the column can be reordered around the headers"),
 359                                                          FALSE,
 360                                                          GTK_PARAM_READWRITE));
 361
 362   g_object_class_install_property (object_class,
 363                                    PROP_SORT_INDICATOR,
 364                                    g_param_spec_boolean ("sort-indicator",
 365                                                         P_("Sort indicator"),
 366                                                         P_("Whether to show a sort indicator"),
 367                                                          FALSE,
 368                                                          GTK_PARAM_READWRITE));
 369
 370   g_object_class_install_property (object_class,
 371                                    PROP_SORT_ORDER,
 372                                    g_param_spec_enum ("sort-order",
 373                                                       P_("Sort order"),
 374                                                       P_("Sort direction the sort indicator should indicate"),
 375                                                       GTK_TYPE_SORT_TYPE,
 376                                                       GTK_SORT_ASCENDING,
 377                                                       GTK_PARAM_READWRITE));
 378
 379   /**
 380    * GtkTreeViewColumn:sort-column-id:
 381    *
 382    * Logical sort column ID this column sorts on when selected for sorting. Setting the sort column ID makes the column header
 383    * clickable. Set to %-1 to make the column unsortable.
 384    *
 385    * Since: 2.18
 386    **/
 387   g_object_class_install_property (object_class,
 388                                    PROP_SORT_COLUMN_ID,
 389                                    g_param_spec_int ("sort-column-id",
 390                                                      P_("Sort column ID"),
 391                                                      P_("Logical sort column ID this column sorts on when selected for sorting"),
 392                                                      -1,
 393                                                      G_MAXINT,
 394                                                      -1,
 395                                                      GTK_PARAM_READWRITE));
 396
 397   g_type_class_add_private (class, sizeof (GtkTreeViewColumnPrivate));
 398 }
 399
 400 static void
 401 gtk_tree_view_column_custom_tag_end (GtkBuildable *buildable,
 402                                      GtkBuilder   *builder,
 403                                      GObject      *child,
 404                                      const gchar  *tagname,
 405                                      gpointer     *data)
 406 {
 407   /* Just ignore the boolean return from here */
 408   _gtk_cell_layout_buildable_custom_tag_end (buildable, builder, child, tagname, data);
 409 }
 410
 411 static void
 412 gtk_tree_view_column_buildable_init (GtkBuildableIface *iface)
 413 {
 414   iface->add_child = _gtk_cell_layout_buildable_add_child;
 415   iface->custom_tag_start = _gtk_cell_layout_buildable_custom_tag_start;
 416   iface->custom_tag_end = gtk_tree_view_column_custom_tag_end;
 417 }
 418
 419 static void
 420 gtk_tree_view_column_cell_layout_init (GtkCellLayoutIface *iface)
 421 {
 422   iface->get_area = gtk_tree_view_column_cell_layout_get_area;
 423 }
 424
 425 static void
 426 gtk_tree_view_column_init (GtkTreeViewColumn *tree_column)
 427 {
 428   GtkTreeViewColumnPrivate *priv;
 429
 430   tree_column->priv = G_TYPE_INSTANCE_GET_PRIVATE (tree_column,
 431                                                    GTK_TYPE_TREE_VIEW_COLUMN,
 432                                                    GtkTreeViewColumnPrivate);
 433   priv = tree_column->priv;
 434
 435   priv->button = NULL;
 436   priv->xalign = 0.0;
 437   priv->width = 0;
 438   priv->requested_width = -1;
 439   priv->min_width = -1;
 440   priv->max_width = -1;
 441   priv->resized_width = 0;
 442   priv->column_type = GTK_TREE_VIEW_COLUMN_GROW_ONLY;
 443   priv->visible = TRUE;
 444   priv->resizable = FALSE;
 445   priv->expand = FALSE;
 446   priv->clickable = FALSE;
 447   priv->dirty = TRUE;
 448   priv->sort_order = GTK_SORT_ASCENDING;
 449   priv->show_sort_indicator = FALSE;
 450   priv->property_changed_signal = 0;
 451   priv->sort_clicked_signal = 0;
 452   priv->sort_column_changed_signal = 0;
 453   priv->sort_column_id = -1;
 454   priv->reorderable = FALSE;
 455   priv->maybe_reordered = FALSE;
 456   priv->fixed_width = 1;
 457   priv->use_resized_width = FALSE;
 458   priv->title = g_strdup ("");
 459
 460   priv->cell_area = gtk_cell_area_box_new ();
 461   gtk_cell_area_set_style_detail (priv->cell_area, "treeview");
 462   priv->cell_area_context = gtk_cell_area_create_context (priv->cell_area);
 463
 464   priv->context_changed_signal =
 465     g_signal_connect (priv->cell_area_context, "notify",
 466                       G_CALLBACK (gtk_tree_view_column_context_changed), tree_column);
 467
 468   return object;
 469 }
 470
 471 static void
 472 gtk_tree_view_column_dispose (GObject *object)
 473 {
 474   GtkTreeViewColumn        *tree_column = (GtkTreeViewColumn *) object;
 475   GtkTreeViewColumnPrivate *priv        = tree_column->priv;
 476
 477   if (priv->cell_area_context)
 478     {
 479       g_signal_handler_disconnect (priv->cell_area_context,
 480                                    priv->context_changed_signal);
 481
 482       g_object_unref (priv->cell_area_context);
 483
 484       priv->cell_area_context = NULL;
 485       priv->context_changed_signal = 0;
 486     }
 487
 488   if (priv->cell_area)
 489     {
 490       g_object_unref (priv->cell_area);
 491       priv->cell_area = NULL;
 492     }
 493
 494   if (priv->child)
 495     {
 496       g_object_unref (priv->child);
 497       priv->child = NULL;
 498     }
 499
 500   G_OBJECT_CLASS (gtk_tree_view_column_parent_class)->dispose (object);
 501 }
 502
 503 static void
 504 gtk_tree_view_column_finalize (GObject *object)
 505 {
 506   GtkTreeViewColumn        *tree_column = (GtkTreeViewColumn *) object;
 507   GtkTreeViewColumnPrivate *priv        = tree_column->priv;
 508
 509   g_free (priv->title);
 510
 511   G_OBJECT_CLASS (gtk_tree_view_column_parent_class)->finalize (object);
 512 }
 513
 514 static void
 515 gtk_tree_view_column_set_property (GObject         *object,
 516                                    guint            prop_id,
 517                                    const GValue    *value,
 518                                    GParamSpec      *pspec)
 519 {
 520   GtkTreeViewColumn *tree_column;
 521   GtkCellArea       *area;
 522
 523   tree_column = GTK_TREE_VIEW_COLUMN (object);
 524
 525   switch (prop_id)
 526     {
 527     case PROP_VISIBLE:
 528       gtk_tree_view_column_set_visible (tree_column,
 529                                         g_value_get_boolean (value));
 530       break;
 531
 532     case PROP_RESIZABLE:
 533       gtk_tree_view_column_set_resizable (tree_column,
 534                                           g_value_get_boolean (value));
 535       break;
 536
 537     case PROP_SIZING:
 538       gtk_tree_view_column_set_sizing (tree_column,
 539                                        g_value_get_enum (value));
 540       break;
 541
 542     case PROP_FIXED_WIDTH:
 543       gtk_tree_view_column_set_fixed_width (tree_column,
 544                                             g_value_get_int (value));
 545       break;
 546
 547     case PROP_MIN_WIDTH:
 548       gtk_tree_view_column_set_min_width (tree_column,
 549                                           g_value_get_int (value));
 550       break;
 551
 552     case PROP_MAX_WIDTH:
 553       gtk_tree_view_column_set_max_width (tree_column,
 554                                           g_value_get_int (value));
 555       break;
 556
 557     case PROP_SPACING:
 558       gtk_tree_view_column_set_spacing (tree_column,
 559                                         g_value_get_int (value));
 560       break;
 561
 562     case PROP_TITLE:
 563       gtk_tree_view_column_set_title (tree_column,
 564                                       g_value_get_string (value));
 565       break;
 566
 567     case PROP_EXPAND:
 568       gtk_tree_view_column_set_expand (tree_column,
 569                                        g_value_get_boolean (value));
 570       break;
 571
 572     case PROP_CLICKABLE:
 573       gtk_tree_view_column_set_clickable (tree_column,
 574                                           g_value_get_boolean (value));
 575       break;
 576
 577     case PROP_WIDGET:
 578       gtk_tree_view_column_set_widget (tree_column,
 579                                        (GtkWidget*) g_value_get_object (value));
 580       break;
 581
 582     case PROP_ALIGNMENT:
 583       gtk_tree_view_column_set_alignment (tree_column,
 584                                           g_value_get_float (value));
 585       break;
 586
 587     case PROP_REORDERABLE:
 588       gtk_tree_view_column_set_reorderable (tree_column,
 589                                             g_value_get_boolean (value));
 590       break;
 591
 592     case PROP_SORT_INDICATOR:
 593       gtk_tree_view_column_set_sort_indicator (tree_column,
 594                                                g_value_get_boolean (value));
 595       break;
 596
 597     case PROP_SORT_ORDER:
 598       gtk_tree_view_column_set_sort_order (tree_column,
 599                                            g_value_get_enum (value));
 600       break;
 601
 602     case PROP_SORT_COLUMN_ID:
 603       gtk_tree_view_column_set_sort_column_id (tree_column,
 604                                                g_value_get_int (value));
 605       break;
 606
 607     case PROP_CELL_AREA:
 608       /* Construct-only, can only be assigned once */
 609       area = g_value_get_object (value);
 610
 611       if (area)
 612         tree_column->cell_area = g_object_ref_sink (area);
 613       break;
 614
 615     default:
 616       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 617       break;
 618     }
 619 }
 620
 621 static void
 622 gtk_tree_view_column_get_property (GObject         *object,
 623                                    guint            prop_id,
 624                                    GValue          *value,
 625                                    GParamSpec      *pspec)
 626 {
 627   GtkTreeViewColumn *tree_column;
 628
 629   tree_column = GTK_TREE_VIEW_COLUMN (object);
 630
 631   switch (prop_id)
 632     {
 633     case PROP_VISIBLE:
 634       g_value_set_boolean (value,
 635                            gtk_tree_view_column_get_visible (tree_column));
 636       break;
 637
 638     case PROP_RESIZABLE:
 639       g_value_set_boolean (value,
 640                            gtk_tree_view_column_get_resizable (tree_column));
 641       break;
 642
 643     case PROP_WIDTH:
 644       g_value_set_int (value,
 645                        gtk_tree_view_column_get_width (tree_column));
 646       break;
 647
 648     case PROP_SPACING:
 649       g_value_set_int (value,
 650                        gtk_tree_view_column_get_spacing (tree_column));
 651       break;
 652
 653     case PROP_SIZING:
 654       g_value_set_enum (value,
 655                         gtk_tree_view_column_get_sizing (tree_column));
 656       break;
 657
 658     case PROP_FIXED_WIDTH:
 659       g_value_set_int (value,
 660                        gtk_tree_view_column_get_fixed_width (tree_column));
 661       break;
 662
 663     case PROP_MIN_WIDTH:
 664       g_value_set_int (value,
 665                        gtk_tree_view_column_get_min_width (tree_column));
 666       break;
 667
 668     case PROP_MAX_WIDTH:
 669       g_value_set_int (value,
 670                        gtk_tree_view_column_get_max_width (tree_column));
 671       break;
 672
 673     case PROP_TITLE:
 674       g_value_set_string (value,
 675                           gtk_tree_view_column_get_title (tree_column));
 676       break;
 677
 678     case PROP_EXPAND:
 679       g_value_set_boolean (value,
 680                           gtk_tree_view_column_get_expand (tree_column));
 681       break;
 682
 683     case PROP_CLICKABLE:
 684       g_value_set_boolean (value,
 685                            gtk_tree_view_column_get_clickable (tree_column));
 686       break;
 687
 688     case PROP_WIDGET:
 689       g_value_set_object (value,
 690                           (GObject*) gtk_tree_view_column_get_widget (tree_column));
 691       break;
 692
 693     case PROP_ALIGNMENT:
 694       g_value_set_float (value,
 695                          gtk_tree_view_column_get_alignment (tree_column));
 696       break;
 697
 698     case PROP_REORDERABLE:
 699       g_value_set_boolean (value,
 700                            gtk_tree_view_column_get_reorderable (tree_column));
 701       break;
 702
 703     case PROP_SORT_INDICATOR:
 704       g_value_set_boolean (value,
 705                            gtk_tree_view_column_get_sort_indicator (tree_column));
 706       break;
 707
 708     case PROP_SORT_ORDER:
 709       g_value_set_enum (value,
 710                         gtk_tree_view_column_get_sort_order (tree_column));
 711       break;
 712
 713     case PROP_SORT_COLUMN_ID:
 714       g_value_set_int (value,
 715                        gtk_tree_view_column_get_sort_column_id (tree_column));
 716       break;
 717
 718     case PROP_CELL_AREA:
 719       g_value_set_object (value, tree_column->cell_area);
 720       break;
 721
 722     default:
 723       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 724       break;
 725     }
 726 }
 727
 728 /* Implementation of GtkCellLayout interface
 729  */
 730 static GtkCellArea *
 731 gtk_tree_view_column_cell_layout_get_area (GtkCellLayout   *cell_layout)
 732 {
 733   GtkTreeViewColumn        *column = GTK_TREE_VIEW_COLUMN (cell_layout);
 734   GtkTreeViewColumnPrivate *priv   = column->priv;
 735
 736   return priv->cell_area;
 737 }
 738
 739 /* Button handling code
 740  */
 741 static void
 742 gtk_tree_view_column_create_button (GtkTreeViewColumn *tree_column)
 743 {
 744   GtkTreeViewColumnPrivate *priv = tree_column->priv;
 745   GtkTreeView *tree_view;
 746   GtkWidget *child;
 747   GtkWidget *hbox;
 748
 749   tree_view = (GtkTreeView *) priv->tree_view;
 750
 751   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
 752   g_return_if_fail (priv->button == NULL);
 753
 754   gtk_widget_push_composite_child ();
 755   priv->button = gtk_button_new ();
 756   gtk_widget_add_events (priv->button, GDK_POINTER_MOTION_MASK);
 757   gtk_widget_pop_composite_child ();
 758
 759   /* make sure we own a reference to it as well. */
 760   if (_gtk_tree_view_get_header_window (tree_view))
 761     gtk_widget_set_parent_window (priv->button, _gtk_tree_view_get_header_window (tree_view));
 762
 763   gtk_widget_set_parent (priv->button, GTK_WIDGET (tree_view));
 764
 765   g_signal_connect (priv->button, "event",
 766                     G_CALLBACK (gtk_tree_view_column_button_event),
 767                     tree_column);
 768   g_signal_connect (priv->button, "clicked",
 769                     G_CALLBACK (gtk_tree_view_column_button_clicked),
 770                     tree_column);
 771
 772   priv->alignment = gtk_alignment_new (priv->xalign, 0.5, 0.0, 0.0);
 773
 774   hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2);
 775   priv->arrow = gtk_arrow_new (GTK_ARROW_DOWN, GTK_SHADOW_IN);
 776
 777   if (priv->child)
 778     child = priv->child;
 779   else
 780     {
 781       child = gtk_label_new (priv->title);
 782       gtk_widget_show (child);
 783     }
 784
 785   g_signal_connect (child, "mnemonic-activate",
 786                     G_CALLBACK (gtk_tree_view_column_mnemonic_activate),
 787                     tree_column);
 788
 789   if (priv->xalign <= 0.5)
 790     gtk_box_pack_end (GTK_BOX (hbox), priv->arrow, FALSE, FALSE, 0);
 791   else
 792     gtk_box_pack_start (GTK_BOX (hbox), priv->arrow, FALSE, FALSE, 0);
 793
 794   gtk_box_pack_start (GTK_BOX (hbox), priv->alignment, TRUE, TRUE, 0);
 795
 796   gtk_container_add (GTK_CONTAINER (priv->alignment), child);
 797   gtk_container_add (GTK_CONTAINER (priv->button), hbox);
 798
 799   gtk_widget_show (hbox);
 800   gtk_widget_show (priv->alignment);
 801   gtk_tree_view_column_update_button (tree_column);
 802 }
 803
 804 static void
 805 gtk_tree_view_column_update_button (GtkTreeViewColumn *tree_column)
 806 {
 807   GtkTreeViewColumnPrivate *priv = tree_column->priv;
 808   gint sort_column_id = -1;
 809   GtkWidget *hbox;
 810   GtkWidget *alignment;
 811   GtkWidget *arrow;
 812   GtkWidget *current_child;
 813   GtkArrowType arrow_type = GTK_ARROW_NONE;
 814   GtkTreeModel *model;
 815
 816   if (priv->tree_view)
 817     model = gtk_tree_view_get_model (GTK_TREE_VIEW (priv->tree_view));
 818   else
 819     model = NULL;
 820
 821   /* Create a button if necessary */
 822   if (priv->visible &&
 823       priv->button == NULL &&
 824       priv->tree_view &&
 825       gtk_widget_get_realized (priv->tree_view))
 826     gtk_tree_view_column_create_button (tree_column);
 827
 828   if (! priv->button)
 829     return;
 830
 831   hbox = gtk_bin_get_child (GTK_BIN (priv->button));
 832   alignment = priv->alignment;
 833   arrow = priv->arrow;
 834   current_child = gtk_bin_get_child (GTK_BIN (alignment));
 835
 836   /* Set up the actual button */
 837   gtk_alignment_set (GTK_ALIGNMENT (alignment), priv->xalign,
 838                      0.5, 0.0, 0.0);
 839
 840   if (priv->child)
 841     {
 842       if (current_child != priv->child)
 843         {
 844           gtk_container_remove (GTK_CONTAINER (alignment),
 845                                 current_child);
 846           gtk_container_add (GTK_CONTAINER (alignment),
 847                              priv->child);
 848         }
 849     }
 850   else
 851     {
 852       if (current_child == NULL)
 853         {
 854           current_child = gtk_label_new (NULL);
 855           gtk_widget_show (current_child);
 856           gtk_container_add (GTK_CONTAINER (alignment),
 857                              current_child);
 858         }
 859
 860       g_return_if_fail (GTK_IS_LABEL (current_child));
 861
 862       if (priv->title)
 863         gtk_label_set_text_with_mnemonic (GTK_LABEL (current_child),
 864                                           priv->title);
 865       else
 866         gtk_label_set_text_with_mnemonic (GTK_LABEL (current_child),
 867                                           "");
 868     }
 869
 870   if (GTK_IS_TREE_SORTABLE (model))
 871     gtk_tree_sortable_get_sort_column_id (GTK_TREE_SORTABLE (model),
 872                                           &sort_column_id,
 873                                           NULL);
 874
 875   if (priv->show_sort_indicator)
 876     {
 877       gboolean alternative;
 878
 879       g_object_get (gtk_widget_get_settings (priv->tree_view),
 880                     "gtk-alternative-sort-arrows", &alternative,
 881                     NULL);
 882
 883       switch (priv->sort_order)
 884         {
 885           case GTK_SORT_ASCENDING:
 886             arrow_type = alternative ? GTK_ARROW_UP : GTK_ARROW_DOWN;
 887             break;
 888
 889           case GTK_SORT_DESCENDING:
 890             arrow_type = alternative ? GTK_ARROW_DOWN : GTK_ARROW_UP;
 891             break;
 892
 893           default:
 894             g_warning (G_STRLOC": bad sort order");
 895             break;
 896         }
 897     }
 898
 899   gtk_arrow_set (GTK_ARROW (arrow),
 900                  arrow_type,
 901                  GTK_SHADOW_IN);
 902
 903   /* Put arrow on the right if the text is left-or-center justified, and on the
 904    * left otherwise; do this by packing boxes, so flipping text direction will
 905    * reverse things
 906    */
 907   g_object_ref (arrow);
 908   gtk_container_remove (GTK_CONTAINER (hbox), arrow);
 909
 910   if (priv->xalign <= 0.5)
 911     {
 912       gtk_box_pack_end (GTK_BOX (hbox), arrow, FALSE, FALSE, 0);
 913     }
 914   else
 915     {
 916       gtk_box_pack_start (GTK_BOX (hbox), arrow, FALSE, FALSE, 0);
 917       /* move it to the front */
 918       gtk_box_reorder_child (GTK_BOX (hbox), arrow, 0);
 919     }
 920   g_object_unref (arrow);
 921
 922   if (priv->show_sort_indicator
 923       || (GTK_IS_TREE_SORTABLE (model) && priv->sort_column_id >= 0))
 924     gtk_widget_show (arrow);
 925   else
 926     gtk_widget_hide (arrow);
 927
 928   /* It's always safe to hide the button.  It isn't always safe to show it, as
 929    * if you show it before it's realized, it'll get the wrong window. */
 930   if (priv->button &&
 931       priv->tree_view != NULL &&
 932       gtk_widget_get_realized (priv->tree_view))
 933     {
 934       if (priv->visible)
 935         {
 936           gtk_widget_show_now (priv->button);
 937           if (priv->window)
 938             {
 939               if (priv->resizable)
 940                 {
 941                   gdk_window_show (priv->window);
 942                   gdk_window_raise (priv->window);
 943                 }
 944               else
 945                 {
 946                   gdk_window_hide (priv->window);
 947                 }
 948             }
 949         }
 950       else
 951         {
 952           gtk_widget_hide (priv->button);
 953           if (priv->window)
 954             gdk_window_hide (priv->window);
 955         }
 956     }
 957
 958   if (priv->reorderable || priv->clickable)
 959     {
 960       gtk_widget_set_can_focus (priv->button, TRUE);
 961     }
 962   else
 963     {
 964       gtk_widget_set_can_focus (priv->button, FALSE);
 965       if (gtk_widget_has_focus (priv->button))
 966         {
 967           GtkWidget *toplevel = gtk_widget_get_toplevel (priv->tree_view);
 968           if (gtk_widget_is_toplevel (toplevel))
 969             {
 970               gtk_window_set_focus (GTK_WINDOW (toplevel), NULL);
 971             }
 972         }
 973     }
 974   /* Queue a resize on the assumption that we always want to catch all changes
 975    * and columns don't change all that often.
 976    */
 977   if (gtk_widget_get_realized (priv->tree_view))
 978      gtk_widget_queue_resize (priv->tree_view);
 979
 980 }
 981
 982 /* Button signal handlers
 983  */
 984
 985 static gint
 986 gtk_tree_view_column_button_event (GtkWidget *widget,
 987                                    GdkEvent  *event,
 988                                    gpointer   data)
 989 {
 990   GtkTreeViewColumn        *column = (GtkTreeViewColumn *) data;
 991   GtkTreeViewColumnPrivate *priv   = column->priv;
 992
 993   g_return_val_if_fail (event != NULL, FALSE);
 994
 995   if (event->type == GDK_BUTTON_PRESS &&
 996       priv->reorderable &&
 997       ((GdkEventButton *)event)->button == 1)
 998     {
 999       priv->maybe_reordered = TRUE;
1000       gdk_window_get_pointer (gtk_button_get_event_window (GTK_BUTTON (widget)),
1001                               &priv->drag_x,
1002                               &priv->drag_y,
1003                               NULL);
1004       gtk_widget_grab_focus (widget);
1005     }
1006
1007   if (event->type == GDK_BUTTON_RELEASE ||
1008       event->type == GDK_LEAVE_NOTIFY)
1009     priv->maybe_reordered = FALSE;
1010
1011   if (event->type == GDK_MOTION_NOTIFY &&
1012       priv->maybe_reordered &&
1013       (gtk_drag_check_threshold (widget,
1014                                  priv->drag_x,
1015                                  priv->drag_y,
1016                                  (gint) ((GdkEventMotion *)event)->x,
1017                                  (gint) ((GdkEventMotion *)event)->y)))
1018     {
1019       priv->maybe_reordered = FALSE;
1020       _gtk_tree_view_column_start_drag (GTK_TREE_VIEW (priv->tree_view), column,
1021                                         event->motion.device);
1022       return TRUE;
1023     }
1024
1025   if (priv->clickable == FALSE)
1026     {
1027       switch (event->type)
1028         {
1029         case GDK_BUTTON_PRESS:
1030         case GDK_2BUTTON_PRESS:
1031         case GDK_3BUTTON_PRESS:
1032         case GDK_MOTION_NOTIFY:
1033         case GDK_BUTTON_RELEASE:
1034         case GDK_ENTER_NOTIFY:
1035         case GDK_LEAVE_NOTIFY:
1036           return TRUE;
1037         default:
1038           return FALSE;
1039         }
1040     }
1041   return FALSE;
1042 }
1043
1044
1045 static void
1046 gtk_tree_view_column_button_clicked (GtkWidget *widget, gpointer data)
1047 {
1048   g_signal_emit_by_name (data, "clicked");
1049 }
1050
1051 static gboolean
1052 gtk_tree_view_column_mnemonic_activate (GtkWidget *widget,
1053                                         gboolean   group_cycling,
1054                                         gpointer   data)
1055 {
1056   GtkTreeViewColumn        *column = (GtkTreeViewColumn *)data;
1057   GtkTreeViewColumnPrivate *priv   = column->priv;
1058
1059   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (column), FALSE);
1060
1061   _gtk_tree_view_set_focus_column (GTK_TREE_VIEW (priv->tree_view), column);
1062
1063   if (priv->clickable)
1064     gtk_button_clicked (GTK_BUTTON (priv->button));
1065   else if (gtk_widget_get_can_focus (priv->button))
1066     gtk_widget_grab_focus (priv->button);
1067   else
1068     gtk_widget_grab_focus (priv->tree_view);
1069
1070   return TRUE;
1071 }
1072
1073 static void
1074 gtk_tree_view_model_sort_column_changed (GtkTreeSortable   *sortable,
1075                                          GtkTreeViewColumn *column)
1076 {
1077   GtkTreeViewColumnPrivate *priv = column->priv;
1078   gint sort_column_id;
1079   GtkSortType order;
1080
1081   if (gtk_tree_sortable_get_sort_column_id (sortable,
1082                                             &sort_column_id,
1083                                             &order))
1084     {
1085       if (sort_column_id == priv->sort_column_id)
1086         {
1087           gtk_tree_view_column_set_sort_indicator (column, TRUE);
1088           gtk_tree_view_column_set_sort_order (column, order);
1089         }
1090       else
1091         {
1092           gtk_tree_view_column_set_sort_indicator (column, FALSE);
1093         }
1094     }
1095   else
1096     {
1097       gtk_tree_view_column_set_sort_indicator (column, FALSE);
1098     }
1099 }
1100
1101 static void
1102 gtk_tree_view_column_sort (GtkTreeViewColumn *tree_column,
1103                            gpointer           data)
1104 {
1105   GtkTreeViewColumnPrivate *priv = tree_column->priv;
1106   GtkTreeModel *model;
1107   GtkTreeSortable *sortable;
1108   gint sort_column_id;
1109   GtkSortType order;
1110   gboolean has_sort_column;
1111   gboolean has_default_sort_func;
1112
1113   g_return_if_fail (priv->tree_view != NULL);
1114
1115   model    = gtk_tree_view_get_model (GTK_TREE_VIEW (priv->tree_view));
1116   sortable = GTK_TREE_SORTABLE (model);
1117
1118   has_sort_column =
1119     gtk_tree_sortable_get_sort_column_id (sortable,
1120                                           &sort_column_id,
1121                                           &order);
1122   has_default_sort_func =
1123     gtk_tree_sortable_has_default_sort_func (sortable);
1124
1125   if (has_sort_column &&
1126       sort_column_id == priv->sort_column_id)
1127     {
1128       if (order == GTK_SORT_ASCENDING)
1129         gtk_tree_sortable_set_sort_column_id (sortable,
1130                                               priv->sort_column_id,
1131                                               GTK_SORT_DESCENDING);
1132       else if (order == GTK_SORT_DESCENDING && has_default_sort_func)
1133         gtk_tree_sortable_set_sort_column_id (sortable,
1134                                               GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID,
1135                                               GTK_SORT_ASCENDING);
1136       else
1137         gtk_tree_sortable_set_sort_column_id (sortable,
1138                                               priv->sort_column_id,
1139                                               GTK_SORT_ASCENDING);
1140     }
1141   else
1142     {
1143       gtk_tree_sortable_set_sort_column_id (sortable,
1144                                             priv->sort_column_id,
1145                                             GTK_SORT_ASCENDING);
1146     }
1147 }
1148
1149 static void
1150 gtk_tree_view_column_setup_sort_column_id_callback (GtkTreeViewColumn *tree_column)
1151 {
1152   GtkTreeViewColumnPrivate *priv = tree_column->priv;
1153   GtkTreeModel *model;
1154
1155   if (priv->tree_view == NULL)
1156     return;
1157
1158   model = gtk_tree_view_get_model (GTK_TREE_VIEW (priv->tree_view));
1159
1160   if (model == NULL)
1161     return;
1162
1163   if (GTK_IS_TREE_SORTABLE (model) &&
1164       priv->sort_column_id != -1)
1165     {
1166       gint real_sort_column_id;
1167       GtkSortType real_order;
1168
1169       if (priv->sort_column_changed_signal == 0)
1170         priv->sort_column_changed_signal =
1171           g_signal_connect (model, "sort-column-changed",
1172                             G_CALLBACK (gtk_tree_view_model_sort_column_changed),
1173                             tree_column);
1174
1175       if (gtk_tree_sortable_get_sort_column_id (GTK_TREE_SORTABLE (model),
1176                                                 &real_sort_column_id,
1177                                                 &real_order) &&
1178           (real_sort_column_id == priv->sort_column_id))
1179         {
1180           gtk_tree_view_column_set_sort_indicator (tree_column, TRUE);
1181           gtk_tree_view_column_set_sort_order (tree_column, real_order);
1182         }
1183       else
1184         {
1185           gtk_tree_view_column_set_sort_indicator (tree_column, FALSE);
1186         }
1187    }
1188 }
1189
1190 static void
1191 gtk_tree_view_column_context_changed  (GtkCellAreaContext      *context,
1192                                        GParamSpec              *pspec,
1193                                        GtkTreeViewColumn       *tree_column)
1194 {
1195   if (!strcmp (pspec->name, "minimum-width") ||
1196       !strcmp (pspec->name, "natural-width") ||
1197       !strcmp (pspec->name, "minimum-height") ||
1198       !strcmp (pspec->name, "natural-height"))
1199     {
1200       /* XXX We want to do something specific if the size actually got cleared
1201        * or if it just grew a little bit because of a data change and we
1202        * are in GROW_ONLY mode.
1203        */
1204       _gtk_tree_view_column_cell_set_dirty (tree_column, TRUE);
1205     }
1206 }
1207
1208 static void
1209 gtk_tree_view_column_add_editable_callback (GtkCellArea       *area,
1210                                             GtkCellRenderer   *renderer,
1211                                             GtkCellEditable   *edit_widget,
1212                                             GdkRectangle      *cell_area,
1213                                             const gchar       *path_string,
1214                                             gpointer           user_data)
1215 {
1216   GtkTreeViewColumn        *column = user_data;
1217   GtkTreeViewColumnPrivate *priv   = column->priv;
1218   GtkTreePath              *path;
1219
1220   path = gtk_tree_path_new_from_string (path_string);
1221
1222   _gtk_tree_view_add_editable (GTK_TREE_VIEW (priv->tree_view),
1223                                column,
1224                                path,
1225                                edit_widget,
1226                                cell_area);
1227
1228   gtk_tree_path_free (path);
1229 }
1230
1231 static void
1232 gtk_tree_view_column_remove_editable_callback (GtkCellArea     *area,
1233                                                GtkCellRenderer *renderer,
1234                                                GtkCellEditable *edit_widget,
1235                                                gpointer         user_data)
1236 {
1237   GtkTreeViewColumn        *column = user_data;
1238   GtkTreeViewColumnPrivate *priv   = column->priv;
1239
1240   _gtk_tree_view_remove_editable (GTK_TREE_VIEW (priv->tree_view),
1241                                   column,
1242                                   edit_widget);
1243 }
1244
1245 /* Exported Private Functions.
1246  * These should only be called by gtktreeview.c or gtktreeviewcolumn.c
1247  */
1248 void
1249 _gtk_tree_view_column_realize_button (GtkTreeViewColumn *column)
1250 {
1251   GtkTreeViewColumnPrivate *priv = column->priv;
1252   GtkAllocation allocation;
1253   GtkTreeView *tree_view;
1254   GdkWindowAttr attr;
1255   guint attributes_mask;
1256   gboolean rtl;
1257
1258   tree_view = (GtkTreeView *)priv->tree_view;
1259   rtl       = (gtk_widget_get_direction (priv->tree_view) == GTK_TEXT_DIR_RTL);
1260
1261   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
1262   g_return_if_fail (gtk_widget_get_realized (priv->tree_view));
1263   g_return_if_fail (priv->button != NULL);
1264
1265   g_return_if_fail (_gtk_tree_view_get_header_window (tree_view) != NULL);
1266   gtk_widget_set_parent_window (priv->button, _gtk_tree_view_get_header_window (tree_view));
1267
1268   if (priv->visible)
1269     gtk_widget_show (priv->button);
1270
1271   attr.window_type = GDK_WINDOW_CHILD;
1272   attr.wclass = GDK_INPUT_ONLY;
1273   attr.visual = gtk_widget_get_visual (GTK_WIDGET (tree_view));
1274   attr.event_mask = gtk_widget_get_events (GTK_WIDGET (tree_view)) |
1275                     (GDK_BUTTON_PRESS_MASK |
1276                      GDK_BUTTON_RELEASE_MASK |
1277                      GDK_POINTER_MOTION_MASK |
1278                      GDK_POINTER_MOTION_HINT_MASK |
1279                      GDK_KEY_PRESS_MASK);
1280   attributes_mask = GDK_WA_CURSOR | GDK_WA_X | GDK_WA_Y;
1281   attr.cursor = gdk_cursor_new_for_display
1282     (gdk_window_get_display (_gtk_tree_view_get_header_window (tree_view)), GDK_SB_H_DOUBLE_ARROW);
1283   attr.y = 0;
1284   attr.width = TREE_VIEW_DRAG_WIDTH;
1285   attr.height = _gtk_tree_view_get_header_height (tree_view);
1286
1287   gtk_widget_get_allocation (priv->button, &allocation);
1288   attr.x       = (allocation.x + (rtl ? 0 : allocation.width)) - TREE_VIEW_DRAG_WIDTH / 2;
1289   priv->window = gdk_window_new (_gtk_tree_view_get_header_window (tree_view),
1290                                  &attr, attributes_mask);
1291   gdk_window_set_user_data (priv->window, tree_view);
1292
1293   gtk_tree_view_column_update_button (column);
1294
1295   gdk_cursor_unref (attr.cursor);
1296 }
1297
1298 void
1299 _gtk_tree_view_column_unrealize_button (GtkTreeViewColumn *column)
1300 {
1301   GtkTreeViewColumnPrivate *priv;
1302
1303   g_return_if_fail (column != NULL);
1304
1305   priv = column->priv;
1306   g_return_if_fail (priv->window != NULL);
1307
1308   gdk_window_set_user_data (priv->window, NULL);
1309   gdk_window_destroy (priv->window);
1310   priv->window = NULL;
1311 }
1312
1313 void
1314 _gtk_tree_view_column_unset_model (GtkTreeViewColumn *column,
1315                                    GtkTreeModel      *old_model)
1316 {
1317   GtkTreeViewColumnPrivate *priv = column->priv;
1318
1319   if (priv->sort_column_changed_signal)
1320     {
1321       g_signal_handler_disconnect (old_model,
1322                                    priv->sort_column_changed_signal);
1323       priv->sort_column_changed_signal = 0;
1324     }
1325   gtk_tree_view_column_set_sort_indicator (column, FALSE);
1326 }
1327
1328 void
1329 _gtk_tree_view_column_set_tree_view (GtkTreeViewColumn *column,
1330                                      GtkTreeView       *tree_view)
1331 {
1332   GtkTreeViewColumnPrivate *priv = column->priv;
1333
1334   g_assert (priv->tree_view == NULL);
1335
1336   priv->tree_view = GTK_WIDGET (tree_view);
1337   gtk_tree_view_column_create_button (column);
1338
1339   priv->add_editable_signal =
1340     g_signal_connect (priv->cell_area, "add-editable",
1341                       G_CALLBACK (gtk_tree_view_column_add_editable_callback),
1342                       column);
1343   priv->remove_editable_signal =
1344     g_signal_connect (priv->cell_area, "remove-editable",
1345                       G_CALLBACK (gtk_tree_view_column_remove_editable_callback),
1346                       column);
1347
1348   priv->property_changed_signal =
1349     g_signal_connect_swapped (tree_view,
1350                               "notify::model",
1351                               G_CALLBACK (gtk_tree_view_column_setup_sort_column_id_callback),
1352                               column);
1353
1354   gtk_tree_view_column_setup_sort_column_id_callback (column);
1355 }
1356
1357 void
1358 _gtk_tree_view_column_unset_tree_view (GtkTreeViewColumn *column)
1359 {
1360   GtkTreeViewColumnPrivate *priv = column->priv;
1361
1362   if (priv->tree_view && priv->button)
1363     {
1364       gtk_container_remove (GTK_CONTAINER (priv->tree_view), priv->button);
1365     }
1366   if (priv->property_changed_signal)
1367     {
1368       g_signal_handler_disconnect (priv->tree_view, priv->property_changed_signal);
1369       priv->property_changed_signal = 0;
1370     }
1371
1372   if (priv->sort_column_changed_signal)
1373     {
1374       g_signal_handler_disconnect (gtk_tree_view_get_model (GTK_TREE_VIEW (priv->tree_view)),
1375                                    priv->sort_column_changed_signal);
1376       priv->sort_column_changed_signal = 0;
1377     }
1378
1379   priv->tree_view = NULL;
1380   priv->button = NULL;
1381 }
1382
1383 gboolean
1384 _gtk_tree_view_column_has_editable_cell (GtkTreeViewColumn *column)
1385 {
1386   GtkTreeViewColumnPrivate *priv = column->priv;
1387   gboolean ret = FALSE;
1388   GList *list, *cells;
1389
1390   cells = gtk_cell_layout_get_cells (GTK_CELL_LAYOUT (priv->cell_area));
1391
1392   for (list = cells; list; list = list->next)
1393     {
1394       GtkCellRenderer *cell = list->data;
1395       GtkCellRendererMode mode;
1396
1397       g_object_get (cell, "mode", &mode, NULL);
1398
1399       if (mode == GTK_CELL_RENDERER_MODE_EDITABLE)
1400         {
1401           ret = TRUE;
1402           break;
1403         }
1404     }
1405
1406   g_list_free (cells);
1407
1408   return ret;
1409 }
1410
1411 /* gets cell being edited */
1412 GtkCellRenderer *
1413 _gtk_tree_view_column_get_edited_cell (GtkTreeViewColumn *column)
1414 {
1415   GtkTreeViewColumnPrivate *priv = column->priv;
1416
1417   return gtk_cell_area_get_edited_cell (priv->cell_area);
1418 }
1419
1420 /* Public Functions */
1421
1422
1423 /**
1424  * gtk_tree_view_column_new:
1425  *
1426  * Creates a new #GtkTreeViewColumn.
1427  *
1428  * Return value: A newly created #GtkTreeViewColumn.
1429  **/
1430 GtkTreeViewColumn *
1431 gtk_tree_view_column_new (void)
1432 {
1433   GtkTreeViewColumn *tree_column;
1434
1435   tree_column = g_object_new (GTK_TYPE_TREE_VIEW_COLUMN, NULL);
1436
1437   return tree_column;
1438 }
1439
1440 /**
1441  * gtk_tree_view_column_new_with_attributes:
1442  * @title: The title to set the header to.
1443  * @cell: The #GtkCellRenderer.
1444  * @Varargs: A %NULL-terminated list of attributes.
1445  *
1446  * Creates a new #GtkTreeViewColumn with a number of default values.  This is
1447  * equivalent to calling gtk_tree_view_column_set_title(),
1448  * gtk_tree_view_column_pack_start(), and
1449  * gtk_tree_view_column_set_attributes() on the newly created #GtkTreeViewColumn.
1450  *
1451  * Here's a simple example:
1452  * |[
1453  *  enum { TEXT_COLUMN, COLOR_COLUMN, N_COLUMNS };
1454  *  ...
1455  *  {
1456  *    GtkTreeViewColumn *column;
1457  *    GtkCellRenderer   *renderer = gtk_cell_renderer_text_new ();
1458  *
1459  *    column = gtk_tree_view_column_new_with_attributes ("Title",
1460  *                                                       renderer,
1461  *                                                       "text", TEXT_COLUMN,
1462  *                                                       "foreground", COLOR_COLUMN,
1463  *                                                       NULL);
1464  *  }
1465  * ]|
1466  *
1467  * Return value: A newly created #GtkTreeViewColumn.
1468  **/
1469 GtkTreeViewColumn *
1470 gtk_tree_view_column_new_with_attributes (const gchar     *title,
1471                                           GtkCellRenderer *cell,
1472                                           ...)
1473 {
1474   GtkTreeViewColumn *retval;
1475   va_list args;
1476
1477   retval = gtk_tree_view_column_new ();
1478
1479   gtk_tree_view_column_set_title (retval, title);
1480   gtk_tree_view_column_pack_start (retval, cell, TRUE);
1481
1482   va_start (args, cell);
1483   gtk_tree_view_column_set_attributesv (retval, cell, args);
1484   va_end (args);
1485
1486   return retval;
1487 }
1488
1489 /**
1490  * gtk_tree_view_column_pack_start:
1491  * @tree_column: A #GtkTreeViewColumn.
1492  * @cell: The #GtkCellRenderer.
1493  * @expand: %TRUE if @cell is to be given extra space allocated to @tree_column.
1494  *
1495  * Packs the @cell into the beginning of the column. If @expand is %FALSE, then
1496  * the @cell is allocated no more space than it needs. Any unused space is divided
1497  * evenly between cells for which @expand is %TRUE.
1498  **/
1499 void
1500 gtk_tree_view_column_pack_start (GtkTreeViewColumn *tree_column,
1501                                  GtkCellRenderer   *cell,
1502                                  gboolean           expand)
1503 {
1504   gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (tree_column), cell, expand);
1505 }
1506
1507 /**
1508  * gtk_tree_view_column_pack_end:
1509  * @tree_column: A #GtkTreeViewColumn.
1510  * @cell: The #GtkCellRenderer.
1511  * @expand: %TRUE if @cell is to be given extra space allocated to @tree_column.
1512  *
1513  * Adds the @cell to end of the column. If @expand is %FALSE, then the @cell
1514  * is allocated no more space than it needs. Any unused space is divided
1515  * evenly between cells for which @expand is %TRUE.
1516  **/
1517 void
1518 gtk_tree_view_column_pack_end (GtkTreeViewColumn  *tree_column,
1519                                GtkCellRenderer    *cell,
1520                                gboolean            expand)
1521 {
1522   gtk_cell_layout_pack_end (GTK_CELL_LAYOUT (tree_column), cell, expand);
1523 }
1524
1525 /**
1526  * gtk_tree_view_column_clear:
1527  * @tree_column: A #GtkTreeViewColumn
1528  *
1529  * Unsets all the mappings on all renderers on the @tree_column.
1530  **/
1531 void
1532 gtk_tree_view_column_clear (GtkTreeViewColumn *tree_column)
1533 {
1534   gtk_cell_layout_clear (GTK_CELL_LAYOUT (tree_column));
1535 }
1536
1537 /**
1538  * gtk_tree_view_column_add_attribute:
1539  * @tree_column: A #GtkTreeViewColumn.
1540  * @cell_renderer: the #GtkCellRenderer to set attributes on
1541  * @attribute: An attribute on the renderer
1542  * @column: The column position on the model to get the attribute from.
1543  *
1544  * Adds an attribute mapping to the list in @tree_column.  The @column is the
1545  * column of the model to get a value from, and the @attribute is the
1546  * parameter on @cell_renderer to be set from the value. So for example
1547  * if column 2 of the model contains strings, you could have the
1548  * "text" attribute of a #GtkCellRendererText get its values from
1549  * column 2.
1550  **/
1551 void
1552 gtk_tree_view_column_add_attribute (GtkTreeViewColumn *tree_column,
1553                                     GtkCellRenderer   *cell_renderer,
1554                                     const gchar       *attribute,
1555                                     gint               column)
1556 {
1557   gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (tree_column),
1558                                  cell_renderer, attribute, column);
1559 }
1560
1561 static void
1562 gtk_tree_view_column_set_attributesv (GtkTreeViewColumn *tree_column,
1563                                       GtkCellRenderer   *cell_renderer,
1564                                       va_list            args)
1565 {
1566   GtkTreeViewColumnPrivate *priv = tree_column->priv;
1567   gchar *attribute;
1568   gint column;
1569
1570   attribute = va_arg (args, gchar *);
1571
1572   gtk_cell_layout_clear_attributes (GTK_CELL_LAYOUT (priv->cell_area),
1573                                     cell_renderer);
1574
1575   while (attribute != NULL)
1576     {
1577       column = va_arg (args, gint);
1578       gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (priv->cell_area),
1579                                      cell_renderer, attribute, column);
1580       attribute = va_arg (args, gchar *);
1581     }
1582 }
1583
1584 /**
1585  * gtk_tree_view_column_set_attributes:
1586  * @tree_column: A #GtkTreeViewColumn.
1587  * @cell_renderer: the #GtkCellRenderer we're setting the attributes of
1588  * @Varargs: A %NULL-terminated list of attributes.
1589  *
1590  * Sets the attributes in the list as the attributes of @tree_column.
1591  * The attributes should be in attribute/column order, as in
1592  * gtk_tree_view_column_add_attribute(). All existing attributes
1593  * are removed, and replaced with the new attributes.
1594  **/
1595 void
1596 gtk_tree_view_column_set_attributes (GtkTreeViewColumn *tree_column,
1597                                      GtkCellRenderer   *cell_renderer,
1598                                      ...)
1599 {
1600   va_list args;
1601
1602   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
1603   g_return_if_fail (GTK_IS_CELL_RENDERER (cell_renderer));
1604
1605   va_start (args, cell_renderer);
1606   gtk_tree_view_column_set_attributesv (tree_column, cell_renderer, args);
1607   va_end (args);
1608 }
1609
1610
1611 /**
1612  * gtk_tree_view_column_set_cell_data_func:
1613  * @tree_column: A #GtkTreeViewColumn
1614  * @cell_renderer: A #GtkCellRenderer
1615  * @func: The #GtkTreeViewColumnFunc to use.
1616  * @func_data: The user data for @func.
1617  * @destroy: The destroy notification for @func_data
1618  *
1619  * Sets the #GtkTreeViewColumnFunc to use for the column.  This
1620  * function is used instead of the standard attributes mapping for
1621  * setting the column value, and should set the value of @tree_column's
1622  * cell renderer as appropriate.  @func may be %NULL to remove an
1623  * older one.
1624  **/
1625 void
1626 gtk_tree_view_column_set_cell_data_func (GtkTreeViewColumn   *tree_column,
1627                                          GtkCellRenderer     *cell_renderer,
1628                                          GtkTreeCellDataFunc  func,
1629                                          gpointer             func_data,
1630                                          GDestroyNotify       destroy)
1631 {
1632   gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (tree_column),
1633                                       cell_renderer,
1634                                       (GtkCellLayoutDataFunc)func,
1635                                       func_data, destroy);
1636 }
1637
1638
1639 /**
1640  * gtk_tree_view_column_clear_attributes:
1641  * @tree_column: a #GtkTreeViewColumn
1642  * @cell_renderer: a #GtkCellRenderer to clear the attribute mapping on.
1643  *
1644  * Clears all existing attributes previously set with
1645  * gtk_tree_view_column_set_attributes().
1646  **/
1647 void
1648 gtk_tree_view_column_clear_attributes (GtkTreeViewColumn *tree_column,
1649                                        GtkCellRenderer   *cell_renderer)
1650 {
1651   gtk_cell_layout_clear_attributes (GTK_CELL_LAYOUT (tree_column),
1652                                     cell_renderer);
1653 }
1654
1655 /**
1656  * gtk_tree_view_column_set_spacing:
1657  * @tree_column: A #GtkTreeViewColumn.
1658  * @spacing: distance between cell renderers in pixels.
1659  *
1660  * Sets the spacing field of @tree_column, which is the number of pixels to
1661  * place between cell renderers packed into it.
1662  **/
1663 void
1664 gtk_tree_view_column_set_spacing (GtkTreeViewColumn *tree_column,
1665                                   gint               spacing)
1666 {
1667   GtkTreeViewColumnPrivate *priv;
1668
1669   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
1670   g_return_if_fail (spacing >= 0);
1671
1672   priv = tree_column->priv;
1673
1674   gtk_cell_area_box_set_spacing (GTK_CELL_AREA_BOX (priv->cell_area),
1675                                  spacing);
1676   if (priv->tree_view)
1677     _gtk_tree_view_column_cell_set_dirty (tree_column, TRUE);
1678 }
1679
1680 /**
1681  * gtk_tree_view_column_get_spacing:
1682  * @tree_column: A #GtkTreeViewColumn.
1683  *
1684  * Returns the spacing of @tree_column.
1685  *
1686  * Return value: the spacing of @tree_column.
1687  **/
1688 gint
1689 gtk_tree_view_column_get_spacing (GtkTreeViewColumn *tree_column)
1690 {
1691   GtkTreeViewColumnPrivate *priv;
1692
1693   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), 0);
1694
1695   priv = tree_column->priv;
1696
1697   return gtk_cell_area_box_get_spacing (GTK_CELL_AREA_BOX (priv->cell_area));
1698 }
1699
1700 /* Options for manipulating the columns */
1701
1702 /**
1703  * gtk_tree_view_column_set_visible:
1704  * @tree_column: A #GtkTreeViewColumn.
1705  * @visible: %TRUE if the @tree_column is visible.
1706  *
1707  * Sets the visibility of @tree_column.
1708  **/
1709 void
1710 gtk_tree_view_column_set_visible (GtkTreeViewColumn *tree_column,
1711                                   gboolean           visible)
1712 {
1713   GtkTreeViewColumnPrivate *priv;
1714
1715   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
1716
1717   priv    = tree_column->priv;
1718   visible = !! visible;
1719
1720   if (priv->visible == visible)
1721     return;
1722
1723   priv->visible = visible;
1724
1725   if (priv->visible)
1726     _gtk_tree_view_column_cell_set_dirty (tree_column, TRUE);
1727
1728   gtk_tree_view_column_update_button (tree_column);
1729   g_object_notify (G_OBJECT (tree_column), "visible");
1730 }
1731
1732 /**
1733  * gtk_tree_view_column_get_visible:
1734  * @tree_column: A #GtkTreeViewColumn.
1735  *
1736  * Returns %TRUE if @tree_column is visible.
1737  *
1738  * Return value: whether the column is visible or not.  If it is visible, then
1739  * the tree will show the column.
1740  **/
1741 gboolean
1742 gtk_tree_view_column_get_visible (GtkTreeViewColumn *tree_column)
1743 {
1744   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), FALSE);
1745
1746   return tree_column->priv->visible;
1747 }
1748
1749 /**
1750  * gtk_tree_view_column_set_resizable:
1751  * @tree_column: A #GtkTreeViewColumn
1752  * @resizable: %TRUE, if the column can be resized
1753  *
1754  * If @resizable is %TRUE, then the user can explicitly resize the column by
1755  * grabbing the outer edge of the column button.  If resizable is %TRUE and
1756  * sizing mode of the column is #GTK_TREE_VIEW_COLUMN_AUTOSIZE, then the sizing
1757  * mode is changed to #GTK_TREE_VIEW_COLUMN_GROW_ONLY.
1758  **/
1759 void
1760 gtk_tree_view_column_set_resizable (GtkTreeViewColumn *tree_column,
1761                                     gboolean           resizable)
1762 {
1763   GtkTreeViewColumnPrivate *priv;
1764
1765   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
1766
1767   priv      = tree_column->priv;
1768   resizable = !! resizable;
1769
1770   if (priv->resizable == resizable)
1771     return;
1772
1773   priv->resizable = resizable;
1774
1775   if (resizable && priv->column_type == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
1776     gtk_tree_view_column_set_sizing (tree_column, GTK_TREE_VIEW_COLUMN_GROW_ONLY);
1777
1778   gtk_tree_view_column_update_button (tree_column);
1779
1780   g_object_notify (G_OBJECT (tree_column), "resizable");
1781 }
1782
1783 /**
1784  * gtk_tree_view_column_get_resizable:
1785  * @tree_column: A #GtkTreeViewColumn
1786  *
1787  * Returns %TRUE if the @tree_column can be resized by the end user.
1788  *
1789  * Return value: %TRUE, if the @tree_column can be resized.
1790  **/
1791 gboolean
1792 gtk_tree_view_column_get_resizable (GtkTreeViewColumn *tree_column)
1793 {
1794   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), FALSE);
1795
1796   return tree_column->priv->resizable;
1797 }
1798
1799
1800 /**
1801  * gtk_tree_view_column_set_sizing:
1802  * @tree_column: A #GtkTreeViewColumn.
1803  * @type: The #GtkTreeViewColumnSizing.
1804  *
1805  * Sets the growth behavior of @tree_column to @type.
1806  **/
1807 void
1808 gtk_tree_view_column_set_sizing (GtkTreeViewColumn       *tree_column,
1809                                  GtkTreeViewColumnSizing  type)
1810 {
1811   GtkTreeViewColumnPrivate *priv;
1812
1813   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
1814
1815   priv      = tree_column->priv;
1816
1817   if (type == priv->column_type)
1818     return;
1819
1820   if (type == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
1821     gtk_tree_view_column_set_resizable (tree_column, FALSE);
1822
1823 #if 0
1824   /* I was clearly on crack when I wrote this.  I'm not sure what's supposed to
1825    * be below so I'll leave it until I figure it out.
1826    */
1827   if (priv->column_type == GTK_TREE_VIEW_COLUMN_AUTOSIZE &&
1828       priv->requested_width != -1)
1829     {
1830       gtk_tree_view_column_set_sizing (tree_column, priv->requested_width);
1831     }
1832 #endif
1833   priv->column_type = type;
1834
1835   gtk_tree_view_column_update_button (tree_column);
1836
1837   g_object_notify (G_OBJECT (tree_column), "sizing");
1838 }
1839
1840 /**
1841  * gtk_tree_view_column_get_sizing:
1842  * @tree_column: A #GtkTreeViewColumn.
1843  *
1844  * Returns the current type of @tree_column.
1845  *
1846  * Return value: The type of @tree_column.
1847  **/
1848 GtkTreeViewColumnSizing
1849 gtk_tree_view_column_get_sizing (GtkTreeViewColumn *tree_column)
1850 {
1851   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), 0);
1852
1853   return tree_column->priv->column_type;
1854 }
1855
1856 /**
1857  * gtk_tree_view_column_get_width:
1858  * @tree_column: A #GtkTreeViewColumn.
1859  *
1860  * Returns the current size of @tree_column in pixels.
1861  *
1862  * Return value: The current width of @tree_column.
1863  **/
1864 gint
1865 gtk_tree_view_column_get_width (GtkTreeViewColumn *tree_column)
1866 {
1867   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), 0);
1868
1869   return tree_column->priv->width;
1870 }
1871
1872 gint
1873 _gtk_tree_view_column_request_width (GtkTreeViewColumn *tree_column)
1874 {
1875   GtkTreeViewColumnPrivate *priv;
1876   gint real_requested_width;
1877
1878   priv = tree_column->priv;
1879
1880   if (priv->use_resized_width)
1881     {
1882       real_requested_width = priv->resized_width;
1883     }
1884   else if (priv->column_type == GTK_TREE_VIEW_COLUMN_FIXED)
1885     {
1886       real_requested_width = priv->fixed_width;
1887     }
1888   else if (gtk_tree_view_get_headers_visible (GTK_TREE_VIEW (priv->tree_view)))
1889     {
1890       gint button_request;
1891
1892       gtk_widget_get_preferred_width (priv->button, &button_request, NULL);
1893       real_requested_width = MAX (priv->requested_width, button_request);
1894     }
1895   else
1896     {
1897       real_requested_width = priv->requested_width;
1898       if (real_requested_width < 0)
1899         real_requested_width = 0;
1900     }
1901
1902   if (priv->min_width != -1)
1903     real_requested_width = MAX (real_requested_width, priv->min_width);
1904
1905   if (priv->max_width != -1)
1906     real_requested_width = MIN (real_requested_width, priv->max_width);
1907
1908   return real_requested_width;
1909 }
1910
1911 void
1912 _gtk_tree_view_column_allocate (GtkTreeViewColumn *tree_column,
1913                                 int                x_offset,
1914                                 int                width,
1915                                 int                cell_width)
1916 {
1917   GtkTreeViewColumnPrivate *priv;
1918   GtkAllocation             allocation;
1919   gboolean                  rtl;
1920
1921   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
1922
1923   priv = tree_column->priv;
1924
1925   priv->width = width;
1926
1927   gtk_cell_area_context_allocate (priv->cell_area_context, cell_width, -1);
1928
1929   allocation.x      = x_offset;
1930   allocation.y      = 0;
1931   allocation.width  = width;
1932   allocation.height = _gtk_tree_view_get_header_height (GTK_TREE_VIEW (priv->tree_view));
1933
1934   gtk_widget_size_allocate (priv->button, &allocation);
1935
1936   if (priv->window)
1937     {
1938       rtl = (gtk_widget_get_direction (priv->tree_view) == GTK_TEXT_DIR_RTL);
1939       gdk_window_move_resize (priv->window,
1940                               allocation.x + (rtl ? 0 : allocation.width) - TREE_VIEW_DRAG_WIDTH/2,
1941                               allocation.y,
1942                               TREE_VIEW_DRAG_WIDTH, allocation.height);
1943     }
1944
1945   g_object_notify (G_OBJECT (tree_column), "width");
1946 }
1947
1948 /**
1949  * gtk_tree_view_column_set_fixed_width:
1950  * @tree_column: A #GtkTreeViewColumn.
1951  * @fixed_width: The size to set @tree_column to. Must be greater than 0.
1952  *
1953  * Sets the size of the column in pixels.  This is meaningful only if the sizing
1954  * type is #GTK_TREE_VIEW_COLUMN_FIXED.  The size of the column is clamped to
1955  * the min/max width for the column.  Please note that the min/max width of the
1956  * column doesn't actually affect the "fixed_width" property of the widget, just
1957  * the actual size when displayed.
1958  **/
1959 void
1960 gtk_tree_view_column_set_fixed_width (GtkTreeViewColumn *tree_column,
1961                                       gint               fixed_width)
1962 {
1963   GtkTreeViewColumnPrivate *priv;
1964
1965   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
1966   g_return_if_fail (fixed_width > 0);
1967
1968   priv = tree_column->priv;
1969
1970   priv->fixed_width = fixed_width;
1971   priv->use_resized_width = FALSE;
1972
1973   if (priv->tree_view &&
1974       gtk_widget_get_realized (priv->tree_view) &&
1975       priv->column_type == GTK_TREE_VIEW_COLUMN_FIXED)
1976     {
1977       gtk_widget_queue_resize (priv->tree_view);
1978     }
1979
1980   g_object_notify (G_OBJECT (tree_column), "fixed-width");
1981 }
1982
1983 /**
1984  * gtk_tree_view_column_get_fixed_width:
1985  * @tree_column: a #GtkTreeViewColumn
1986  *
1987  * Gets the fixed width of the column.  This value is only meaning may not be
1988  * the actual width of the column on the screen, just what is requested.
1989  *
1990  * Return value: the fixed width of the column
1991  **/
1992 gint
1993 gtk_tree_view_column_get_fixed_width (GtkTreeViewColumn *tree_column)
1994 {
1995   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), 0);
1996
1997   return tree_column->priv->fixed_width;
1998 }
1999
2000 /**
2001  * gtk_tree_view_column_set_min_width:
2002  * @tree_column: A #GtkTreeViewColumn.
2003  * @min_width: The minimum width of the column in pixels, or -1.
2004  *
2005  * Sets the minimum width of the @tree_column.  If @min_width is -1, then the
2006  * minimum width is unset.
2007  **/
2008 void
2009 gtk_tree_view_column_set_min_width (GtkTreeViewColumn *tree_column,
2010                                     gint               min_width)
2011 {
2012   GtkTreeViewColumnPrivate *priv;
2013
2014   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
2015   g_return_if_fail (min_width >= -1);
2016
2017   priv = tree_column->priv;
2018
2019   if (min_width == priv->min_width)
2020     return;
2021
2022   if (priv->visible &&
2023       priv->tree_view != NULL &&
2024       gtk_widget_get_realized (priv->tree_view))
2025     {
2026       if (min_width > priv->width)
2027         gtk_widget_queue_resize (priv->tree_view);
2028     }
2029
2030   priv->min_width = min_width;
2031   g_object_freeze_notify (G_OBJECT (tree_column));
2032   if (priv->max_width != -1 && priv->max_width < min_width)
2033     {
2034       priv->max_width = min_width;
2035       g_object_notify (G_OBJECT (tree_column), "max-width");
2036     }
2037   g_object_notify (G_OBJECT (tree_column), "min-width");
2038   g_object_thaw_notify (G_OBJECT (tree_column));
2039
2040   if (priv->column_type == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
2041     _gtk_tree_view_column_autosize (GTK_TREE_VIEW (priv->tree_view),
2042                                     tree_column);
2043 }
2044
2045 /**
2046  * gtk_tree_view_column_get_min_width:
2047  * @tree_column: A #GtkTreeViewColumn.
2048  *
2049  * Returns the minimum width in pixels of the @tree_column, or -1 if no minimum
2050  * width is set.
2051  *
2052  * Return value: The minimum width of the @tree_column.
2053  **/
2054 gint
2055 gtk_tree_view_column_get_min_width (GtkTreeViewColumn *tree_column)
2056 {
2057   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), -1);
2058
2059   return tree_column->priv->min_width;
2060 }
2061
2062 /**
2063  * gtk_tree_view_column_set_max_width:
2064  * @tree_column: A #GtkTreeViewColumn.
2065  * @max_width: The maximum width of the column in pixels, or -1.
2066  *
2067  * Sets the maximum width of the @tree_column.  If @max_width is -1, then the
2068  * maximum width is unset.  Note, the column can actually be wider than max
2069  * width if it's the last column in a view.  In this case, the column expands to
2070  * fill any extra space.
2071  **/
2072 void
2073 gtk_tree_view_column_set_max_width (GtkTreeViewColumn *tree_column,
2074                                     gint               max_width)
2075 {
2076   GtkTreeViewColumnPrivate *priv;
2077
2078   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
2079   g_return_if_fail (max_width >= -1);
2080
2081   priv = tree_column->priv;
2082
2083   if (max_width == priv->max_width)
2084     return;
2085
2086   if (priv->visible &&
2087       priv->tree_view != NULL &&
2088       gtk_widget_get_realized (priv->tree_view))
2089     {
2090       if (max_width != -1 && max_width < priv->width)
2091         gtk_widget_queue_resize (priv->tree_view);
2092     }
2093
2094   priv->max_width = max_width;
2095   g_object_freeze_notify (G_OBJECT (tree_column));
2096   if (max_width != -1 && max_width < priv->min_width)
2097     {
2098       priv->min_width = max_width;
2099       g_object_notify (G_OBJECT (tree_column), "min-width");
2100     }
2101   g_object_notify (G_OBJECT (tree_column), "max-width");
2102   g_object_thaw_notify (G_OBJECT (tree_column));
2103
2104   if (priv->column_type == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
2105     _gtk_tree_view_column_autosize (GTK_TREE_VIEW (priv->tree_view),
2106                                     tree_column);
2107 }
2108
2109 /**
2110  * gtk_tree_view_column_get_max_width:
2111  * @tree_column: A #GtkTreeViewColumn.
2112  *
2113  * Returns the maximum width in pixels of the @tree_column, or -1 if no maximum
2114  * width is set.
2115  *
2116  * Return value: The maximum width of the @tree_column.
2117  **/
2118 gint
2119 gtk_tree_view_column_get_max_width (GtkTreeViewColumn *tree_column)
2120 {
2121   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), -1);
2122
2123   return tree_column->priv->max_width;
2124 }
2125
2126 /**
2127  * gtk_tree_view_column_clicked:
2128  * @tree_column: a #GtkTreeViewColumn
2129  *
2130  * Emits the "clicked" signal on the column.  This function will only work if
2131  * @tree_column is clickable.
2132  **/
2133 void
2134 gtk_tree_view_column_clicked (GtkTreeViewColumn *tree_column)
2135 {
2136   GtkTreeViewColumnPrivate *priv;
2137
2138   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
2139
2140   priv = tree_column->priv;
2141
2142   if (priv->visible &&
2143       priv->button &&
2144       priv->clickable)
2145     gtk_button_clicked (GTK_BUTTON (priv->button));
2146 }
2147
2148 /**
2149  * gtk_tree_view_column_set_title:
2150  * @tree_column: A #GtkTreeViewColumn.
2151  * @title: The title of the @tree_column.
2152  *
2153  * Sets the title of the @tree_column.  If a custom widget has been set, then
2154  * this value is ignored.
2155  **/
2156 void
2157 gtk_tree_view_column_set_title (GtkTreeViewColumn *tree_column,
2158                                 const gchar       *title)
2159 {
2160   GtkTreeViewColumnPrivate *priv;
2161   gchar                    *new_title;
2162
2163   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
2164
2165   priv = tree_column->priv;
2166
2167   new_title = g_strdup (title);
2168   g_free (priv->title);
2169   priv->title = new_title;
2170
2171   gtk_tree_view_column_update_button (tree_column);
2172   g_object_notify (G_OBJECT (tree_column), "title");
2173 }
2174
2175 /**
2176  * gtk_tree_view_column_get_title:
2177  * @tree_column: A #GtkTreeViewColumn.
2178  *
2179  * Returns the title of the widget.
2180  *
2181  * Return value: the title of the column. This string should not be
2182  * modified or freed.
2183  **/
2184 G_CONST_RETURN gchar *
2185 gtk_tree_view_column_get_title (GtkTreeViewColumn *tree_column)
2186 {
2187   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), NULL);
2188
2189   return tree_column->priv->title;
2190 }
2191
2192 /**
2193  * gtk_tree_view_column_set_expand:
2194  * @tree_column: A #GtkTreeViewColumn
2195  * @expand: %TRUE if the column should take available extra space, %FALSE if not
2196  *
2197  * Sets the column to take available extra space.  This space is shared equally
2198  * amongst all columns that have the expand set to %TRUE.  If no column has this
2199  * option set, then the last column gets all extra space.  By default, every
2200  * column is created with this %FALSE.
2201  *
2202  * Since: 2.4
2203  **/
2204 void
2205 gtk_tree_view_column_set_expand (GtkTreeViewColumn *tree_column,
2206                                  gboolean           expand)
2207 {
2208   GtkTreeViewColumnPrivate *priv;
2209
2210   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
2211
2212   priv = tree_column->priv;
2213
2214   expand = expand?TRUE:FALSE;
2215   if (priv->expand == expand)
2216     return;
2217   priv->expand = expand;
2218
2219   if (priv->visible &&
2220       priv->tree_view != NULL &&
2221       gtk_widget_get_realized (priv->tree_view))
2222     {
2223       /* We want to continue using the original width of the
2224        * column that includes additional space added by the user
2225        * resizing the columns and possibly extra (expanded) space, which
2226        * are not included in the resized width.
2227        */
2228       priv->use_resized_width = FALSE;
2229
2230       gtk_widget_queue_resize (priv->tree_view);
2231     }
2232
2233   g_object_notify (G_OBJECT (tree_column), "expand");
2234 }
2235
2236 /**
2237  * gtk_tree_view_column_get_expand:
2238  * @tree_column: a #GtkTreeViewColumn
2239  *
2240  * Return %TRUE if the column expands to take any available space.
2241  *
2242  * Return value: %TRUE, if the column expands
2243  *
2244  * Since: 2.4
2245  **/
2246 gboolean
2247 gtk_tree_view_column_get_expand (GtkTreeViewColumn *tree_column)
2248 {
2249   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), FALSE);
2250
2251   return tree_column->priv->expand;
2252 }
2253
2254 /**
2255  * gtk_tree_view_column_set_clickable:
2256  * @tree_column: A #GtkTreeViewColumn.
2257  * @clickable: %TRUE if the header is active.
2258  *
2259  * Sets the header to be active if @active is %TRUE.  When the header is active,
2260  * then it can take keyboard focus, and can be clicked.
2261  **/
2262 void
2263 gtk_tree_view_column_set_clickable (GtkTreeViewColumn *tree_column,
2264                                     gboolean           clickable)
2265 {
2266   GtkTreeViewColumnPrivate *priv;
2267
2268   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
2269
2270   priv = tree_column->priv;
2271
2272   clickable = !! clickable;
2273   if (priv->clickable == clickable)
2274     return;
2275
2276   priv->clickable = clickable;
2277   gtk_tree_view_column_update_button (tree_column);
2278   g_object_notify (G_OBJECT (tree_column), "clickable");
2279 }
2280
2281 /**
2282  * gtk_tree_view_column_get_clickable:
2283  * @tree_column: a #GtkTreeViewColumn
2284  *
2285  * Returns %TRUE if the user can click on the header for the column.
2286  *
2287  * Return value: %TRUE if user can click the column header.
2288  **/
2289 gboolean
2290 gtk_tree_view_column_get_clickable (GtkTreeViewColumn *tree_column)
2291 {
2292   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), FALSE);
2293
2294   return tree_column->priv->clickable;
2295 }
2296
2297 /**
2298  * gtk_tree_view_column_set_widget:
2299  * @tree_column: A #GtkTreeViewColumn.
2300  * @widget: (allow-none): A child #GtkWidget, or %NULL.
2301  *
2302  * Sets the widget in the header to be @widget.  If widget is %NULL, then the
2303  * header button is set with a #GtkLabel set to the title of @tree_column.
2304  **/
2305 void
2306 gtk_tree_view_column_set_widget (GtkTreeViewColumn *tree_column,
2307                                  GtkWidget         *widget)
2308 {
2309   GtkTreeViewColumnPrivate *priv;
2310
2311   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
2312   g_return_if_fail (widget == NULL || GTK_IS_WIDGET (widget));
2313
2314   priv = tree_column->priv;
2315
2316   if (widget)
2317     g_object_ref_sink (widget);
2318
2319   if (priv->child)
2320     g_object_unref (priv->child);
2321
2322   priv->child = widget;
2323   gtk_tree_view_column_update_button (tree_column);
2324   g_object_notify (G_OBJECT (tree_column), "widget");
2325 }
2326
2327 /**
2328  * gtk_tree_view_column_get_widget:
2329  * @tree_column: A #GtkTreeViewColumn.
2330  *
2331  * Returns the #GtkWidget in the button on the column header.
2332  * If a custom widget has not been set then %NULL is returned.
2333  *
2334  * Return value: (transfer none): The #GtkWidget in the column
2335  *     header, or %NULL
2336  **/
2337 GtkWidget *
2338 gtk_tree_view_column_get_widget (GtkTreeViewColumn *tree_column)
2339 {
2340   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), NULL);
2341
2342   return tree_column->priv->child;
2343 }
2344
2345 /**
2346  * gtk_tree_view_column_set_alignment:
2347  * @tree_column: A #GtkTreeViewColumn.
2348  * @xalign: The alignment, which is between [0.0 and 1.0] inclusive.
2349  *
2350  * Sets the alignment of the title or custom widget inside the column header.
2351  * The alignment determines its location inside the button -- 0.0 for left, 0.5
2352  * for center, 1.0 for right.
2353  **/
2354 void
2355 gtk_tree_view_column_set_alignment (GtkTreeViewColumn *tree_column,
2356                                     gfloat             xalign)
2357 {
2358   GtkTreeViewColumnPrivate *priv;
2359
2360   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
2361
2362   priv = tree_column->priv;
2363
2364   xalign = CLAMP (xalign, 0.0, 1.0);
2365
2366   if (priv->xalign == xalign)
2367     return;
2368
2369   priv->xalign = xalign;
2370   gtk_tree_view_column_update_button (tree_column);
2371   g_object_notify (G_OBJECT (tree_column), "alignment");
2372 }
2373
2374 /**
2375  * gtk_tree_view_column_get_alignment:
2376  * @tree_column: A #GtkTreeViewColumn.
2377  *
2378  * Returns the current x alignment of @tree_column.  This value can range
2379  * between 0.0 and 1.0.
2380  *
2381  * Return value: The current alignent of @tree_column.
2382  **/
2383 gfloat
2384 gtk_tree_view_column_get_alignment (GtkTreeViewColumn *tree_column)
2385 {
2386   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), 0.5);
2387
2388   return tree_column->priv->xalign;
2389 }
2390
2391 /**
2392  * gtk_tree_view_column_set_reorderable:
2393  * @tree_column: A #GtkTreeViewColumn
2394  * @reorderable: %TRUE, if the column can be reordered.
2395  *
2396  * If @reorderable is %TRUE, then the column can be reordered by the end user
2397  * dragging the header.
2398  **/
2399 void
2400 gtk_tree_view_column_set_reorderable (GtkTreeViewColumn *tree_column,
2401                                       gboolean           reorderable)
2402 {
2403   GtkTreeViewColumnPrivate *priv;
2404
2405   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
2406
2407   priv = tree_column->priv;
2408
2409   /*  if (reorderable)
2410       gtk_tree_view_column_set_clickable (tree_column, TRUE);*/
2411
2412   if (priv->reorderable == (reorderable?TRUE:FALSE))
2413     return;
2414
2415   priv->reorderable = (reorderable?TRUE:FALSE);
2416   gtk_tree_view_column_update_button (tree_column);
2417   g_object_notify (G_OBJECT (tree_column), "reorderable");
2418 }
2419
2420 /**
2421  * gtk_tree_view_column_get_reorderable:
2422  * @tree_column: A #GtkTreeViewColumn
2423  *
2424  * Returns %TRUE if the @tree_column can be reordered by the user.
2425  *
2426  * Return value: %TRUE if the @tree_column can be reordered by the user.
2427  **/
2428 gboolean
2429 gtk_tree_view_column_get_reorderable (GtkTreeViewColumn *tree_column)
2430 {
2431   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), FALSE);
2432
2433   return tree_column->priv->reorderable;
2434 }
2435
2436
2437 /**
2438  * gtk_tree_view_column_set_sort_column_id:
2439  * @tree_column: a #GtkTreeViewColumn
2440  * @sort_column_id: The @sort_column_id of the model to sort on.
2441  *
2442  * Sets the logical @sort_column_id that this column sorts on when this column
2443  * is selected for sorting.  Doing so makes the column header clickable.
2444  **/
2445 void
2446 gtk_tree_view_column_set_sort_column_id (GtkTreeViewColumn *tree_column,
2447                                          gint               sort_column_id)
2448 {
2449   GtkTreeViewColumnPrivate *priv;
2450
2451   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
2452   g_return_if_fail (sort_column_id >= -1);
2453
2454   priv = tree_column->priv;
2455
2456   if (priv->sort_column_id == sort_column_id)
2457     return;
2458
2459   priv->sort_column_id = sort_column_id;
2460
2461   /* Handle unsetting the id */
2462   if (sort_column_id == -1)
2463     {
2464       GtkTreeModel *model = gtk_tree_view_get_model (GTK_TREE_VIEW (priv->tree_view));
2465
2466       if (priv->sort_clicked_signal)
2467         {
2468           g_signal_handler_disconnect (tree_column, priv->sort_clicked_signal);
2469           priv->sort_clicked_signal = 0;
2470         }
2471
2472       if (priv->sort_column_changed_signal)
2473         {
2474           g_signal_handler_disconnect (model, priv->sort_column_changed_signal);
2475           priv->sort_column_changed_signal = 0;
2476         }
2477
2478       gtk_tree_view_column_set_sort_order (tree_column, GTK_SORT_ASCENDING);
2479       gtk_tree_view_column_set_sort_indicator (tree_column, FALSE);
2480       gtk_tree_view_column_set_clickable (tree_column, FALSE);
2481       g_object_notify (G_OBJECT (tree_column), "sort-column-id");
2482       return;
2483     }
2484
2485   gtk_tree_view_column_set_clickable (tree_column, TRUE);
2486
2487   if (! priv->sort_clicked_signal)
2488     priv->sort_clicked_signal = g_signal_connect (tree_column,
2489                                                   "clicked",
2490                                                   G_CALLBACK (gtk_tree_view_column_sort),
2491                                                   NULL);
2492
2493   gtk_tree_view_column_setup_sort_column_id_callback (tree_column);
2494   g_object_notify (G_OBJECT (tree_column), "sort-column-id");
2495 }
2496
2497 /**
2498  * gtk_tree_view_column_get_sort_column_id:
2499  * @tree_column: a #GtkTreeViewColumn
2500  *
2501  * Gets the logical @sort_column_id that the model sorts on when this
2502  * column is selected for sorting.
2503  * See gtk_tree_view_column_set_sort_column_id().
2504  *
2505  * Return value: the current @sort_column_id for this column, or -1 if
2506  *               this column can't be used for sorting.
2507  **/
2508 gint
2509 gtk_tree_view_column_get_sort_column_id (GtkTreeViewColumn *tree_column)
2510 {
2511   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), 0);
2512
2513   return tree_column->priv->sort_column_id;
2514 }
2515
2516 /**
2517  * gtk_tree_view_column_set_sort_indicator:
2518  * @tree_column: a #GtkTreeViewColumn
2519  * @setting: %TRUE to display an indicator that the column is sorted
2520  *
2521  * Call this function with a @setting of %TRUE to display an arrow in
2522  * the header button indicating the column is sorted. Call
2523  * gtk_tree_view_column_set_sort_order() to change the direction of
2524  * the arrow.
2525  *
2526  **/
2527 void
2528 gtk_tree_view_column_set_sort_indicator (GtkTreeViewColumn     *tree_column,
2529                                          gboolean               setting)
2530 {
2531   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
2532
2533   setting = setting != FALSE;
2534
2535   if (setting == tree_column->priv->show_sort_indicator)
2536     return;
2537
2538   tree_column->priv->show_sort_indicator = setting;
2539   gtk_tree_view_column_update_button (tree_column);
2540   g_object_notify (G_OBJECT (tree_column), "sort-indicator");
2541 }
2542
2543 /**
2544  * gtk_tree_view_column_get_sort_indicator:
2545  * @tree_column: a #GtkTreeViewColumn
2546  *
2547  * Gets the value set by gtk_tree_view_column_set_sort_indicator().
2548  *
2549  * Return value: whether the sort indicator arrow is displayed
2550  **/
2551 gboolean
2552 gtk_tree_view_column_get_sort_indicator  (GtkTreeViewColumn     *tree_column)
2553 {
2554   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), FALSE);
2555
2556   return tree_column->priv->show_sort_indicator;
2557 }
2558
2559 /**
2560  * gtk_tree_view_column_set_sort_order:
2561  * @tree_column: a #GtkTreeViewColumn
2562  * @order: sort order that the sort indicator should indicate
2563  *
2564  * Changes the appearance of the sort indicator.
2565  *
2566  * This <emphasis>does not</emphasis> actually sort the model.  Use
2567  * gtk_tree_view_column_set_sort_column_id() if you want automatic sorting
2568  * support.  This function is primarily for custom sorting behavior, and should
2569  * be used in conjunction with gtk_tree_sortable_set_sort_column() to do
2570  * that. For custom models, the mechanism will vary.
2571  *
2572  * The sort indicator changes direction to indicate normal sort or reverse sort.
2573  * Note that you must have the sort indicator enabled to see anything when
2574  * calling this function; see gtk_tree_view_column_set_sort_indicator().
2575  **/
2576 void
2577 gtk_tree_view_column_set_sort_order      (GtkTreeViewColumn     *tree_column,
2578                                           GtkSortType            order)
2579 {
2580   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
2581
2582   if (order == tree_column->priv->sort_order)
2583     return;
2584
2585   tree_column->priv->sort_order = order;
2586   gtk_tree_view_column_update_button (tree_column);
2587   g_object_notify (G_OBJECT (tree_column), "sort-order");
2588 }
2589
2590 /**
2591  * gtk_tree_view_column_get_sort_order:
2592  * @tree_column: a #GtkTreeViewColumn
2593  *
2594  * Gets the value set by gtk_tree_view_column_set_sort_order().
2595  *
2596  * Return value: the sort order the sort indicator is indicating
2597  **/
2598 GtkSortType
2599 gtk_tree_view_column_get_sort_order      (GtkTreeViewColumn     *tree_column)
2600 {
2601   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), 0);
2602
2603   return tree_column->priv->sort_order;
2604 }
2605
2606 /**
2607  * gtk_tree_view_column_cell_set_cell_data:
2608  * @tree_column: A #GtkTreeViewColumn.
2609  * @tree_model: The #GtkTreeModel to to get the cell renderers attributes from.
2610  * @iter: The #GtkTreeIter to to get the cell renderer's attributes from.
2611  * @is_expander: %TRUE, if the row has children
2612  * @is_expanded: %TRUE, if the row has visible children
2613  *
2614  * Sets the cell renderer based on the @tree_model and @iter.  That is, for
2615  * every attribute mapping in @tree_column, it will get a value from the set
2616  * column on the @iter, and use that value to set the attribute on the cell
2617  * renderer.  This is used primarily by the #GtkTreeView.
2618  **/
2619 void
2620 gtk_tree_view_column_cell_set_cell_data (GtkTreeViewColumn *tree_column,
2621                                          GtkTreeModel      *tree_model,
2622                                          GtkTreeIter       *iter,
2623                                          gboolean           is_expander,
2624                                          gboolean           is_expanded)
2625 {
2626   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
2627
2628   if (tree_model == NULL)
2629     return;
2630
2631   gtk_cell_area_apply_attributes (tree_column->priv->cell_area, tree_model, iter,
2632                                   is_expander, is_expanded);
2633 }
2634
2635 /**
2636  * gtk_tree_view_column_cell_get_size:
2637  * @tree_column: A #GtkTreeViewColumn.
2638  * @cell_area: (allow-none): The area a cell in the column will be allocated, or %NULL
2639  * @x_offset: (allow-none): location to return x offset of a cell relative to @cell_area, or %NULL
2640  * @y_offset: (allow-none): location to return y offset of a cell relative to @cell_area, or %NULL
2641  * @width: (allow-none): location to return width needed to render a cell, or %NULL
2642  * @height: (allow-none): location to return height needed to render a cell, or %NULL
2643  *
2644  * Obtains the width and height needed to render the column.  This is used
2645  * primarily by the #GtkTreeView.
2646  **/
2647 void
2648 gtk_tree_view_column_cell_get_size (GtkTreeViewColumn  *tree_column,
2649                                     const GdkRectangle *cell_area,
2650                                     gint               *x_offset,
2651                                     gint               *y_offset,
2652                                     gint               *width,
2653                                     gint               *height)
2654 {
2655   GtkTreeViewColumnPrivate *priv;
2656   int focus_line_width;
2657
2658   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
2659
2660   priv = tree_column->priv;
2661
2662   if (height)
2663     * height = 0;
2664   if (width)
2665     * width = 0;
2666
2667   /* FIXME: This is a temporary hack to get things to allocate mostly right.
2668    *
2669    * We will add twice the focus-line-width to the for-width
2670    * parameter below.  If we do not do this, the height returned is the
2671    * height for two lines of text instead of one.  It feels like some lines
2672    * get less width than expected (due to subtraction of focus_line_width?)
2673    * and will unnecessarily wrap.
2674    */
2675   gtk_widget_style_get (priv->tree_view,
2676                         "focus-line-width", &focus_line_width,
2677                         NULL);
2678
2679   g_signal_handler_block (priv->cell_area_context,
2680                           priv->context_changed_signal);
2681
2682   gtk_cell_area_get_preferred_width (priv->cell_area,
2683                                      priv->cell_area_context,
2684                                      priv->tree_view,
2685                                      width, NULL);
2686   gtk_cell_area_get_preferred_height_for_width (priv->cell_area,
2687                                                 priv->cell_area_context,
2688                                                 priv->tree_view,
2689                                                 *width + focus_line_width * 2,
2690                                                 height,
2691                                                 NULL);
2692
2693   g_signal_handler_unblock (priv->cell_area_context,
2694                             priv->context_changed_signal);
2695
2696
2697   if (height)
2698     * height = min_height;
2699   if (width)
2700     * width = min_width;
2701
2702 }
2703
2704 /**
2705  * gtk_tree_view_column_cell_render:
2706  * @tree_column: A #GtkTreeViewColumn.
2707  * @cr: cairo context to draw to
2708  * @background_area: entire cell area (including tree expanders and maybe padding on the sides)
2709  * @cell_area: area normally rendered by a cell renderer
2710  * @flags: flags that affect rendering
2711  *
2712  * Renders the cell contained by #tree_column. This is used primarily by the
2713  * #GtkTreeView.
2714  **/
2715 void
2716 _gtk_tree_view_column_cell_render (GtkTreeViewColumn  *tree_column,
2717                                    cairo_t            *cr,
2718                                    const GdkRectangle *background_area,
2719                                    const GdkRectangle *cell_area,
2720                                    guint               flags,
2721                                    gboolean            draw_focus)
2722 {
2723   GtkTreeViewColumnPrivate *priv;
2724
2725   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
2726   g_return_if_fail (cr != NULL);
2727   g_return_if_fail (background_area != NULL);
2728   g_return_if_fail (cell_area != NULL);
2729
2730   priv = tree_column->priv;
2731
2732   cairo_save (cr);
2733
2734   gtk_cell_area_render (priv->cell_area, priv->cell_area_context,
2735                         priv->tree_view, cr,
2736                         background_area, cell_area, flags,
2737                         draw_focus);
2738
2739   cairo_restore (cr);
2740 }
2741
2742 gboolean
2743 _gtk_tree_view_column_cell_event (GtkTreeViewColumn  *tree_column,
2744                                   GtkCellEditable   **editable_widget,
2745                                   GdkEvent           *event,
2746                                   gchar              *path_string,
2747                                   const GdkRectangle *background_area,
2748                                   const GdkRectangle *cell_area,
2749                                   guint               flags)
2750 {
2751   GtkTreeViewColumnPrivate *priv;
2752
2753   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), FALSE);
2754
2755   priv = tree_column->priv;
2756
2757   /* FIXME: Should we pass background area here as well?
2758    * What will happen to the path_string and editable widget
2759    * variables?
2760    *
2761    * Answer, No dont pass background area... editable widgets
2762    * grab the pointer and keyboard so the treeview doesnt
2763    * recieve these events while editable widgets are editing.
2764    *
2765    * Also it's important that gtk_cell_area_apply_attributes be
2766    * called before passing the event to the cell (maybe we need to
2767    * instead use the path_string here to apply the attributes ?,
2768    * if the attributes are applied, the underlying CellArea knows
2769    * the path string, which is expected when handling events).
2770    */
2771   return gtk_cell_area_event (priv->cell_area,
2772                               priv->cell_area_context,
2773                               priv->tree_view,
2774                               event,
2775                               cell_area,
2776                               flags);
2777 }
2778
2779 void
2780 _gtk_tree_view_column_get_focus_area (GtkTreeViewColumn  *tree_column,
2781                                       const GdkRectangle *background_area,
2782                                       const GdkRectangle *cell_area,
2783                                       GdkRectangle       *focus_area)
2784 {
2785   /* FIXME */
2786 #if 0
2787   gtk_tree_view_column_cell_process_action (tree_column,
2788                                             NULL,
2789                                             background_area,
2790                                             cell_area,
2791                                             0,
2792                                             CELL_ACTION_FOCUS,
2793                                             focus_area,
2794                                             NULL, NULL, NULL);
2795 #endif
2796 }
2797
2798
2799 gboolean
2800 _gtk_tree_view_column_cell_focus (GtkTreeViewColumn *tree_column,
2801                                   gint               count,
2802                                   gboolean           left,
2803                                   gboolean           right)
2804 {
2805   gboolean rtl;
2806   GtkDirectionType direction = 0;
2807   GtkTreeViewColumnPrivate *priv = tree_column->priv;
2808
2809   rtl = gtk_widget_get_direction (priv->tree_view) == GTK_TEXT_DIR_RTL;
2810
2811   switch (count)
2812     {
2813       case -1:
2814         direction = GTK_DIR_LEFT;
2815         break;
2816
2817       case 1:
2818         direction = GTK_DIR_RIGHT;
2819         break;
2820     }
2821
2822   /* if we are the current focus column and have multiple editable cells,
2823    * try to select the next one, else move the focus to the next column
2824    */
2825   if (_gtk_tree_view_get_focus_column (GTK_TREE_VIEW (priv->tree_view)) == tree_column)
2826     {
2827       if (gtk_cell_area_focus (priv->cell_area, direction))
2828         /* Focus stays in this column, so we are done */
2829         return TRUE;
2830
2831       /* FIXME: RTL support for the following: */
2832       if (count == -1 && !left)
2833         {
2834           direction = GTK_DIR_RIGHT;
2835           gtk_cell_area_focus (priv->cell_area, direction);
2836         }
2837       else if (count == 1 && !right)
2838         {
2839           direction = GTK_DIR_LEFT;
2840           gtk_cell_area_focus (priv->cell_area, direction);
2841         }
2842
2843       return FALSE;
2844     }
2845
2846   return gtk_cell_area_focus (priv->cell_area, direction);
2847 }
2848
2849 /**
2850  * gtk_tree_view_column_cell_is_visible:
2851  * @tree_column: A #GtkTreeViewColumn
2852  *
2853  * Returns %TRUE if any of the cells packed into the @tree_column are visible.
2854  * For this to be meaningful, you must first initialize the cells with
2855  * gtk_tree_view_column_cell_set_cell_data()
2856  *
2857  * Return value: %TRUE, if any of the cells packed into the @tree_column are currently visible
2858  **/
2859 gboolean
2860 gtk_tree_view_column_cell_is_visible (GtkTreeViewColumn *tree_column)
2861 {
2862   GList *list;
2863   GList *cells;
2864   GtkTreeViewColumnPrivate *priv;
2865
2866   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), FALSE);
2867
2868   priv = tree_column->priv;
2869
2870   cells = gtk_cell_layout_get_cells (GTK_CELL_LAYOUT (priv->cell_area));
2871   for (list = cells; list; list = list->next)
2872     {
2873       if (gtk_cell_renderer_get_visible (list->data))
2874         {
2875           g_list_free (cells);
2876           return TRUE;
2877         }
2878     }
2879
2880   g_list_free (cells);
2881
2882   return FALSE;
2883 }
2884
2885 /**
2886  * gtk_tree_view_column_focus_cell:
2887  * @tree_column: A #GtkTreeViewColumn
2888  * @cell: A #GtkCellRenderer
2889  *
2890  * Sets the current keyboard focus to be at @cell, if the column contains
2891  * 2 or more editable and activatable cells.
2892  *
2893  * Since: 2.2
2894  **/
2895 void
2896 gtk_tree_view_column_focus_cell (GtkTreeViewColumn *tree_column,
2897                                  GtkCellRenderer   *cell)
2898 {
2899   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
2900   g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
2901
2902   gtk_cell_area_set_focus_cell (tree_column->priv->cell_area, cell);
2903 }
2904
2905 void
2906 _gtk_tree_view_column_cell_set_dirty (GtkTreeViewColumn *tree_column,
2907                                       gboolean           install_handler)
2908 {
2909   GtkTreeViewColumnPrivate *priv = tree_column->priv;
2910
2911   priv->dirty = TRUE;
2912   priv->requested_width = -1;
2913   priv->width = 0;
2914
2915   if (priv->tree_view &&
2916       gtk_widget_get_realized (priv->tree_view))
2917     {
2918       _gtk_tree_view_install_mark_rows_col_dirty (GTK_TREE_VIEW (priv->tree_view), install_handler);
2919       gtk_widget_queue_resize (priv->tree_view);
2920     }
2921 }
2922
2923 gboolean
2924 _gtk_tree_view_column_cell_get_dirty (GtkTreeViewColumn  *tree_column)
2925 {
2926   return tree_column->priv->dirty;
2927 }
2928
2929 /**
2930  * gtk_tree_view_column_cell_get_position:
2931  * @tree_column: a #GtkTreeViewColumn
2932  * @cell_renderer: a #GtkCellRenderer
2933  * @start_pos: return location for the horizontal position of @cell within
2934  *            @tree_column, may be %NULL
2935  * @width: return location for the width of @cell, may be %NULL
2936  *
2937  * Obtains the horizontal position and size of a cell in a column. If the
2938  * cell is not found in the column, @start_pos and @width are not changed and
2939  * %FALSE is returned.
2940  *
2941  * Return value: %TRUE if @cell belongs to @tree_column.
2942  */
2943 gboolean
2944 gtk_tree_view_column_cell_get_position (GtkTreeViewColumn *tree_column,
2945                                         GtkCellRenderer   *cell_renderer,
2946                                         gint              *start_pos,
2947                                         gint              *width)
2948 {
2949   GtkTreeViewColumnPrivate *priv;
2950   GdkRectangle zero_cell_area = { 0, };
2951   GdkRectangle allocation;
2952
2953   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), FALSE);
2954   g_return_val_if_fail (GTK_IS_CELL_RENDERER (cell_renderer), FALSE);
2955
2956   priv = tree_column->priv;
2957
2958   /* FIXME: Could use a boolean return value for invalid cells */
2959   gtk_cell_area_get_cell_allocation (priv->cell_area,
2960                                      priv->cell_area_context,
2961                                      priv->tree_view,
2962                                      cell_renderer,
2963                                      &zero_cell_area,
2964                                      &allocation);
2965
2966   if (start_pos)
2967     *start_pos = allocation.x;
2968   if (width)
2969     *width = allocation.width;
2970
2971   return TRUE;
2972 }
2973
2974 /**
2975  * gtk_tree_view_column_queue_resize:
2976  * @tree_column: A #GtkTreeViewColumn
2977  *
2978  * Flags the column, and the cell renderers added to this column, to have
2979  * their sizes renegotiated.
2980  *
2981  * Since: 2.8
2982  **/
2983 void
2984 gtk_tree_view_column_queue_resize (GtkTreeViewColumn *tree_column)
2985 {
2986   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
2987
2988   if (tree_column->priv->tree_view)
2989     _gtk_tree_view_column_cell_set_dirty (tree_column, TRUE);
2990 }
2991
2992 /**
2993  * gtk_tree_view_column_get_tree_view:
2994  * @tree_column: A #GtkTreeViewColumn
2995  *
2996  * Returns the #GtkTreeView wherein @tree_column has been inserted.
2997  * If @column is currently not inserted in any tree view, %NULL is
2998  * returned.
2999  *
3000  * Return value: (transfer none): The tree view wherein @column has
3001  *     been inserted if any, %NULL otherwise.
3002  *
3003  * Since: 2.12
3004  */
3005 GtkWidget *
3006 gtk_tree_view_column_get_tree_view (GtkTreeViewColumn *tree_column)
3007 {
3008   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), NULL);
3009
3010   return tree_column->priv->tree_view;
3011 }
3012
3013 /**
3014  * gtk_tree_view_column_get_button:
3015  * @tree_column: A #GtkTreeViewColumn
3016  *
3017  * Returns the button used in the treeview column header
3018  *
3019  * Return value: (transfer none): The button for the column header.
3020  *
3021  * Since: 3.0
3022  */
3023 GtkWidget *
3024 gtk_tree_view_column_get_button (GtkTreeViewColumn *tree_column)
3025 {
3026   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), NULL);
3027
3028   return tree_column->priv->button;
3029 }
3030
3031 GdkWindow *
3032 _gtk_tree_view_column_get_window (GtkTreeViewColumn  *column)
3033 {
3034   return column->priv->window;
3035 }
3036
3037 void
3038 _gtk_tree_view_column_set_requested_width (GtkTreeViewColumn  *column,
3039                                            gint                width)
3040 {
3041   column->priv->requested_width = width;
3042 }
3043
3044 gint
3045 _gtk_tree_view_column_get_requested_width (GtkTreeViewColumn  *column)
3046 {
3047   return column->priv->requested_width;
3048 }
3049
3050 void
3051 _gtk_tree_view_column_set_resized_width (GtkTreeViewColumn  *column,
3052                                          gint                width)
3053 {
3054   column->priv->resized_width = width;
3055 }
3056
3057 gint
3058 _gtk_tree_view_column_get_resized_width (GtkTreeViewColumn  *column)
3059 {
3060   return column->priv->resized_width;
3061 }
3062
3063 void
3064 _gtk_tree_view_column_set_use_resized_width (GtkTreeViewColumn  *column,
3065                                              gboolean            use_resized_width)
3066 {
3067   column->priv->use_resized_width = use_resized_width;
3068 }
3069
3070 gboolean
3071 _gtk_tree_view_column_get_use_resized_width (GtkTreeViewColumn  *column)
3072 {
3073   return column->priv->use_resized_width;
3074 }
3075
3076 gint
3077 _gtk_tree_view_column_get_drag_x (GtkTreeViewColumn  *column)
3078 {
3079   return column->priv->drag_x;
3080 }
3081
3082 GtkCellAreaContext *
3083 _gtk_tree_view_column_get_context (GtkTreeViewColumn  *column)
3084 {
3085   return column->priv->cell_area_context;
3086 }