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 "gtktreeviewcolumn.h"
  21 #include "gtktreeview.h"
  22 #include "gtktreeprivate.h"
  23 #include "gtksignal.h"
  24 #include "gtkbutton.h"
  25 #include "gtkalignment.h"
  26 #include "gtklabel.h"
  27 #include "gtkhbox.h"
  28 #include "gtkarrow.h"
  29 #include "gtkintl.h"
  30 #include <string.h>
  31
  32 enum
  33 {
  34   PROP_0,
  35
  36   PROP_CELL_RENDERER,
  37   PROP_VISIBLE,
  38   PROP_SIZING,
  39   PROP_WIDTH,
  40   PROP_MIN_WIDTH,
  41   PROP_MAX_WIDTH,
  42   PROP_TITLE,
  43   PROP_CLICKABLE,
  44   PROP_WIDGET,
  45   PROP_ALIGNMENT,
  46   PROP_REORDERABLE,
  47   PROP_SORT_INDICATOR,
  48   PROP_SORT_ORDER
  49 };
  50
  51 enum
  52 {
  53   CLICKED,
  54   LAST_SIGNAL
  55 };
  56
  57
  58 /* Type methods */
  59 static void gtk_tree_view_column_init                          (GtkTreeViewColumn       *tree_column);
  60 static void gtk_tree_view_column_class_init                    (GtkTreeViewColumnClass  *klass);
  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
  73 /* Button handling code */
  74 static void gtk_tree_view_column_create_button                 (GtkTreeViewColumn       *tree_column);
  75 static void gtk_tree_view_column_update_button                 (GtkTreeViewColumn       *tree_column);
  76
  77 /* Button signal handlers */
  78 static gint gtk_tree_view_column_button_event                  (GtkWidget               *widget,
  79                                                                 GdkEvent                *event,
  80                                                                 gpointer                 data);
  81 static void gtk_tree_view_column_button_realize                (GtkWidget               *widget,
  82                                                                 gpointer                 data);
  83 static void gtk_tree_view_column_button_clicked                (GtkWidget               *widget,
  84                                                                 gpointer                 data);
  85
  86 /* Property handlers */
  87 static void gtk_tree_view_model_sort_column_changed            (GtkTreeSortable         *sortable,
  88                                                                 GtkTreeViewColumn       *tree_column);
  89
  90 /* Internal functions */
  91 static void gtk_tree_view_column_sort                          (GtkTreeViewColumn       *tree_column,
  92                                                                 gpointer                 data);
  93 static void gtk_tree_view_column_setup_sort_column_id_callback (GtkTreeViewColumn       *tree_column);
  94 static void gtk_tree_view_column_set_attributesv               (GtkTreeViewColumn       *tree_column,
  95                                                                 va_list                  args);
  96
  97
  98
  99
 100 static GtkObjectClass *parent_class = NULL;
 101 static guint tree_column_signals[LAST_SIGNAL] = { 0 };
 102
 103
 104 GtkType
 105 gtk_tree_view_column_get_type (void)
 106 {
 107   static GtkType tree_column_type = 0;
 108
 109   if (!tree_column_type)
 110     {
 111       static const GTypeInfo tree_column_info =
 112       {
 113         sizeof (GtkTreeViewColumnClass),
 114         NULL,           /* base_init */
 115         NULL,           /* base_finalize */
 116         (GClassInitFunc) gtk_tree_view_column_class_init,
 117         NULL,           /* class_finalize */
 118         NULL,           /* class_data */
 119         sizeof (GtkTreeViewColumn),
 120         0,
 121         (GInstanceInitFunc) gtk_tree_view_column_init,
 122       };
 123
 124       tree_column_type = g_type_register_static (GTK_TYPE_OBJECT, "GtkTreeViewColumn", &tree_column_info, 0);
 125     }
 126
 127   return tree_column_type;
 128 }
 129
 130 static void
 131 gtk_tree_view_column_class_init (GtkTreeViewColumnClass *class)
 132 {
 133   GObjectClass *object_class;
 134
 135   object_class = (GObjectClass*) class;
 136
 137   parent_class = g_type_class_peek_parent (class);
 138
 139   class->clicked = NULL;
 140
 141   object_class->finalize = gtk_tree_view_column_finalize;
 142   object_class->set_property = gtk_tree_view_column_set_property;
 143   object_class->get_property = gtk_tree_view_column_get_property;
 144
 145   tree_column_signals[CLICKED] =
 146     g_signal_newc ("clicked",
 147                    GTK_CLASS_TYPE (object_class),
 148                    G_SIGNAL_RUN_LAST,
 149                    G_STRUCT_OFFSET (GtkTreeViewColumnClass, clicked),
 150                    NULL, NULL,
 151                    gtk_marshal_VOID__VOID,
 152                    GTK_TYPE_NONE, 0);
 153
 154   g_object_class_install_property (object_class,
 155                                    PROP_CELL_RENDERER,
 156                                    g_param_spec_object ("cell_renderer",
 157                                                         _("Cell renderer"),
 158                                                         _("Cell renderer object to use for rendering the cell"),
 159                                                         GTK_TYPE_CELL_RENDERER,
 160                                                         G_PARAM_READABLE | G_PARAM_WRITABLE));
 161
 162   g_object_class_install_property (object_class,
 163                                    PROP_VISIBLE,
 164                                    g_param_spec_boolean ("visible",
 165                                                         _("Visible"),
 166                                                         _("Whether to display the colomn"),
 167                                                          TRUE,
 168                                                          G_PARAM_READABLE | G_PARAM_WRITABLE));
 169
 170   g_object_class_install_property (object_class,
 171                                    PROP_SIZING,
 172                                    g_param_spec_enum ("sizing",
 173                                                       _("Sizing"),
 174                                                       _("Resize mode of the column"),
 175                                                       GTK_TYPE_TREE_VIEW_COLUMN_SIZING,
 176                                                       GTK_TREE_VIEW_COLUMN_AUTOSIZE,
 177                                                       G_PARAM_READABLE | G_PARAM_WRITABLE));
 178
 179   g_object_class_install_property (object_class,
 180                                    PROP_WIDTH,
 181                                    g_param_spec_int ("width",
 182                                                      _("Width"),
 183                                                      _("Current width of the column"),
 184                                                      1,
 185                                                      G_MAXINT,
 186                                                      1, /* not useful */
 187                                                      G_PARAM_READABLE | G_PARAM_WRITABLE));
 188
 189   g_object_class_install_property (object_class,
 190                                    PROP_MIN_WIDTH,
 191                                    g_param_spec_int ("min_width",
 192                                                      _("Minimum Width"),
 193                                                      _("Minimum allowed width of the column"),
 194                                                      -1,
 195                                                      G_MAXINT,
 196                                                      1,
 197                                                      G_PARAM_READABLE | G_PARAM_WRITABLE));
 198
 199   g_object_class_install_property (object_class,
 200                                    PROP_MAX_WIDTH,
 201                                    g_param_spec_int ("max_width",
 202                                                      _("Maximum Width"),
 203                                                      _("Maximum allowed width of the column"),
 204                                                      -1,
 205                                                      G_MAXINT,
 206                                                      G_MAXINT,
 207                                                      G_PARAM_READABLE | G_PARAM_WRITABLE));
 208
 209   g_object_class_install_property (object_class,
 210                                    PROP_TITLE,
 211                                    g_param_spec_string ("title",
 212                                                         _("Title"),
 213                                                         _("Title to appear in column header"),
 214                                                         "",
 215                                                         G_PARAM_READABLE | G_PARAM_WRITABLE));
 216
 217   g_object_class_install_property (object_class,
 218                                    PROP_CLICKABLE,
 219                                    g_param_spec_boolean ("clickable",
 220                                                         _("Clickable"),
 221                                                         _("Whether the header can be clicked"),
 222                                                          TRUE,
 223                                                          G_PARAM_READABLE | G_PARAM_WRITABLE));
 224
 225
 226   g_object_class_install_property (object_class,
 227                                    PROP_WIDGET,
 228                                    g_param_spec_object ("widget",
 229                                                         _("Widget"),
 230                                                         _("Widget to put in column header button instead of column title"),
 231                                                         GTK_TYPE_WIDGET,
 232                                                         G_PARAM_READABLE | G_PARAM_WRITABLE));
 233
 234   g_object_class_install_property (object_class,
 235                                    PROP_ALIGNMENT,
 236                                    g_param_spec_float ("alignment",
 237                                                        _("Alignment"),
 238                                                        _("X Alignment of the column header text or widget"),
 239                                                        0.0,
 240                                                        1.0,
 241                                                        0.5,
 242                                                        G_PARAM_READABLE | G_PARAM_WRITABLE));
 243
 244   g_object_class_install_property (object_class,
 245                                    PROP_REORDERABLE,
 246                                    g_param_spec_boolean ("reorderable",
 247                                                          _("Reorderable"),
 248                                                          _("Wether the column can be reordered around the headers"),
 249                                                          FALSE,
 250                                                          G_PARAM_READABLE | G_PARAM_WRITABLE));
 251
 252   g_object_class_install_property (object_class,
 253                                    PROP_SORT_INDICATOR,
 254                                    g_param_spec_boolean ("sort_indicator",
 255                                                         _("Sort indicator"),
 256                                                         _("Whether to show a sort indicator"),
 257                                                          FALSE,
 258                                                          G_PARAM_READABLE | G_PARAM_WRITABLE));
 259
 260   g_object_class_install_property (object_class,
 261                                    PROP_SORT_ORDER,
 262                                    g_param_spec_enum ("sort_order",
 263                                                       _("Sort order"),
 264                                                       _("Sort direction the sort indicator should indicate"),
 265                                                       GTK_TYPE_TREE_SORT_ORDER,
 266                                                       GTK_TREE_SORT_ASCENDING,
 267                                                       G_PARAM_READABLE | G_PARAM_WRITABLE));
 268
 269 }
 270
 271 static void
 272 gtk_tree_view_column_init (GtkTreeViewColumn *tree_column)
 273 {
 274   /* FIXME remove on port to GtkObject */
 275   gtk_object_ref (GTK_OBJECT (tree_column));
 276   gtk_object_sink (GTK_OBJECT (tree_column));
 277
 278   tree_column->button = NULL;
 279   tree_column->xalign = 0.0;
 280   tree_column->width = 1;
 281   tree_column->requested_width = -1;
 282   tree_column->min_width = -1;
 283   tree_column->max_width = -1;
 284   tree_column->cell = NULL;
 285   tree_column->attributes = NULL;
 286   tree_column->column_type = GTK_TREE_VIEW_COLUMN_AUTOSIZE;
 287   tree_column->visible = TRUE;
 288   tree_column->clickable = FALSE;
 289   tree_column->dirty = TRUE;
 290   tree_column->sort_order = GTK_TREE_SORT_ASCENDING;
 291   tree_column->show_sort_indicator = FALSE;
 292   tree_column->property_changed_signal = 0;
 293   tree_column->sort_clicked_signal = 0;
 294   tree_column->sort_column_changed_signal = 0;
 295   tree_column->sort_column_id = -1;
 296   tree_column->reorderable = FALSE;
 297   tree_column->maybe_reordered = FALSE;
 298 }
 299
 300 static void
 301 gtk_tree_view_column_finalize (GObject *object)
 302 {
 303   GtkTreeViewColumn *tree_column = (GtkTreeViewColumn *) object;
 304
 305   if (tree_column->func_data && tree_column->destroy)
 306     (tree_column->destroy) (tree_column->func_data);
 307
 308   g_slist_free (tree_column->attributes);
 309   g_free (tree_column->title);
 310 }
 311
 312 static void
 313 gtk_tree_view_column_set_property (GObject         *object,
 314                                    guint            prop_id,
 315                                    const GValue    *value,
 316                                    GParamSpec      *pspec)
 317 {
 318   GtkTreeViewColumn *tree_column;
 319
 320   tree_column = GTK_TREE_VIEW_COLUMN (object);
 321
 322   switch (prop_id)
 323     {
 324     case PROP_CELL_RENDERER:
 325       gtk_tree_view_column_set_cell_renderer (tree_column,
 326                                               (GtkCellRenderer*)
 327                                               g_value_get_object (value));
 328       break;
 329
 330     case PROP_VISIBLE:
 331       gtk_tree_view_column_set_visible (tree_column,
 332                                         g_value_get_boolean (value));
 333       break;
 334
 335     case PROP_SIZING:
 336       gtk_tree_view_column_set_sizing (tree_column,
 337                                        g_value_get_enum (value));
 338       break;
 339
 340     case PROP_WIDTH:
 341       gtk_tree_view_column_set_width (tree_column,
 342                                       g_value_get_int (value));
 343       break;
 344
 345     case PROP_MIN_WIDTH:
 346       gtk_tree_view_column_set_min_width (tree_column,
 347                                           g_value_get_int (value));
 348       break;
 349
 350     case PROP_MAX_WIDTH:
 351       gtk_tree_view_column_set_max_width (tree_column,
 352                                           g_value_get_int (value));
 353       break;
 354
 355     case PROP_TITLE:
 356       gtk_tree_view_column_set_title (tree_column,
 357                                       g_value_get_string (value));
 358       break;
 359
 360     case PROP_CLICKABLE:
 361       gtk_tree_view_column_set_clickable (tree_column,
 362                                           g_value_get_boolean (value));
 363       break;
 364
 365     case PROP_WIDGET:
 366       gtk_tree_view_column_set_widget (tree_column,
 367                                        (GtkWidget*) g_value_get_object (value));
 368       break;
 369
 370     case PROP_ALIGNMENT:
 371       gtk_tree_view_column_set_alignment (tree_column,
 372                                           g_value_get_float (value));
 373       break;
 374
 375     case PROP_REORDERABLE:
 376       gtk_tree_view_column_set_reorderable (tree_column,
 377                                             g_value_get_boolean (value));
 378       break;
 379
 380     case PROP_SORT_INDICATOR:
 381       gtk_tree_view_column_set_sort_indicator (tree_column,
 382                                                g_value_get_boolean (value));
 383       break;
 384
 385     case PROP_SORT_ORDER:
 386       gtk_tree_view_column_set_sort_order (tree_column,
 387                                            g_value_get_enum (value));
 388       break;
 389
 390     default:
 391       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 392       break;
 393     }
 394 }
 395
 396 static void
 397 gtk_tree_view_column_get_property (GObject         *object,
 398                                    guint            prop_id,
 399                                    GValue          *value,
 400                                    GParamSpec      *pspec)
 401 {
 402   GtkTreeViewColumn *tree_column;
 403
 404   tree_column = GTK_TREE_VIEW_COLUMN (object);
 405
 406   switch (prop_id)
 407     {
 408     case PROP_CELL_RENDERER:
 409       g_value_set_object (value,
 410                           (GObject*) gtk_tree_view_column_get_cell_renderer (tree_column));
 411       break;
 412
 413     case PROP_VISIBLE:
 414       g_value_set_boolean (value,
 415                            gtk_tree_view_column_get_visible (tree_column));
 416       break;
 417
 418     case PROP_SIZING:
 419       g_value_set_enum (value,
 420                         gtk_tree_view_column_get_sizing (tree_column));
 421       break;
 422
 423     case PROP_WIDTH:
 424       g_value_set_int (value,
 425                        gtk_tree_view_column_get_width (tree_column));
 426       break;
 427
 428     case PROP_MIN_WIDTH:
 429       g_value_set_int (value,
 430                        gtk_tree_view_column_get_min_width (tree_column));
 431       break;
 432
 433     case PROP_MAX_WIDTH:
 434       g_value_set_int (value,
 435                        gtk_tree_view_column_get_max_width (tree_column));
 436       break;
 437
 438     case PROP_TITLE:
 439       g_value_set_string (value,
 440                           gtk_tree_view_column_get_title (tree_column));
 441       break;
 442
 443     case PROP_CLICKABLE:
 444       g_value_set_boolean (value,
 445                            gtk_tree_view_column_get_clickable (tree_column));
 446       break;
 447
 448     case PROP_WIDGET:
 449       g_value_set_object (value,
 450                           (GObject*) gtk_tree_view_column_get_widget (tree_column));
 451       break;
 452
 453     case PROP_ALIGNMENT:
 454       g_value_set_float (value,
 455                          gtk_tree_view_column_get_alignment (tree_column));
 456       break;
 457
 458     case PROP_REORDERABLE:
 459       g_value_set_boolean (value,
 460                            gtk_tree_view_column_get_reorderable (tree_column));
 461       break;
 462
 463     case PROP_SORT_INDICATOR:
 464       g_value_set_boolean (value,
 465                            gtk_tree_view_column_get_sort_indicator (tree_column));
 466       break;
 467
 468     case PROP_SORT_ORDER:
 469       g_value_set_enum (value,
 470                         gtk_tree_view_column_get_sort_order (tree_column));
 471       break;
 472
 473     default:
 474       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 475       break;
 476     }
 477 }
 478
 479 /* Helper functions
 480  */
 481
 482 /* Button handling code
 483  */
 484 static void
 485 gtk_tree_view_column_create_button (GtkTreeViewColumn *tree_column)
 486 {
 487   GtkTreeView *tree_view;
 488   GtkWidget *child;
 489   GtkWidget *hbox;
 490
 491   tree_view = (GtkTreeView *) tree_column->tree_view;
 492
 493   g_return_if_fail (tree_view != NULL);
 494   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
 495   g_return_if_fail (tree_column->button == NULL);
 496
 497   gtk_widget_push_composite_child ();
 498   tree_column->button = gtk_button_new ();
 499   gtk_widget_pop_composite_child ();
 500
 501   /* make sure we own a reference to it as well. */
 502   gtk_widget_set_parent (tree_column->button, GTK_WIDGET (tree_view));
 503   if (tree_view->priv->header_window)
 504     gtk_widget_set_parent_window (tree_column->button, tree_view->priv->header_window);
 505
 506   gtk_signal_connect (GTK_OBJECT (tree_column->button), "realize",
 507                       (GtkSignalFunc) gtk_tree_view_column_button_realize,
 508                       NULL);
 509
 510   gtk_signal_connect (GTK_OBJECT (tree_column->button), "event",
 511                       (GtkSignalFunc) gtk_tree_view_column_button_event,
 512                       (gpointer) tree_column);
 513
 514   gtk_signal_connect (GTK_OBJECT (tree_column->button), "clicked",
 515                       (GtkSignalFunc) gtk_tree_view_column_button_clicked,
 516                       (gpointer) tree_column);
 517
 518   tree_column->alignment = gtk_alignment_new (tree_column->xalign, 0.5, 0.0, 0.0);
 519
 520   hbox = gtk_hbox_new (FALSE, 2);
 521   tree_column->arrow = gtk_arrow_new (GTK_ARROW_DOWN, GTK_SHADOW_IN);
 522
 523   if (tree_column->child)
 524     child = tree_column->child;
 525   else
 526     {
 527       child = gtk_label_new (tree_column->title);
 528       gtk_widget_show (child);
 529     }
 530
 531   if (tree_column->xalign <= 0.5)
 532     gtk_box_pack_end (GTK_BOX (hbox), tree_column->arrow, FALSE, FALSE, 0);
 533   else
 534     gtk_box_pack_start (GTK_BOX (hbox), tree_column->arrow, FALSE, FALSE, 0);
 535
 536   gtk_box_pack_start (GTK_BOX (hbox), tree_column->alignment, TRUE, TRUE, 0);
 537
 538   gtk_container_add (GTK_CONTAINER (tree_column->alignment), child);
 539   gtk_container_add (GTK_CONTAINER (tree_column->button), hbox);
 540
 541   gtk_widget_show (hbox);
 542   gtk_widget_show (tree_column->alignment);
 543   gtk_tree_view_column_update_button (tree_column);
 544 }
 545
 546 static void
 547 gtk_tree_view_column_update_button (GtkTreeViewColumn *tree_column)
 548 {
 549   GtkWidget *hbox;
 550   GtkWidget *alignment;
 551   GtkWidget *arrow;
 552   GtkWidget *current_child;
 553
 554   /* Create a button if necessary */
 555   if (tree_column->visible &&
 556       tree_column->button == NULL &&
 557       tree_column->tree_view &&
 558       GTK_WIDGET_REALIZED (tree_column->tree_view))
 559     gtk_tree_view_column_create_button (tree_column);
 560
 561   if (! tree_column->button)
 562     return;
 563
 564   hbox = GTK_BIN (tree_column->button)->child;
 565   alignment = tree_column->alignment;
 566   arrow = tree_column->arrow;
 567   current_child = GTK_BIN (alignment)->child;
 568
 569   /* Set up the actual button */
 570   gtk_alignment_set (GTK_ALIGNMENT (alignment), tree_column->xalign,
 571                      0.5, 0.0, 0.0);
 572
 573   if (tree_column->child)
 574     {
 575       if (current_child != tree_column->child)
 576         {
 577           gtk_container_remove (GTK_CONTAINER (alignment),
 578                                 current_child);
 579           gtk_container_add (GTK_CONTAINER (alignment),
 580                              tree_column->child);
 581         }
 582     }
 583   else
 584     {
 585       if (current_child == NULL)
 586         {
 587           current_child = gtk_label_new (NULL);
 588           gtk_widget_show (current_child);
 589           gtk_container_add (GTK_CONTAINER (alignment),
 590                              current_child);
 591         }
 592
 593       g_return_if_fail (GTK_IS_LABEL (current_child));
 594
 595       if (tree_column->title)
 596         gtk_label_set_text (GTK_LABEL (current_child),
 597                             tree_column->title);
 598       else
 599         gtk_label_set_text (GTK_LABEL (current_child),
 600                             "");
 601     }
 602
 603   switch (tree_column->sort_order)
 604     {
 605     case GTK_TREE_SORT_ASCENDING:
 606       gtk_arrow_set (GTK_ARROW (arrow),
 607                      GTK_ARROW_DOWN,
 608                      GTK_SHADOW_IN);
 609       break;
 610
 611     case GTK_TREE_SORT_DESCENDING:
 612       gtk_arrow_set (GTK_ARROW (arrow),
 613                      GTK_ARROW_UP,
 614                      GTK_SHADOW_IN);
 615       break;
 616
 617     default:
 618       g_warning (G_STRLOC": bad sort order");
 619       break;
 620     }
 621
 622   /* Put arrow on the right if the text is left-or-center justified,
 623        * and on the left otherwise; do this by packing boxes, so flipping
 624        * text direction will reverse things
 625        */
 626   gtk_widget_ref (arrow);
 627   gtk_container_remove (GTK_CONTAINER (hbox), arrow);
 628
 629   if (tree_column->xalign <= 0.5)
 630     {
 631       gtk_box_pack_end (GTK_BOX (hbox), arrow, FALSE, FALSE, 0);
 632     }
 633   else
 634     {
 635       gtk_box_pack_start (GTK_BOX (hbox), arrow, FALSE, FALSE, 0);
 636       /* move it to the front */
 637       gtk_box_reorder_child (GTK_BOX (hbox), arrow, 0);
 638     }
 639   gtk_widget_unref (arrow);
 640
 641   if (tree_column->show_sort_indicator)
 642     gtk_widget_show (arrow);
 643   else
 644     gtk_widget_hide (arrow);
 645
 646   /* It's always safe to hide the button.  It isn't always safe to show it, as if you show it
 647    * before it's realized, it'll get the wrong window. */
 648   if (tree_column->button &&
 649       tree_column->tree_view != NULL &&
 650       GTK_WIDGET_REALIZED (tree_column->tree_view))
 651     {
 652       if (tree_column->visible)
 653         {
 654           gtk_widget_show_now (tree_column->button);
 655           if (tree_column->window)
 656             {
 657               if (tree_column->column_type == GTK_TREE_VIEW_COLUMN_RESIZEABLE)
 658                 {
 659                   gdk_window_show (tree_column->window);
 660                   gdk_window_raise (tree_column->window);
 661                 }
 662               else
 663                 {
 664                   gdk_window_hide (tree_column->window);
 665                 }
 666             }
 667         }
 668       else
 669         {
 670           gtk_widget_hide (tree_column->button);
 671           if (tree_column->window)
 672             gdk_window_hide (tree_column->window);
 673         }
 674     }
 675
 676   if (tree_column->reorderable || tree_column->clickable)
 677     {
 678       GTK_WIDGET_SET_FLAGS (tree_column->button, GTK_CAN_FOCUS);
 679     }
 680   else
 681     {
 682       GTK_WIDGET_UNSET_FLAGS (tree_column->button, GTK_CAN_FOCUS);
 683       if (GTK_WIDGET_HAS_FOCUS (tree_column->button))
 684         gtk_window_set_focus (GTK_WINDOW (gtk_widget_get_toplevel (tree_column->tree_view)), NULL);
 685     }
 686
 687   tree_column->dirty = TRUE;
 688   gtk_widget_queue_resize (tree_column->tree_view);
 689 }
 690
 691 /* Button signal handlers
 692  */
 693
 694 static gint
 695 gtk_tree_view_column_button_event (GtkWidget *widget,
 696                                    GdkEvent  *event,
 697                                    gpointer   data)
 698 {
 699   GtkTreeViewColumn *column = (GtkTreeViewColumn *) data;
 700
 701   g_return_val_if_fail (event != NULL, FALSE);
 702
 703   if (event->type == GDK_BUTTON_PRESS &&
 704       column->reorderable)
 705     {
 706       column->maybe_reordered = TRUE;
 707       gdk_window_get_pointer (widget->window,
 708                               &column->drag_x,
 709                               &column->drag_y,
 710                               NULL);
 711       gtk_widget_grab_focus (widget);
 712     }
 713
 714   if (event->type == GDK_BUTTON_RELEASE &&
 715       column->maybe_reordered)
 716     column->maybe_reordered = FALSE;
 717
 718   if (event->type == GDK_MOTION_NOTIFY &&
 719       (column->maybe_reordered) &&
 720       (gtk_drag_check_threshold (widget,
 721                                  column->drag_x,
 722                                  column->drag_y,
 723                                  (gint) ((GdkEventMotion *)event)->x,
 724                                  (gint) ((GdkEventMotion *)event)->y)))
 725     {
 726       column->maybe_reordered = FALSE;
 727       _gtk_tree_view_column_start_drag (GTK_TREE_VIEW (column->tree_view), column);
 728       return TRUE;
 729     }
 730   if (column->clickable == FALSE)
 731     {
 732       switch (event->type)
 733         {
 734         case GDK_BUTTON_PRESS:
 735         case GDK_2BUTTON_PRESS:
 736         case GDK_3BUTTON_PRESS:
 737         case GDK_MOTION_NOTIFY:
 738         case GDK_BUTTON_RELEASE:
 739         case GDK_ENTER_NOTIFY:
 740         case GDK_LEAVE_NOTIFY:
 741           return TRUE;
 742         default:
 743           return FALSE;
 744         }
 745     }
 746   return FALSE;
 747 }
 748
 749 static void
 750 gtk_tree_view_column_button_realize (GtkWidget *widget, gpointer data)
 751 {
 752   gdk_window_set_events (widget->window, gdk_window_get_events (widget->window) | GDK_POINTER_MOTION_MASK);
 753 }
 754
 755 static void
 756 gtk_tree_view_column_button_clicked (GtkWidget *widget, gpointer data)
 757 {
 758   g_signal_emit_by_name (G_OBJECT (data), "clicked");
 759 }
 760
 761 static void
 762 gtk_tree_view_model_sort_column_changed (GtkTreeSortable   *sortable,
 763                                           GtkTreeViewColumn *column)
 764 {
 765   gint sort_column_id;
 766   GtkTreeSortOrder order;
 767
 768   if (gtk_tree_sortable_get_sort_column_id (sortable,
 769                                             &sort_column_id,
 770                                             &order))
 771     {
 772       if (sort_column_id == column->sort_column_id)
 773         {
 774           gtk_tree_view_column_set_sort_indicator (column, TRUE);
 775           gtk_tree_view_column_set_sort_order (column, order);
 776         }
 777       else
 778         {
 779           gtk_tree_view_column_set_sort_indicator (column, FALSE);
 780         }
 781     }
 782 }
 783
 784 static void
 785 gtk_tree_view_column_sort (GtkTreeViewColumn *tree_column,
 786                            gpointer           data)
 787 {
 788   GList *list;
 789
 790   g_return_if_fail (tree_column->tree_view != NULL);
 791
 792   if (tree_column->show_sort_indicator)
 793     {
 794       if (tree_column->sort_order == GTK_TREE_SORT_ASCENDING)
 795         gtk_tree_view_column_set_sort_order (tree_column, GTK_TREE_SORT_DESCENDING);
 796       else
 797         gtk_tree_view_column_set_sort_order (tree_column, GTK_TREE_SORT_ASCENDING);
 798     }
 799   else
 800     {
 801       gtk_tree_view_column_set_sort_order (tree_column, GTK_TREE_SORT_ASCENDING);
 802       gtk_tree_view_column_set_sort_indicator (tree_column, TRUE);
 803     }
 804
 805   list = (GTK_TREE_VIEW (tree_column->tree_view)->priv->columns);
 806   g_assert (list);
 807   while (list)
 808     {
 809       GtkTreeViewColumn *tmp_column;
 810
 811       tmp_column = GTK_TREE_VIEW_COLUMN (list->data);
 812       if (tmp_column->visible && tmp_column != tree_column)
 813         gtk_tree_view_column_set_sort_indicator (tmp_column, FALSE);
 814
 815       list = list->next;
 816     }
 817
 818   gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (GTK_TREE_VIEW (tree_column->tree_view)->priv->model),
 819                                         tree_column->sort_column_id,
 820                                         tree_column->sort_order);
 821 }
 822
 823
 824 static void
 825 gtk_tree_view_column_setup_sort_column_id_callback (GtkTreeViewColumn *tree_column)
 826 {
 827   GtkTreeModel *model;
 828
 829   if (tree_column->tree_view == NULL)
 830     return;
 831
 832   model = gtk_tree_view_get_model (GTK_TREE_VIEW (tree_column->tree_view));
 833
 834   if (model == NULL)
 835     {
 836       if (tree_column->sort_column_changed_signal)
 837         {
 838           g_signal_handler_disconnect (G_OBJECT (tree_column), tree_column->sort_column_changed_signal);
 839           tree_column->sort_column_changed_signal = 0;
 840         }
 841       return;
 842     }
 843
 844   if (GTK_IS_TREE_SORTABLE (model) &&
 845       tree_column->sort_column_id != -1)
 846     {
 847       gint real_sort_column_id;
 848       GtkTreeSortOrder real_order;
 849
 850       if (tree_column->sort_column_changed_signal == 0)
 851         tree_column->sort_column_changed_signal =
 852           g_signal_connectc (G_OBJECT (model), "sort_column_changed",
 853                              GTK_SIGNAL_FUNC (gtk_tree_view_model_sort_column_changed),
 854                              tree_column, FALSE);
 855
 856       if (gtk_tree_sortable_get_sort_column_id (GTK_TREE_SORTABLE (model),
 857                                                 &real_sort_column_id,
 858                                                 &real_order) &&
 859           (real_sort_column_id == tree_column->sort_column_id))
 860         {
 861           gtk_tree_view_column_set_sort_indicator (tree_column, TRUE);
 862           gtk_tree_view_column_set_sort_order (tree_column, real_order);
 863
 864           return;
 865         }
 866     }
 867 }
 868
 869
 870 /* Exported Private Functions.
 871  * These should only be called by gtktreeview.c or gtktreeviewcolumn.c
 872  */
 873
 874 void
 875 _gtk_tree_view_column_realize_button (GtkTreeViewColumn *column)
 876 {
 877   GtkTreeView *tree_view;
 878   GdkWindowAttr attr;
 879   guint attributes_mask;
 880
 881   tree_view = (GtkTreeView *)column->tree_view;
 882
 883   g_return_if_fail (tree_view != NULL);
 884   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
 885   g_return_if_fail (GTK_WIDGET_REALIZED (tree_view));
 886   g_return_if_fail (tree_view->priv->header_window != NULL);
 887   g_return_if_fail (column->button != NULL);
 888
 889   gtk_widget_set_parent_window (column->button, tree_view->priv->header_window);
 890
 891   if (column->visible)
 892     gtk_widget_show (column->button);
 893
 894   attr.window_type = GDK_WINDOW_CHILD;
 895   attr.wclass = GDK_INPUT_ONLY;
 896   attr.visual = gtk_widget_get_visual (GTK_WIDGET (tree_view));
 897   attr.colormap = gtk_widget_get_colormap (GTK_WIDGET (tree_view));
 898   attr.event_mask = gtk_widget_get_events (GTK_WIDGET (tree_view));
 899   attr.event_mask = (GDK_BUTTON_PRESS_MASK |
 900                      GDK_BUTTON_RELEASE_MASK |
 901                      GDK_POINTER_MOTION_MASK |
 902                      GDK_POINTER_MOTION_HINT_MASK |
 903                      GDK_KEY_PRESS_MASK);
 904   attributes_mask = GDK_WA_CURSOR | GDK_WA_X | GDK_WA_Y;
 905   attr.cursor = gdk_cursor_new (GDK_SB_H_DOUBLE_ARROW);
 906   tree_view->priv->cursor_drag = attr.cursor;
 907
 908   attr.y = 0;
 909   attr.width = TREE_VIEW_DRAG_WIDTH;
 910   attr.height = tree_view->priv->header_height;
 911
 912   attr.x = (column->button->allocation.x + column->button->allocation.width) - 3;
 913
 914   column->window = gdk_window_new (tree_view->priv->header_window,
 915                                    &attr, attributes_mask);
 916   gdk_window_set_user_data (column->window, tree_view);
 917
 918   gtk_tree_view_column_update_button (column);
 919 }
 920
 921 void
 922 _gtk_tree_view_column_unrealize_button (GtkTreeViewColumn *column)
 923 {
 924   g_return_if_fail (column != NULL);
 925   g_return_if_fail (column->window != NULL);
 926
 927   gdk_window_set_user_data (column->window, NULL);
 928   gdk_window_destroy (column->window);
 929   column->window = NULL;
 930 }
 931
 932 void
 933 _gtk_tree_view_column_set_tree_view (GtkTreeViewColumn *column,
 934                                      GtkTreeView       *tree_view)
 935 {
 936   g_assert (column->tree_view == NULL);
 937
 938   column->tree_view = GTK_WIDGET (tree_view);
 939   gtk_tree_view_column_create_button (column);
 940
 941   column->property_changed_signal =
 942           g_signal_connect_data (GTK_OBJECT (tree_view),
 943                                  "notify::model",
 944                                  GTK_SIGNAL_FUNC (gtk_tree_view_column_setup_sort_column_id_callback),
 945                                  column, NULL, TRUE, FALSE);
 946
 947   gtk_tree_view_column_setup_sort_column_id_callback (column);
 948 }
 949
 950 void
 951 _gtk_tree_view_column_unset_tree_view (GtkTreeViewColumn *column)
 952 {
 953   if (column->tree_view && column->button)
 954     {
 955       gtk_container_remove (GTK_CONTAINER (column->tree_view), column->button);
 956     }
 957   if (column->property_changed_signal)
 958     {
 959       g_signal_handler_disconnect (G_OBJECT (column->tree_view), column->property_changed_signal);
 960       column->property_changed_signal = 0;
 961     }
 962
 963   if (column->sort_column_changed_signal)
 964     {
 965       g_signal_handler_disconnect (G_OBJECT (column), column->sort_column_changed_signal);
 966       column->sort_column_changed_signal = 0;
 967     }
 968
 969   column->tree_view = NULL;
 970   column->button = NULL;
 971 }
 972
 973 void
 974 _gtk_tree_view_column_set_width (GtkTreeViewColumn *tree_column,
 975                                  gint               width)
 976 {
 977   if (tree_column->min_width != -1 &&
 978       width <= tree_column->min_width)
 979     width = tree_column->min_width;
 980   else if (tree_column->max_width != -1 &&
 981            width > tree_column->max_width)
 982     width = tree_column->max_width;
 983
 984   if (tree_column->width == width)
 985     return;
 986
 987   tree_column->width = width;
 988
 989   g_object_notify (G_OBJECT (tree_column), "width");
 990
 991   if (tree_column->tree_view != NULL)
 992     gtk_widget_queue_resize (tree_column->tree_view);
 993
 994 }
 995
 996 /* Public Functions */
 997
 998
 999 /**
1000  * gtk_tree_view_column_new:
1001  *
1002  * Creates a new #GtkTreeViewColumn.
1003  *
1004  * Return value: A newly created #GtkTreeViewColumn.
1005  **/
1006 GtkTreeViewColumn *
1007 gtk_tree_view_column_new (void)
1008 {
1009   GtkTreeViewColumn *tree_column;
1010
1011   tree_column = GTK_TREE_VIEW_COLUMN (gtk_type_new (GTK_TYPE_TREE_VIEW_COLUMN));
1012
1013   return tree_column;
1014 }
1015
1016 /**
1017  * gtk_tree_view_column_new_with_attributes:
1018  * @title: The title to set the header to.
1019  * @cell: The #GtkCellRenderer.
1020  * @Varargs: A NULL terminated list of attributes.
1021  *
1022  * Creates a new #GtkTreeViewColumn with a number of default values.  This is
1023  * equivalent to calling @gtk_tree_view_column_set_title,
1024  * @gtk_tree_view_column_set_cell_renderer, and
1025  * @gtk_tree_view_column_set_attributes on the newly created #GtkTreeViewColumn.
1026  *
1027  * Return value: A newly created #GtkTreeViewColumn.
1028  **/
1029 GtkTreeViewColumn *
1030 gtk_tree_view_column_new_with_attributes (const gchar     *title,
1031                                           GtkCellRenderer *cell,
1032                                           ...)
1033 {
1034   GtkTreeViewColumn *retval;
1035   va_list args;
1036
1037   retval = gtk_tree_view_column_new ();
1038
1039   gtk_tree_view_column_set_title (retval, title);
1040   gtk_tree_view_column_set_cell_renderer (retval, cell);
1041
1042   va_start (args, cell);
1043   gtk_tree_view_column_set_attributesv (retval, args);
1044   va_end (args);
1045
1046   return retval;
1047 }
1048
1049 /**
1050  * gtk_tree_view_column_set_cell_renderer:
1051  * @tree_column: A #GtkTreeViewColumn.
1052  * @cell: The #GtkCellRenderer, or NULL.
1053  *
1054  * Sets the cell renderer of the @tree_column.  If there is a cell
1055  * renderer already set, then it is removed.  If @cell is NULL, then
1056  * the cell renderer is unset.
1057  **/
1058 void
1059 gtk_tree_view_column_set_cell_renderer (GtkTreeViewColumn *tree_column,
1060                                         GtkCellRenderer   *cell)
1061 {
1062   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
1063
1064   if (cell)
1065     g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
1066
1067   if (cell)
1068     g_object_ref (G_OBJECT (cell));
1069
1070   if (tree_column->cell)
1071     g_object_unref (G_OBJECT (tree_column->cell));
1072
1073   tree_column->cell = cell;
1074
1075   if (tree_column->tree_view)
1076     {
1077       tree_column->dirty = TRUE;
1078       gtk_widget_queue_resize (tree_column->tree_view);
1079     }
1080
1081   g_object_notify (G_OBJECT (tree_column), "cell_renderer");
1082 }
1083
1084 /**
1085  * gtk_tree_view_column_get_cell_renderer:
1086  * @tree_column: a #GtkTreeViewColumn
1087  *
1088  * Gets the value set with gtk_tree_view_column_set_cell_renderer().
1089  *
1090  * Return value: cell renderer for the column, or %NULL if unset
1091  **/
1092 GtkCellRenderer*
1093 gtk_tree_view_column_get_cell_renderer (GtkTreeViewColumn *tree_column)
1094 {
1095   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), NULL);
1096
1097   return tree_column->cell;
1098 }
1099
1100 /**
1101  * gtk_tree_view_column_add_attribute:
1102  * @tree_column: A #GtkTreeViewColumn.
1103  * @attribute: An attribute on the columns cell
1104  * @column: The column position on the model to get the attribute from.
1105  *
1106  * Adds an attribute mapping to the list in @tree_column.  The @column is the
1107  * column position on the model to get a value from, and the @attribute is the
1108  * parameter on the @tree_column's cell renderer to set that value to.
1109  **/
1110 void
1111 gtk_tree_view_column_add_attribute (GtkTreeViewColumn *tree_column,
1112                                     const gchar       *attribute,
1113                                     gint               column)
1114 {
1115   g_return_if_fail (tree_column != NULL);
1116   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
1117
1118   tree_column->attributes = g_slist_prepend (tree_column->attributes,
1119                                              GINT_TO_POINTER (column));
1120   tree_column->attributes = g_slist_prepend (tree_column->attributes,
1121                                              g_strdup (attribute));
1122
1123   if (tree_column->tree_view)
1124     {
1125       tree_column->dirty = TRUE;
1126       gtk_widget_queue_resize (tree_column->tree_view);
1127     }
1128
1129 }
1130
1131 static void
1132 gtk_tree_view_column_set_attributesv (GtkTreeViewColumn *tree_column,
1133                                       va_list            args)
1134 {
1135   gchar *attribute;
1136   gint column;
1137
1138   g_return_if_fail (tree_column != NULL);
1139   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
1140
1141   attribute = va_arg (args, gchar *);
1142
1143   gtk_tree_view_column_clear_attributes (tree_column);
1144
1145   while (attribute != NULL)
1146     {
1147       column = va_arg (args, gint);
1148       gtk_tree_view_column_add_attribute (tree_column,
1149                                           attribute,
1150                                           column);
1151       attribute = va_arg (args, gchar *);
1152     }
1153 }
1154
1155 /**
1156  * gtk_tree_view_column_set_attributes:
1157  * @tree_column: A #GtkTreeViewColumn.
1158  * @Varargs: A NULL terminated listing of attributes.
1159  *
1160  * Sets the attributes in the list as the attributes of @tree_column.
1161  * The attributes should be in attribute/column order, as in
1162  * @gtk_tree_view_column_add_attribute. All existing attributes
1163  * are removed, and replaced with the new attributes.
1164  **/
1165 void
1166 gtk_tree_view_column_set_attributes (GtkTreeViewColumn *tree_column,
1167                                      ...)
1168 {
1169   va_list args;
1170
1171   g_return_if_fail (tree_column != NULL);
1172   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
1173
1174   va_start (args, tree_column);
1175
1176   gtk_tree_view_column_set_attributesv (tree_column, args);
1177
1178   va_end (args);
1179 }
1180
1181
1182 /**
1183  * gtk_tree_view_column_set_cell_data_func:
1184  * @tree_column: A #GtkTreeViewColumn
1185  * @func: The #GtkTreeViewColumnFunc to use.
1186  * @func_data: The user data for @func.
1187  * @destroy: The destroy notification for @func_data
1188  *
1189  * Sets the #GtkTreeViewColumnFunc to use for the column.  This function is used
1190  * instead of the standard attributes mapping for setting the column value, and
1191  * should set the value of @tree_column 's cell renderer as appropriate.  @func
1192  * may be NULL to remove an older one.
1193  **/
1194 void
1195 gtk_tree_view_column_set_cell_data_func (GtkTreeViewColumn   *tree_column,
1196                                          GtkTreeCellDataFunc  func,
1197                                          gpointer             func_data,
1198                                          GtkDestroyNotify     destroy)
1199 {
1200   g_return_if_fail (tree_column != NULL);
1201   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
1202
1203   if (func == tree_column->func &&
1204       func_data == tree_column->func_data &&
1205       destroy == tree_column->destroy)
1206     return;
1207
1208   if (tree_column->func_data && tree_column->destroy)
1209     (tree_column->destroy) (tree_column->func_data);
1210
1211   tree_column->func = func;
1212   tree_column->func_data = func_data;
1213   tree_column->destroy = destroy;
1214
1215   if (tree_column->tree_view)
1216     {
1217       tree_column->dirty = TRUE;
1218       gtk_widget_queue_resize (tree_column->tree_view);
1219     }
1220 }
1221
1222
1223 /**
1224  * gtk_tree_view_column_clear_attributes:
1225  * @tree_column: a #GtkTreeViewColumn
1226  *
1227  * Clears all existing attributes previously set with
1228  * gtk_tree_view_column_set_attributes().
1229  **/
1230 void
1231 gtk_tree_view_column_clear_attributes (GtkTreeViewColumn *tree_column)
1232 {
1233   GSList *list;
1234
1235   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
1236
1237   list = tree_column->attributes;
1238
1239   while (list && list->next)
1240     {
1241       g_free (list->data);
1242       list = list->next->next;
1243     }
1244   g_slist_free (tree_column->attributes);
1245   tree_column->attributes = NULL;
1246
1247   if (tree_column->tree_view)
1248     {
1249       tree_column->dirty = TRUE;
1250       gtk_widget_queue_resize (tree_column->tree_view);
1251     }
1252 }
1253
1254 /* Options for manipulating the columns */
1255
1256 /**
1257  * gtk_tree_view_column_set_visible:
1258  * @tree_column: A #GtkTreeViewColumn.
1259  * @visible: TRUE if the @tree_column is visible.
1260  *
1261  * Sets the visibility of @tree_column.
1262  **/
1263 void
1264 gtk_tree_view_column_set_visible (GtkTreeViewColumn *tree_column,
1265                                   gboolean           visible)
1266 {
1267   g_return_if_fail (tree_column != NULL);
1268   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
1269
1270   visible = !! visible;
1271
1272   if (tree_column->visible == visible)
1273     return;
1274
1275   tree_column->visible = visible;
1276
1277   gtk_tree_view_column_update_button (tree_column);
1278   g_object_notify (G_OBJECT (tree_column), "visible");
1279 }
1280
1281 /**
1282  * gtk_tree_view_column_get_visible:
1283  * @tree_column: A #GtkTreeViewColumn.
1284  *
1285  * Returns TRUE if @tree_column is visible.
1286  *
1287  * Return value: whether the column is visible or not.  If it is visible, then
1288  * the tree will show the column.
1289  **/
1290 gboolean
1291 gtk_tree_view_column_get_visible (GtkTreeViewColumn *tree_column)
1292 {
1293   g_return_val_if_fail (tree_column != NULL, FALSE);
1294   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), FALSE);
1295
1296   return tree_column->visible;
1297 }
1298
1299 /**
1300  * gtk_tree_view_column_set_sizing:
1301  * @tree_column: A #GtkTreeViewColumn.
1302  * @type: The #GtkTreeViewColumnSizing.
1303  *
1304  * Sets the growth behavior of @tree_column to @type.
1305  **/
1306 void
1307 gtk_tree_view_column_set_sizing (GtkTreeViewColumn       *tree_column,
1308                                  GtkTreeViewColumnSizing  type)
1309 {
1310   g_return_if_fail (tree_column != NULL);
1311   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
1312
1313   if (type == tree_column->column_type)
1314     return;
1315
1316   if (tree_column->column_type == GTK_TREE_VIEW_COLUMN_AUTOSIZE &&
1317       tree_column->requested_width != -1)
1318     {
1319       gtk_tree_view_column_set_sizing (tree_column, tree_column->requested_width);
1320     }
1321   tree_column->column_type = type;
1322
1323   gtk_tree_view_column_update_button (tree_column);
1324
1325   if (type != GTK_TREE_VIEW_COLUMN_AUTOSIZE)
1326   g_object_notify (G_OBJECT (tree_column), "sizing");
1327 }
1328
1329 /**
1330  * gtk_tree_view_column_get_sizing:
1331  * @tree_column: A #GtkTreeViewColumn.
1332  *
1333  * Returns the current type of @tree_column.
1334  *
1335  * Return value: The type of @tree_column.
1336  **/
1337 gint
1338 gtk_tree_view_column_get_sizing (GtkTreeViewColumn *tree_column)
1339 {
1340   g_return_val_if_fail (tree_column != NULL, 0);
1341   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), 0);
1342
1343   return tree_column->column_type;
1344 }
1345
1346 /**
1347  * gtk_tree_view_column_get_size:
1348  * @tree_column: A #GtkTreeViewColumn.
1349  *
1350  * Returns the current size of the @tree_column in pixels.
1351  *
1352  * Return value: The current size of the @tree_column.
1353  **/
1354 gint
1355 gtk_tree_view_column_get_size (GtkTreeViewColumn *tree_column)
1356 {
1357   g_return_val_if_fail (tree_column != NULL, 0);
1358   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), 0);
1359
1360   return tree_column->width;
1361 }
1362
1363 /**
1364  * gtk_tree_view_column_set_width:
1365  * @tree_column: A #GtkTreeViewColumn.
1366  * @width: The size to set the @tree_column to.
1367  *
1368  * Sets the size of the column in pixels, unless the the column type is
1369  * #GTK_TREE_VIEW_COLUMN_AUTOSIZE.  In this case, the value is discarded as the
1370  * size of the column is based on the calculated width of the column. The
1371  * width is clamped to the min/max width for the column.
1372  **/
1373 void
1374 gtk_tree_view_column_set_width (GtkTreeViewColumn *tree_column,
1375                                 gint               width)
1376 {
1377   g_return_if_fail (tree_column != NULL);
1378   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
1379   g_return_if_fail (width > 0);
1380
1381   if (tree_column->column_type == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
1382     return;
1383
1384   tree_column->requested_width = width;
1385   _gtk_tree_view_column_set_width (tree_column, width);
1386 }
1387
1388 /**
1389  * gtk_tree_view_column_get_width:
1390  * @tree_column: a #GtkTreeViewColumn
1391  *
1392  * Gets the value set by gtk_tree_view_column_set_width().
1393  *
1394  * Return value: the width of the column
1395  **/
1396 gint
1397 gtk_tree_view_column_get_width (GtkTreeViewColumn *tree_column)
1398 {
1399   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), 0);
1400
1401   return tree_column->width;
1402 }
1403
1404 /**
1405  * gtk_tree_view_column_set_min_width:
1406  * @tree_column: A #GtkTreeViewColumn.
1407  * @min_width: The minimum width of the column in pixels, or -1.
1408  *
1409  * Sets the minimum width of the @tree_column.  If @min_width is -1, then the
1410  * minimum width is unset.
1411  **/
1412 void
1413 gtk_tree_view_column_set_min_width (GtkTreeViewColumn *tree_column,
1414                                     gint               min_width)
1415 {
1416   gint real_min_width;
1417
1418   g_return_if_fail (tree_column != NULL);
1419   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
1420   g_return_if_fail (min_width >= -1);
1421
1422   if (min_width == tree_column->min_width)
1423     return;
1424
1425   if (tree_column->tree_view == NULL)
1426     {
1427       tree_column->min_width = min_width;
1428       return;
1429     }
1430
1431   real_min_width = (tree_column->min_width == -1) ?
1432     tree_column->button->requisition.width : tree_column->min_width;
1433
1434   /* We want to queue a resize if the either the old min_size or the
1435    * new min_size determined the size of the column */
1436   if (GTK_WIDGET_REALIZED (tree_column->tree_view))
1437     {
1438       if ((tree_column->min_width > tree_column->width) ||
1439           (tree_column->min_width == -1 &&
1440            tree_column->button->requisition.width > tree_column->width) ||
1441           (min_width > tree_column->width) ||
1442           (min_width == -1 &&
1443            tree_column->button->requisition.width > tree_column->width))
1444         gtk_widget_queue_resize (tree_column->tree_view);
1445     }
1446
1447   if (tree_column->max_width != -1 && tree_column->max_width < real_min_width)
1448     tree_column->max_width = real_min_width;
1449
1450   tree_column->min_width = min_width;
1451
1452   g_object_notify (G_OBJECT (tree_column), "min_width");
1453 }
1454
1455 /**
1456  * gtk_tree_view_column_get_min_width:
1457  * @tree_column: A #GtkTreeViewColumn.
1458  *
1459  * Returns the minimum width in pixels of the @tree_column, or -1 if no minimum
1460  * width is set.
1461  *
1462  * Return value: The minimum width of the @tree_column.
1463  **/
1464 gint
1465 gtk_tree_view_column_get_min_width (GtkTreeViewColumn *tree_column)
1466 {
1467   g_return_val_if_fail (tree_column != NULL, -1);
1468   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), -1);
1469
1470   return tree_column->min_width;
1471 }
1472
1473 /**
1474  * gtk_tree_view_column_set_max_width:
1475  * @tree_column: A #GtkTreeViewColumn.
1476  * @max_width: The maximum width of the column in pixels, or -1.
1477  *
1478  * Sets the maximum width of the @tree_column.  If @max_width is -1, then the
1479  * maximum width is unset.
1480  **/
1481 void
1482 gtk_tree_view_column_set_max_width (GtkTreeViewColumn *tree_column,
1483                                     gint               max_width)
1484 {
1485   gint real_max_width;
1486
1487   g_return_if_fail (tree_column != NULL);
1488   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
1489   g_return_if_fail (max_width >= -1);
1490
1491   if (max_width == tree_column->max_width)
1492     return;
1493
1494   if (tree_column->tree_view == NULL)
1495     {
1496       tree_column->max_width = max_width;
1497       return;
1498     }
1499
1500   real_max_width = tree_column->max_width == -1 ?
1501     tree_column->button->requisition.width : tree_column->max_width;
1502
1503   if (tree_column->tree_view &&
1504       GTK_WIDGET_REALIZED (tree_column->tree_view) &&
1505       ((tree_column->max_width < tree_column->width) ||
1506        (max_width != -1 && max_width < tree_column->width)))
1507     gtk_widget_queue_resize (tree_column->tree_view);
1508
1509   tree_column->max_width = max_width;
1510
1511   if (real_max_width > max_width)
1512     tree_column->max_width = max_width;
1513
1514   g_object_notify (G_OBJECT (tree_column), "max_width");
1515 }
1516
1517 /**
1518  * gtk_tree_view_column_get_max_width:
1519  * @tree_column: A #GtkTreeViewColumn.
1520  *
1521  * Returns the maximum width in pixels of the @tree_column, or -1 if no maximum
1522  * width is set.
1523  *
1524  * Return value: The maximum width of the @tree_column.
1525  **/
1526 gint
1527 gtk_tree_view_column_get_max_width (GtkTreeViewColumn *tree_column)
1528 {
1529   g_return_val_if_fail (tree_column != NULL, -1);
1530   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), -1);
1531
1532   return tree_column->max_width;
1533 }
1534
1535 /**
1536  * gtk_tree_view_column_clicked:
1537  * @tree_column: a #GtkTreeViewColumn
1538  *
1539  * Emits the "clicked" signal on the column.  This function will only work if
1540  * the user could have conceivably clicked on the button.
1541  **/
1542 void
1543 gtk_tree_view_column_clicked (GtkTreeViewColumn *tree_column)
1544 {
1545   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
1546
1547   if (tree_column->visible &&
1548       tree_column->button &&
1549       tree_column->clickable)
1550     gtk_button_clicked (GTK_BUTTON (tree_column->button));
1551 }
1552
1553 /**
1554  * gtk_tree_view_column_set_title:
1555  * @tree_column: A #GtkTreeViewColumn.
1556  * @title: The title of the @tree_column.
1557  *
1558  * Sets the title of the @tree_column.  If a custom widget has been set, then
1559  * this value is ignored.
1560  **/
1561 void
1562 gtk_tree_view_column_set_title (GtkTreeViewColumn *tree_column,
1563                                 const gchar       *title)
1564 {
1565   g_return_if_fail (tree_column != NULL);
1566   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
1567
1568   g_free (tree_column->title);
1569   if (title)
1570     tree_column->title = g_strdup (title);
1571   else
1572     tree_column->title = NULL;
1573
1574   gtk_tree_view_column_update_button (tree_column);
1575   g_object_notify (G_OBJECT (tree_column), "title");
1576 }
1577
1578 /**
1579  * gtk_tree_view_column_get_title:
1580  * @tree_column: A #GtkTreeViewColumn.
1581  *
1582  * Returns the title of the widget.  This value should not be modified.
1583  *
1584  * Return value: the title of the column.
1585  **/
1586 G_CONST_RETURN gchar *
1587 gtk_tree_view_column_get_title (GtkTreeViewColumn *tree_column)
1588 {
1589   g_return_val_if_fail (tree_column != NULL, NULL);
1590   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), NULL);
1591
1592   return tree_column->title;
1593 }
1594
1595 /**
1596  * gtk_tree_view_column_set_clickable:
1597  * @tree_column: A #GtkTreeViewColumn.
1598  * @clickable: TRUE if the header is active.
1599  *
1600  * Sets the header to be active if @active is TRUE.  When the header is active,
1601  * then it can take keyboard focus, and can be clicked.
1602  **/
1603 void
1604 gtk_tree_view_column_set_clickable (GtkTreeViewColumn *tree_column,
1605                                     gboolean           clickable)
1606 {
1607   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
1608
1609   if (tree_column->clickable == (clickable?TRUE:FALSE))
1610     return;
1611
1612   tree_column->clickable = (clickable?TRUE:FALSE);
1613   gtk_tree_view_column_update_button (tree_column);
1614   g_object_notify (G_OBJECT (tree_column), "clickable");
1615 }
1616
1617 /**
1618  * gtk_tree_view_column_get_clickable:
1619  * @tree_column: a #GtkTreeViewColumn
1620  *
1621  * Returns %TRUE if the user can click on the header for the column.
1622  *
1623  * Return value: whether the user can click the column header
1624  **/
1625 gboolean
1626 gtk_tree_view_column_get_clickable (GtkTreeViewColumn *tree_column)
1627 {
1628   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), FALSE);
1629
1630   return tree_column->clickable;
1631 }
1632
1633 /**
1634  * gtk_tree_view_column_set_widget:
1635  * @tree_column: A #GtkTreeViewColumn.
1636  * @widget: A child #GtkWidget, or NULL.
1637  *
1638  * Sets the widget in the header to be @widget.  If widget is NULL, then the
1639  * header button is set with a #GtkLabel set to the title of @tree_column.
1640  **/
1641 void
1642 gtk_tree_view_column_set_widget (GtkTreeViewColumn *tree_column,
1643                                  GtkWidget         *widget)
1644 {
1645   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
1646   g_return_if_fail (widget == NULL || GTK_IS_WIDGET (widget));
1647
1648   if (widget)
1649     {
1650       gtk_object_ref (GTK_OBJECT (widget));
1651       gtk_object_sink (GTK_OBJECT (widget));
1652     }
1653
1654   if (tree_column->child)
1655     gtk_object_unref (GTK_OBJECT (tree_column->child));
1656
1657   tree_column->child = widget;
1658   gtk_tree_view_column_update_button (tree_column);
1659   g_object_notify (G_OBJECT (tree_column), "widget");
1660 }
1661
1662 /**
1663  * gtk_tree_view_column_get_widget:
1664  * @tree_column: A #GtkTreeViewColumn.
1665  *
1666  * Returns the #GtkWidget in the button in the column header.  If a custom
1667  * widget has not been set, then this will be a #GtkAlignment with a #GtkLabel
1668  * in it.
1669  *
1670  * Return value: The #GtkWidget in the column header.
1671  **/
1672 GtkWidget *
1673 gtk_tree_view_column_get_widget (GtkTreeViewColumn *tree_column)
1674 {
1675   g_return_val_if_fail (tree_column != NULL, NULL);
1676   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), NULL);
1677
1678   return tree_column->child;
1679 }
1680
1681 /**
1682  * gtk_tree_view_column_set_alignment:
1683  * @tree_column: A #GtkTreeViewColumn.
1684  * @xalign: alignment (0.0 for left, 0.5 for center, 1.0 for right)
1685  *
1686  * Sets the alignment of the title or custom widget inside the column header.
1687  **/
1688 void
1689 gtk_tree_view_column_set_alignment (GtkTreeViewColumn *tree_column,
1690                                     gfloat             xalign)
1691 {
1692   g_return_if_fail (tree_column != NULL);
1693   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
1694
1695   if (tree_column->xalign == xalign)
1696     return;
1697
1698   tree_column->xalign = xalign;
1699   gtk_tree_view_column_update_button (tree_column);
1700   g_object_notify (G_OBJECT (tree_column), "alignment");
1701 }
1702
1703 /**
1704  * gtk_tree_view_column_get_alignment:
1705  * @tree_column: A #GtkTreeViewColumn.
1706  *
1707  * Returns the current x alignment of @tree_column.  This value can range
1708  * between 0.0 and 1.0.
1709  *
1710  * Return value: The current alignent of @tree_column.
1711  **/
1712 gfloat
1713 gtk_tree_view_column_get_alignment (GtkTreeViewColumn *tree_column)
1714 {
1715   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), 0.5);
1716
1717   return tree_column->xalign;
1718 }
1719
1720 void
1721 gtk_tree_view_column_set_reorderable (GtkTreeViewColumn *tree_column,
1722                                       gboolean           reorderable)
1723 {
1724   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
1725
1726   /*  if (reorderable)
1727       gtk_tree_view_column_set_clickable (tree_column, TRUE);*/
1728
1729   if (tree_column->reorderable == (reorderable?TRUE:FALSE))
1730     return;
1731
1732   tree_column->reorderable = (reorderable?TRUE:FALSE);
1733   gtk_tree_view_column_update_button (tree_column);
1734   g_object_notify (G_OBJECT (tree_column), "reorderable");
1735 }
1736
1737 gboolean
1738 gtk_tree_view_column_get_reorderable (GtkTreeViewColumn *tree_column)
1739 {
1740   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), FALSE);
1741
1742   return tree_column->reorderable;
1743 }
1744
1745
1746 /**
1747  * gtk_tree_view_column_set_sort_column_id:
1748  * @tree_column: a #GtkTreeViewColumn
1749  * @sort_column_id: The sort_column_id of the model to sort on.
1750  *
1751  * Sets the sort_column_id that the column sorts on.  Doing so makes headers
1752  * clickable.
1753  **/
1754 void
1755 gtk_tree_view_column_set_sort_column_id (GtkTreeViewColumn *tree_column,
1756                                          gint               sort_column_id)
1757 {
1758   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
1759   g_return_if_fail (sort_column_id >= 0);
1760
1761   if (tree_column->sort_column_id == sort_column_id)
1762     return;
1763
1764   tree_column->sort_column_id = sort_column_id;
1765
1766   /* Handle unsetting the id */
1767   if (sort_column_id == -1)
1768     {
1769       if (tree_column->sort_clicked_signal)
1770         {
1771           g_signal_handler_disconnect (G_OBJECT (tree_column), tree_column->sort_clicked_signal);
1772           tree_column->sort_clicked_signal = 0;
1773         }
1774
1775       if (tree_column->sort_column_changed_signal)
1776         {
1777           g_signal_handler_disconnect (G_OBJECT (tree_column), tree_column->sort_column_changed_signal);
1778           tree_column->sort_column_changed_signal = 0;
1779         }
1780
1781       gtk_tree_view_column_set_sort_order (tree_column, GTK_TREE_SORT_ASCENDING);
1782       gtk_tree_view_column_set_sort_indicator (tree_column, FALSE);
1783       return;
1784     }
1785
1786   gtk_tree_view_column_set_clickable (tree_column, TRUE);
1787
1788   if (! tree_column->sort_clicked_signal)
1789     tree_column->sort_clicked_signal = g_signal_connectc (G_OBJECT (tree_column),
1790                                                           "clicked",
1791                                                           G_CALLBACK (gtk_tree_view_column_sort),
1792                                                           NULL, FALSE);
1793
1794   gtk_tree_view_column_setup_sort_column_id_callback (tree_column);
1795 }
1796
1797 /**
1798  * gtk_tree_view_column_set_sort_indicator:
1799  * @tree_column: a #GtkTreeViewColumn
1800  * @setting: %TRUE to display an indicator that the column is sorted
1801  *
1802  * Call this function with a @setting of %TRUE to display an arrow in
1803  * the header button indicating the column is sorted. Call
1804  * gtk_tree_view_column_set_sort_order() to change the direction of
1805  * the arrow.
1806  *
1807  **/
1808 void
1809 gtk_tree_view_column_set_sort_indicator (GtkTreeViewColumn     *tree_column,
1810                                          gboolean               setting)
1811 {
1812   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
1813
1814   setting = setting != FALSE;
1815
1816   if (setting == tree_column->show_sort_indicator)
1817     return;
1818
1819   tree_column->show_sort_indicator = setting;
1820   gtk_tree_view_column_update_button (tree_column);
1821   g_object_notify (G_OBJECT (tree_column), "sort_indicator");
1822 }
1823
1824 /**
1825  * gtk_tree_view_column_get_sort_indicator:
1826  * @tree_column: a #GtkTreeViewColumn
1827  *
1828  * Gets the value set by gtk_tree_view_column_set_sort_indicator().
1829  *
1830  * Return value: whether the sort indicator arrow is displayed
1831  **/
1832 gboolean
1833 gtk_tree_view_column_get_sort_indicator  (GtkTreeViewColumn     *tree_column)
1834 {
1835   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), FALSE);
1836
1837   return tree_column->show_sort_indicator;
1838 }
1839
1840 /**
1841  * gtk_tree_view_column_set_sort_order:
1842  * @tree_column: a #GtkTreeViewColumn
1843  * @order: sort order that the sort indicator should indicate
1844  *
1845  * Changes the appearance of the sort indicator. (This <emphasis>does
1846  * not</emphasis> actually sort the model.  Use
1847  * gtk_tree_view_column_set_sort_column_id() if you want automatic sorting
1848  * support.  This function is primarily for custom sorting behavior, and should
1849  * be used in conjunction with #gtk_tree_sortable_set_sort_column() to do
1850  * that. For custom models, the mechanism will vary. The sort indicator changes
1851  * direction to indicate normal sort or reverse sort. Note that you must have
1852  * the sort indicator enabled to see anything when calling this function; see
1853  * gtk_tree_view_column_set_sort_indicator().
1854  *
1855  **/
1856 void
1857 gtk_tree_view_column_set_sort_order      (GtkTreeViewColumn     *tree_column,
1858                                           GtkTreeSortOrder       order)
1859 {
1860   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
1861
1862   if (order == tree_column->sort_order)
1863     return;
1864
1865   tree_column->sort_order = order;
1866   gtk_tree_view_column_update_button (tree_column);
1867   g_object_notify (G_OBJECT (tree_column), "sort_order");
1868 }
1869
1870 /**
1871  * gtk_tree_view_column_get_sort_order:
1872  * @tree_column: a #GtkTreeViewColumn
1873  *
1874  * Gets the value set by gtk_tree_view_column_set_sort_order().
1875  *
1876  * Return value: the sort order the sort indicator is indicating
1877  **/
1878 GtkTreeSortOrder
1879 gtk_tree_view_column_get_sort_order      (GtkTreeViewColumn     *tree_column)
1880 {
1881   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), 0);
1882
1883   return tree_column->sort_order;
1884 }
1885
1886
1887
1888
1889 /**
1890  * gtk_tree_view_column_cell_set_cell_data:
1891  * @tree_column: A #GtkTreeViewColumn.
1892  * @tree_model: The #GtkTreeModel to to get the cell renderers attributes from.
1893  * @iter: The #GtkTreeIter to to get the cell renderer's attributes from.
1894  *
1895  * Sets the cell renderer based on the @tree_model and @tree_node.  That is, for
1896  * every attribute mapping in @tree_column, it will get a value from the set
1897  * column on the @tree_node, and use that value to set the attribute on the cell
1898  * renderer.  This is used primarily by the GtkTreeView.
1899  **/
1900 void
1901 gtk_tree_view_column_cell_set_cell_data (GtkTreeViewColumn *tree_column,
1902                                          GtkTreeModel      *tree_model,
1903                                          GtkTreeIter       *iter)
1904 {
1905   GSList *list;
1906   GValue value = { 0, };
1907   GObject *cell;
1908
1909   g_return_if_fail (tree_column != NULL);
1910   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
1911   g_return_if_fail (tree_column->cell != NULL);
1912
1913   if (tree_model == NULL)
1914     return;
1915
1916   cell = (GObject *) tree_column->cell;
1917   list = tree_column->attributes;
1918
1919   g_object_freeze_notify (cell);
1920
1921   while (list && list->next)
1922     {
1923       gtk_tree_model_get_value (tree_model, iter,
1924                                 GPOINTER_TO_INT (list->next->data),
1925                                 &value);
1926       g_object_set_property (cell, (gchar *) list->data, &value);
1927       g_value_unset (&value);
1928       list = list->next->next;
1929
1930     }
1931
1932   if (tree_column->func)
1933     (* tree_column->func) (tree_column, tree_column->cell, tree_model, iter, tree_column->func_data);
1934
1935   g_object_thaw_notify (cell);
1936 }
1937
1938 /**
1939  * gtk_tree_view_column_cell_get_size:
1940  * @tree_column: A #GtkTreeViewColumn.
1941  * @cell_area: The area a the column will be allocated, or %NULL
1942  * @x_offset: location to return x offset of cell relative to @cell_area, or %NULL
1943  * @y_offset: location to return y offset of cell relative to @cell_area, or %NULL
1944  * @width: location to return width needed to render a cell, or %NULL
1945  * @height: location to return height needed to render a cell, or %NULL
1946  *
1947  * Obtains the width and height needed to render the column.  This is used
1948  * primarily by the GtkTreeView.
1949  **/
1950 void
1951 gtk_tree_view_column_cell_get_size (GtkTreeViewColumn *tree_column,
1952                                     GdkRectangle      *cell_area,
1953                                     gint              *x_offset,
1954                                     gint              *y_offset,
1955                                     gint              *width,
1956                                     gint              *height)
1957 {
1958   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
1959
1960   gtk_cell_renderer_get_size (tree_column->cell,
1961                               tree_column->tree_view,
1962                               cell_area,
1963                               x_offset,
1964                               y_offset,
1965                               width,
1966                               height);
1967
1968 }
1969
1970 /**
1971  * gtk_tree_view_column_cell_render:
1972  * @tree_column: A #GtkTreeViewColumn.
1973  * @window: a #GdkDrawable to draw to
1974  * @background_area: entire cell area (including tree expanders and maybe padding on the sides)
1975  * @cell_area: area normally rendered by a cell renderer
1976  * @expose_area: area that actually needs updating
1977  * @flags: flags that affect rendering
1978  *
1979  * Renders the cell contained by #tree_column. This is used primarily by the
1980  * GtkTreeView.
1981  **/
1982 void
1983 gtk_tree_view_column_cell_render (GtkTreeViewColumn *tree_column,
1984                                   GdkWindow         *window,
1985                                   GdkRectangle      *background_area,
1986                                   GdkRectangle      *cell_area,
1987                                   GdkRectangle      *expose_area,
1988                                   guint              flags)
1989 {
1990   gboolean visible;
1991   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
1992
1993   g_object_get (G_OBJECT (tree_column->cell), "visible", &visible, NULL);
1994   if (visible)
1995     gtk_cell_renderer_render (tree_column->cell,
1996                               window,
1997                               tree_column->tree_view,
1998                               background_area,
1999                               cell_area,
2000                               expose_area,
2001                               flags);
2002 }
2003
2004 /**
2005  * gtk_tree_view_column_cell_event:
2006  * @tree_column: A #GtkTreeViewColumn.
2007  * @event: a #GdkEvent
2008  * @path_string: widget-dependent string representation of the event location; e.g. for #GtkTreeView, a string representation of #GtkTreePath
2009  * @background_area: background area as passed to gtk_cell_renderer_render()
2010  * @cell_area: cell area as passed to gtk_cell_renderer_render()
2011  * @flags: render flags
2012  *
2013  * Handles an event.  This is used primarily by the GtkTreeView.
2014  *
2015  * Return value: %TRUE if the event was consumed/handled
2016  **/
2017 gboolean
2018 gtk_tree_view_column_cell_event (GtkTreeViewColumn *tree_column,
2019                                  GdkEvent          *event,
2020                                  gchar             *path_string,
2021                                  GdkRectangle      *background_area,
2022                                  GdkRectangle      *cell_area,
2023                                  guint              flags)
2024 {
2025   gboolean visible, can_activate;
2026
2027   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), FALSE);
2028
2029   g_object_get (G_OBJECT (tree_column->cell),
2030                 "visible", &visible,
2031                 "can_activate", &can_activate,
2032                 NULL);
2033   if (visible && can_activate)
2034     {
2035       if (gtk_cell_renderer_event (tree_column->cell,
2036                                    event,
2037                                    tree_column->tree_view,
2038                                    path_string,
2039                                    background_area,
2040                                    cell_area,
2041                                    flags))
2042         return TRUE;
2043
2044     }
2045   return FALSE;
2046 }