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

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