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