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   PROP_VISIBLE,
  36   PROP_SIZING,
  37   PROP_WIDTH,
  38   PROP_MIN_WIDTH,
  39   PROP_MAX_WIDTH,
  40   PROP_TITLE,
  41   PROP_CLICKABLE,
  42   PROP_WIDGET,
  43   PROP_ALIGNMENT,
  44   PROP_REORDERABLE,
  45   PROP_SORT_INDICATOR,
  46   PROP_SORT_ORDER
  47 };
  48
  49 enum
  50 {
  51   CLICKED,
  52   LAST_SIGNAL
  53 };
  54
  55 typedef struct _GtkTreeViewColumnCellInfo GtkTreeViewColumnCellInfo;
  56 struct _GtkTreeViewColumnCellInfo
  57 {
  58   GtkCellRenderer *cell;
  59   GSList *attributes;
  60   GtkTreeCellDataFunc func;
  61   gpointer func_data;
  62   GtkDestroyNotify destroy;
  63   guint16 padding;
  64   guint expand : 1;
  65   guint fill : 1;
  66   guint pack : 1;
  67 };
  68
  69 /* Type methods */
  70 static void gtk_tree_view_column_init                          (GtkTreeViewColumn       *tree_column);
  71 static void gtk_tree_view_column_class_init                    (GtkTreeViewColumnClass  *klass);
  72
  73 /* GObject methods */
  74 static void gtk_tree_view_column_set_property                  (GObject                 *object,
  75                                                                 guint                    prop_id,
  76                                                                 const GValue            *value,
  77                                                                 GParamSpec              *pspec);
  78 static void gtk_tree_view_column_get_property                  (GObject                 *object,
  79                                                                 guint                    prop_id,
  80                                                                 GValue                  *value,
  81                                                                 GParamSpec              *pspec);
  82 static void gtk_tree_view_column_finalize                      (GObject                 *object);
  83
  84 /* Button handling code */
  85 static void gtk_tree_view_column_create_button                 (GtkTreeViewColumn       *tree_column);
  86 static void gtk_tree_view_column_update_button                 (GtkTreeViewColumn       *tree_column);
  87
  88 /* Button signal handlers */
  89 static gint gtk_tree_view_column_button_event                  (GtkWidget               *widget,
  90                                                                 GdkEvent                *event,
  91                                                                 gpointer                 data);
  92 static void gtk_tree_view_column_button_realize                (GtkWidget               *widget,
  93                                                                 gpointer                 data);
  94 static void gtk_tree_view_column_button_clicked                (GtkWidget               *widget,
  95                                                                 gpointer                 data);
  96
  97 /* Property handlers */
  98 static void gtk_tree_view_model_sort_column_changed            (GtkTreeSortable         *sortable,
  99                                                                 GtkTreeViewColumn       *tree_column);
 100
 101 /* Internal functions */
 102 static void gtk_tree_view_column_sort                          (GtkTreeViewColumn       *tree_column,
 103                                                                 gpointer                 data);
 104 static void gtk_tree_view_column_setup_sort_column_id_callback (GtkTreeViewColumn       *tree_column);
 105 static void gtk_tree_view_column_set_attributesv               (GtkTreeViewColumn       *tree_column,
 106                                                                 GtkCellRenderer         *cell_renderer,
 107                                                                 va_list                  args);
 108 static GtkTreeViewColumnCellInfo *gtk_tree_view_column_get_cell_info (GtkTreeViewColumn *tree_column,
 109                                                                       GtkCellRenderer   *cell_renderer);
 110
 111
 112
 113 static GtkObjectClass *parent_class = NULL;
 114 static guint tree_column_signals[LAST_SIGNAL] = { 0 };
 115
 116
 117 GtkType
 118 gtk_tree_view_column_get_type (void)
 119 {
 120   static GtkType tree_column_type = 0;
 121
 122   if (!tree_column_type)
 123     {
 124       static const GTypeInfo tree_column_info =
 125       {
 126         sizeof (GtkTreeViewColumnClass),
 127         NULL,           /* base_init */
 128         NULL,           /* base_finalize */
 129         (GClassInitFunc) gtk_tree_view_column_class_init,
 130         NULL,           /* class_finalize */
 131         NULL,           /* class_data */
 132         sizeof (GtkTreeViewColumn),
 133         0,
 134         (GInstanceInitFunc) gtk_tree_view_column_init,
 135       };
 136
 137       tree_column_type = g_type_register_static (GTK_TYPE_OBJECT, "GtkTreeViewColumn", &tree_column_info, 0);
 138     }
 139
 140   return tree_column_type;
 141 }
 142
 143 static void
 144 gtk_tree_view_column_class_init (GtkTreeViewColumnClass *class)
 145 {
 146   GObjectClass *object_class;
 147
 148   object_class = (GObjectClass*) class;
 149
 150   parent_class = g_type_class_peek_parent (class);
 151
 152   class->clicked = NULL;
 153
 154   object_class->finalize = gtk_tree_view_column_finalize;
 155   object_class->set_property = gtk_tree_view_column_set_property;
 156   object_class->get_property = gtk_tree_view_column_get_property;
 157
 158   tree_column_signals[CLICKED] =
 159     g_signal_new ("clicked",
 160                   GTK_CLASS_TYPE (object_class),
 161                   G_SIGNAL_RUN_LAST,
 162                   G_STRUCT_OFFSET (GtkTreeViewColumnClass, clicked),
 163                   NULL, NULL,
 164                   gtk_marshal_VOID__VOID,
 165                   GTK_TYPE_NONE, 0);
 166
 167   g_object_class_install_property (object_class,
 168                                    PROP_VISIBLE,
 169                                    g_param_spec_boolean ("visible",
 170                                                         _("Visible"),
 171                                                         _("Whether to display the column"),
 172                                                          TRUE,
 173                                                          G_PARAM_READABLE | G_PARAM_WRITABLE));
 174
 175   g_object_class_install_property (object_class,
 176                                    PROP_SIZING,
 177                                    g_param_spec_enum ("sizing",
 178                                                       _("Sizing"),
 179                                                       _("Resize mode of the column"),
 180                                                       GTK_TYPE_TREE_VIEW_COLUMN_SIZING,
 181                                                       GTK_TREE_VIEW_COLUMN_AUTOSIZE,
 182                                                       G_PARAM_READABLE | G_PARAM_WRITABLE));
 183
 184   g_object_class_install_property (object_class,
 185                                    PROP_WIDTH,
 186                                    g_param_spec_int ("width",
 187                                                      _("Width"),
 188                                                      _("Current width of the column"),
 189                                                      1,
 190                                                      G_MAXINT,
 191                                                      1, /* not useful */
 192                                                      G_PARAM_READABLE | G_PARAM_WRITABLE));
 193
 194   g_object_class_install_property (object_class,
 195                                    PROP_MIN_WIDTH,
 196                                    g_param_spec_int ("min_width",
 197                                                      _("Minimum Width"),
 198                                                      _("Minimum allowed width of the column"),
 199                                                      -1,
 200                                                      G_MAXINT,
 201                                                      1,
 202                                                      G_PARAM_READABLE | G_PARAM_WRITABLE));
 203
 204   g_object_class_install_property (object_class,
 205                                    PROP_MAX_WIDTH,
 206                                    g_param_spec_int ("max_width",
 207                                                      _("Maximum Width"),
 208                                                      _("Maximum allowed width of the column"),
 209                                                      -1,
 210                                                      G_MAXINT,
 211                                                      G_MAXINT,
 212                                                      G_PARAM_READABLE | G_PARAM_WRITABLE));
 213
 214   g_object_class_install_property (object_class,
 215                                    PROP_TITLE,
 216                                    g_param_spec_string ("title",
 217                                                         _("Title"),
 218                                                         _("Title to appear in column header"),
 219                                                         "",
 220                                                         G_PARAM_READABLE | G_PARAM_WRITABLE));
 221
 222   g_object_class_install_property (object_class,
 223                                    PROP_CLICKABLE,
 224                                    g_param_spec_boolean ("clickable",
 225                                                         _("Clickable"),
 226                                                         _("Whether the header can be clicked"),
 227                                                          TRUE,
 228                                                          G_PARAM_READABLE | G_PARAM_WRITABLE));
 229
 230
 231   g_object_class_install_property (object_class,
 232                                    PROP_WIDGET,
 233                                    g_param_spec_object ("widget",
 234                                                         _("Widget"),
 235                                                         _("Widget to put in column header button instead of column title"),
 236                                                         GTK_TYPE_WIDGET,
 237                                                         G_PARAM_READABLE | G_PARAM_WRITABLE));
 238
 239   g_object_class_install_property (object_class,
 240                                    PROP_ALIGNMENT,
 241                                    g_param_spec_float ("alignment",
 242                                                        _("Alignment"),
 243                                                        _("X Alignment of the column header text or widget"),
 244                                                        0.0,
 245                                                        1.0,
 246                                                        0.5,
 247                                                        G_PARAM_READABLE | G_PARAM_WRITABLE));
 248
 249   g_object_class_install_property (object_class,
 250                                    PROP_REORDERABLE,
 251                                    g_param_spec_boolean ("reorderable",
 252                                                          _("Reorderable"),
 253                                                          _("Wether the column can be reordered around the headers"),
 254                                                          FALSE,
 255                                                          G_PARAM_READABLE | G_PARAM_WRITABLE));
 256
 257   g_object_class_install_property (object_class,
 258                                    PROP_SORT_INDICATOR,
 259                                    g_param_spec_boolean ("sort_indicator",
 260                                                         _("Sort indicator"),
 261                                                         _("Whether to show a sort indicator"),
 262                                                          FALSE,
 263                                                          G_PARAM_READABLE | G_PARAM_WRITABLE));
 264
 265   g_object_class_install_property (object_class,
 266                                    PROP_SORT_ORDER,
 267                                    g_param_spec_enum ("sort_order",
 268                                                       _("Sort order"),
 269                                                       _("Sort direction the sort indicator should indicate"),
 270                                                       GTK_TYPE_TREE_SORT_ORDER,
 271                                                       GTK_TREE_SORT_ASCENDING,
 272                                                       G_PARAM_READABLE | G_PARAM_WRITABLE));
 273
 274 }
 275
 276 static void
 277 gtk_tree_view_column_init (GtkTreeViewColumn *tree_column)
 278 {
 279   /* FIXME remove on port to GtkObject */
 280   gtk_object_ref (GTK_OBJECT (tree_column));
 281   gtk_object_sink (GTK_OBJECT (tree_column));
 282
 283   tree_column->button = NULL;
 284   tree_column->xalign = 0.0;
 285   tree_column->width = 1;
 286   tree_column->requested_width = -1;
 287   tree_column->min_width = -1;
 288   tree_column->max_width = -1;
 289   tree_column->column_type = GTK_TREE_VIEW_COLUMN_AUTOSIZE;
 290   tree_column->visible = TRUE;
 291   tree_column->clickable = FALSE;
 292   tree_column->dirty = TRUE;
 293   tree_column->sort_order = GTK_TREE_SORT_ASCENDING;
 294   tree_column->show_sort_indicator = FALSE;
 295   tree_column->property_changed_signal = 0;
 296   tree_column->sort_clicked_signal = 0;
 297   tree_column->sort_column_changed_signal = 0;
 298   tree_column->sort_column_id = -1;
 299   tree_column->reorderable = FALSE;
 300   tree_column->maybe_reordered = FALSE;
 301 }
 302
 303 static void
 304 gtk_tree_view_column_finalize (GObject *object)
 305 {
 306   GtkTreeViewColumn *tree_column = (GtkTreeViewColumn *) object;
 307   GList *list;
 308
 309
 310   for (list = tree_column->cell_list; list; list = list->next)
 311     {
 312       GtkTreeViewColumnCellInfo *info = (GtkTreeViewColumnCellInfo *) list->data;
 313       if (info->func_data && info->destroy)
 314         (info->destroy) (info->func_data);
 315       gtk_tree_view_column_clear_attributes (tree_column, info->cell);
 316       g_object_unref (G_OBJECT (info->cell));
 317       g_free (info);
 318     }
 319
 320   g_free (tree_column->title);
 321 }
 322
 323 static void
 324 gtk_tree_view_column_set_property (GObject         *object,
 325                                    guint            prop_id,
 326                                    const GValue    *value,
 327                                    GParamSpec      *pspec)
 328 {
 329   GtkTreeViewColumn *tree_column;
 330
 331   tree_column = GTK_TREE_VIEW_COLUMN (object);
 332
 333   switch (prop_id)
 334     {
 335     case PROP_VISIBLE:
 336       gtk_tree_view_column_set_visible (tree_column,
 337                                         g_value_get_boolean (value));
 338       break;
 339
 340     case PROP_SIZING:
 341       gtk_tree_view_column_set_sizing (tree_column,
 342                                        g_value_get_enum (value));
 343       break;
 344
 345     case PROP_WIDTH:
 346       gtk_tree_view_column_set_width (tree_column,
 347                                       g_value_get_int (value));
 348       break;
 349
 350     case PROP_MIN_WIDTH:
 351       gtk_tree_view_column_set_min_width (tree_column,
 352                                           g_value_get_int (value));
 353       break;
 354
 355     case PROP_MAX_WIDTH:
 356       gtk_tree_view_column_set_max_width (tree_column,
 357                                           g_value_get_int (value));
 358       break;
 359
 360     case PROP_TITLE:
 361       gtk_tree_view_column_set_title (tree_column,
 362                                       g_value_get_string (value));
 363       break;
 364
 365     case PROP_CLICKABLE:
 366       gtk_tree_view_column_set_clickable (tree_column,
 367                                           g_value_get_boolean (value));
 368       break;
 369
 370     case PROP_WIDGET:
 371       gtk_tree_view_column_set_widget (tree_column,
 372                                        (GtkWidget*) g_value_get_object (value));
 373       break;
 374
 375     case PROP_ALIGNMENT:
 376       gtk_tree_view_column_set_alignment (tree_column,
 377                                           g_value_get_float (value));
 378       break;
 379
 380     case PROP_REORDERABLE:
 381       gtk_tree_view_column_set_reorderable (tree_column,
 382                                             g_value_get_boolean (value));
 383       break;
 384
 385     case PROP_SORT_INDICATOR:
 386       gtk_tree_view_column_set_sort_indicator (tree_column,
 387                                                g_value_get_boolean (value));
 388       break;
 389
 390     case PROP_SORT_ORDER:
 391       gtk_tree_view_column_set_sort_order (tree_column,
 392                                            g_value_get_enum (value));
 393       break;
 394
 395     default:
 396       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 397       break;
 398     }
 399 }
 400
 401 static void
 402 gtk_tree_view_column_get_property (GObject         *object,
 403                                    guint            prop_id,
 404                                    GValue          *value,
 405                                    GParamSpec      *pspec)
 406 {
 407   GtkTreeViewColumn *tree_column;
 408
 409   tree_column = GTK_TREE_VIEW_COLUMN (object);
 410
 411   switch (prop_id)
 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_RESIZABLE)
 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_connect (G_OBJECT (model), "sort_column_changed",
 853                             GTK_SIGNAL_FUNC (gtk_tree_view_model_sort_column_changed),
 854                             tree_column);
 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 (GTK_OBJECT (tree_view),
 943                             "notify::model",
 944                             GTK_SIGNAL_FUNC (gtk_tree_view_column_setup_sort_column_id_callback),
 945                             column);
 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, cell, 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   gtk_tree_view_column_pack_start_cell_renderer (tree_column, cell, TRUE, TRUE, 0);
1063 }
1064
1065 static GtkTreeViewColumnCellInfo *
1066 gtk_tree_view_column_get_cell_info (GtkTreeViewColumn *tree_column,
1067                                     GtkCellRenderer   *cell_renderer)
1068 {
1069   GList *list;
1070   for (list = tree_column->cell_list; list; list = list->next)
1071     if (((GtkTreeViewColumnCellInfo *)list->data)->cell == cell_renderer)
1072       return (GtkTreeViewColumnCellInfo *) list->data;
1073   return NULL;
1074 }
1075
1076 /**
1077  * gtk_tree_view_column_pack_start_cell_renderer:
1078  * @tree_column: A #GtkTreeViewColumn.
1079  * @cell: The #GtkCellRenderer,
1080  * @expand: TRUE if @cell is to be given extra space allocated to box.
1081  * @fill: TRUE if @cell is to fill space allocated to it.
1082  * @padding: extra space in pixels to place on the outside of the cell
1083  *
1084  * Packs a cell into
1085  **/
1086 void
1087 gtk_tree_view_column_pack_start_cell_renderer (GtkTreeViewColumn  *tree_column,
1088                                                GtkCellRenderer    *cell,
1089                                                gboolean            expand,
1090                                                gboolean            fill,
1091                                                guint               padding)
1092 {
1093   GtkTreeViewColumnCellInfo *cell_info;
1094
1095   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
1096   g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
1097   g_return_if_fail (! gtk_tree_view_column_get_cell_info (tree_column, cell));
1098
1099   g_object_ref (G_OBJECT (cell));
1100
1101   cell_info = g_new0 (GtkTreeViewColumnCellInfo, 1);
1102   cell_info->cell = cell;
1103   cell_info->expand = expand ? TRUE : FALSE;
1104   cell_info->fill = fill ? TRUE : FALSE;
1105   cell_info->pack = GTK_PACK_START;
1106   cell_info->attributes = NULL;
1107
1108   tree_column->cell_list = g_list_append (tree_column->cell_list, cell_info);
1109 }
1110
1111 void
1112 gtk_tree_view_column_pack_end_cell_renderer (GtkTreeViewColumn  *tree_column,
1113                                              GtkCellRenderer    *cell,
1114                                              gboolean            expand,
1115                                              gboolean            fill,
1116                                              guint               padding)
1117 {
1118   GtkTreeViewColumnCellInfo *cell_info;
1119
1120   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
1121   g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
1122   g_return_if_fail (! gtk_tree_view_column_get_cell_info (tree_column, cell));
1123
1124   g_object_ref (G_OBJECT (cell));
1125
1126   cell_info = g_new (GtkTreeViewColumnCellInfo, 1);
1127   cell_info->cell = cell;
1128   cell_info->expand = expand ? TRUE : FALSE;
1129   cell_info->fill = fill ? TRUE : FALSE;
1130   cell_info->pack = GTK_PACK_END;
1131   cell_info->attributes = NULL;
1132
1133   tree_column->cell_list = g_list_append (tree_column->cell_list, cell_info);
1134 }
1135
1136
1137 void
1138 gtk_tree_view_column_clear_cell_renderers (GtkTreeViewColumn *tree_column)
1139 {
1140   GList *list;
1141   g_return_if_fail (tree_column != NULL);
1142
1143   for (list = tree_column->cell_list; list; list = list->next)
1144     {
1145       GtkTreeViewColumnCellInfo *info = (GtkTreeViewColumnCellInfo *)list->data;
1146
1147       g_object_unref (G_OBJECT (info->cell));
1148       gtk_tree_view_column_clear_attributes (tree_column, info->cell);
1149       g_free (info);
1150     }
1151
1152   g_list_free (tree_column->cell_list);
1153   tree_column->cell_list = NULL;
1154 }
1155
1156 GList *
1157 gtk_tree_view_column_get_cell_renderers (GtkTreeViewColumn *tree_column)
1158 {
1159   GList *retval = NULL, *list;
1160
1161   g_return_val_if_fail (tree_column != NULL, NULL);
1162
1163   for (list = tree_column->cell_list; list; list = list->next)
1164     {
1165       GtkTreeViewColumnCellInfo *info = (GtkTreeViewColumnCellInfo *)list->data;
1166
1167       retval = g_list_append (retval, info->cell);
1168     }
1169
1170   return retval;
1171 }
1172
1173 /**
1174  * gtk_tree_view_column_add_attribute:
1175  * @tree_column: A #GtkTreeViewColumn.
1176  * @attribute: An attribute on the columns cell
1177  * @column: The column position on the model to get the attribute from.
1178  *
1179  * Adds an attribute mapping to the list in @tree_column.  The @column is the
1180  * column position on the model to get a value from, and the @attribute is the
1181  * parameter on the @tree_column's cell renderer to set that value to.
1182  **/
1183 void
1184 gtk_tree_view_column_add_attribute (GtkTreeViewColumn *tree_column,
1185                                     GtkCellRenderer   *cell_renderer,
1186                                     const gchar       *attribute,
1187                                     gint               column)
1188 {
1189   GtkTreeViewColumnCellInfo *info;
1190
1191   g_return_if_fail (tree_column != NULL);
1192   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
1193   info = gtk_tree_view_column_get_cell_info (tree_column, cell_renderer);
1194   g_return_if_fail (info != NULL);
1195
1196   info->attributes = g_slist_prepend (info->attributes, GINT_TO_POINTER (column));
1197   info->attributes = g_slist_prepend (info->attributes, g_strdup (attribute));
1198
1199   if (tree_column->tree_view)
1200     {
1201       tree_column->dirty = TRUE;
1202       gtk_widget_queue_resize (tree_column->tree_view);
1203     }
1204
1205 }
1206
1207 static void
1208 gtk_tree_view_column_set_attributesv (GtkTreeViewColumn *tree_column,
1209                                       GtkCellRenderer   *cell_renderer,
1210                                       va_list            args)
1211 {
1212   gchar *attribute;
1213   gint column;
1214
1215   attribute = va_arg (args, gchar *);
1216
1217   gtk_tree_view_column_clear_attributes (tree_column, cell_renderer);
1218
1219   while (attribute != NULL)
1220     {
1221       column = va_arg (args, gint);
1222       gtk_tree_view_column_add_attribute (tree_column, cell_renderer, attribute, column);
1223       attribute = va_arg (args, gchar *);
1224     }
1225 }
1226
1227 /**
1228  * gtk_tree_view_column_set_attributes:
1229  * @tree_column: A #GtkTreeViewColumn.
1230  * @Varargs: A NULL terminated listing of attributes.
1231  *
1232  * Sets the attributes in the list as the attributes of @tree_column.
1233  * The attributes should be in attribute/column order, as in
1234  * @gtk_tree_view_column_add_attribute. All existing attributes
1235  * are removed, and replaced with the new attributes.
1236  **/
1237 void
1238 gtk_tree_view_column_set_attributes (GtkTreeViewColumn *tree_column,
1239                                      GtkCellRenderer   *cell_renderer,
1240                                      ...)
1241 {
1242   va_list args;
1243
1244   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
1245   g_return_if_fail (GTK_IS_CELL_RENDERER (cell_renderer));
1246   g_return_if_fail (gtk_tree_view_column_get_cell_info (tree_column, cell_renderer));
1247
1248   va_start (args, cell_renderer);
1249   gtk_tree_view_column_set_attributesv (tree_column, cell_renderer, args);
1250   va_end (args);
1251 }
1252
1253
1254 /**
1255  * gtk_tree_view_column_set_cell_data_func:
1256  * @tree_column: A #GtkTreeViewColumn
1257  * @func: The #GtkTreeViewColumnFunc to use.
1258  * @func_data: The user data for @func.
1259  * @destroy: The destroy notification for @func_data
1260  *
1261  * Sets the #GtkTreeViewColumnFunc to use for the column.  This function is used
1262  * instead of the standard attributes mapping for setting the column value, and
1263  * should set the value of @tree_column 's cell renderer as appropriate.  @func
1264  * may be NULL to remove an older one.
1265  **/
1266 void
1267 gtk_tree_view_column_set_cell_data_func (GtkTreeViewColumn   *tree_column,
1268                                          GtkCellRenderer     *cell_renderer,
1269                                          GtkTreeCellDataFunc  func,
1270                                          gpointer             func_data,
1271                                          GtkDestroyNotify     destroy)
1272 {
1273   GtkTreeViewColumnCellInfo *info;
1274
1275   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
1276   g_return_if_fail (GTK_IS_CELL_RENDERER (cell_renderer));
1277   info = gtk_tree_view_column_get_cell_info (tree_column, cell_renderer);
1278
1279   g_return_if_fail (info != NULL);
1280
1281   if (func == info->func &&
1282       func_data == info->func_data &&
1283       destroy == info->destroy)
1284     return;
1285
1286   if (info->func_data && info->destroy)
1287     (info->destroy) (info->func_data);
1288
1289   info->func = func;
1290   info->func_data = func_data;
1291   info->destroy = destroy;
1292
1293   if (tree_column->tree_view)
1294     {
1295       tree_column->dirty = TRUE;
1296       gtk_widget_queue_resize (tree_column->tree_view);
1297     }
1298 }
1299
1300
1301 /**
1302  * gtk_tree_view_column_clear_attributes:
1303  * @tree_column: a #GtkTreeViewColumn
1304  *@cell_renderer: a #GtkCellRenderer to clear the attribute mapping on.
1305  *
1306  * Clears all existing attributes previously set with
1307  * gtk_tree_view_column_set_attributes().
1308  **/
1309 void
1310 gtk_tree_view_column_clear_attributes (GtkTreeViewColumn *tree_column,
1311                                        GtkCellRenderer   *cell_renderer)
1312 {
1313   GtkTreeViewColumnCellInfo *info;
1314   GSList *list;
1315
1316   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
1317   g_return_if_fail (GTK_IS_CELL_RENDERER (cell_renderer));
1318   info = gtk_tree_view_column_get_cell_info (tree_column, cell_renderer);
1319
1320   list = info->attributes;
1321
1322   while (list && list->next)
1323     {
1324       g_free (list->data);
1325       list = list->next->next;
1326     }
1327   g_slist_free (info->attributes);
1328   info->attributes = NULL;
1329
1330   if (tree_column->tree_view)
1331     {
1332       tree_column->dirty = TRUE;
1333       gtk_widget_queue_resize (tree_column->tree_view);
1334     }
1335 }
1336
1337 /* Options for manipulating the columns */
1338
1339 /**
1340  * gtk_tree_view_column_set_visible:
1341  * @tree_column: A #GtkTreeViewColumn.
1342  * @visible: TRUE if the @tree_column is visible.
1343  *
1344  * Sets the visibility of @tree_column.
1345  **/
1346 void
1347 gtk_tree_view_column_set_visible (GtkTreeViewColumn *tree_column,
1348                                   gboolean           visible)
1349 {
1350   g_return_if_fail (tree_column != NULL);
1351   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
1352
1353   visible = !! visible;
1354
1355   if (tree_column->visible == visible)
1356     return;
1357
1358   tree_column->visible = visible;
1359
1360   gtk_tree_view_column_update_button (tree_column);
1361   g_object_notify (G_OBJECT (tree_column), "visible");
1362 }
1363
1364 /**
1365  * gtk_tree_view_column_get_visible:
1366  * @tree_column: A #GtkTreeViewColumn.
1367  *
1368  * Returns TRUE if @tree_column is visible.
1369  *
1370  * Return value: whether the column is visible or not.  If it is visible, then
1371  * the tree will show the column.
1372  **/
1373 gboolean
1374 gtk_tree_view_column_get_visible (GtkTreeViewColumn *tree_column)
1375 {
1376   g_return_val_if_fail (tree_column != NULL, FALSE);
1377   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), FALSE);
1378
1379   return tree_column->visible;
1380 }
1381
1382 /**
1383  * gtk_tree_view_column_set_sizing:
1384  * @tree_column: A #GtkTreeViewColumn.
1385  * @type: The #GtkTreeViewColumnSizing.
1386  *
1387  * Sets the growth behavior of @tree_column to @type.
1388  **/
1389 void
1390 gtk_tree_view_column_set_sizing (GtkTreeViewColumn       *tree_column,
1391                                  GtkTreeViewColumnSizing  type)
1392 {
1393   g_return_if_fail (tree_column != NULL);
1394   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
1395
1396   if (type == tree_column->column_type)
1397     return;
1398
1399   if (tree_column->column_type == GTK_TREE_VIEW_COLUMN_AUTOSIZE &&
1400       tree_column->requested_width != -1)
1401     {
1402       gtk_tree_view_column_set_sizing (tree_column, tree_column->requested_width);
1403     }
1404   tree_column->column_type = type;
1405
1406   gtk_tree_view_column_update_button (tree_column);
1407
1408   if (type != GTK_TREE_VIEW_COLUMN_AUTOSIZE)
1409   g_object_notify (G_OBJECT (tree_column), "sizing");
1410 }
1411
1412 /**
1413  * gtk_tree_view_column_get_sizing:
1414  * @tree_column: A #GtkTreeViewColumn.
1415  *
1416  * Returns the current type of @tree_column.
1417  *
1418  * Return value: The type of @tree_column.
1419  **/
1420 GtkTreeViewColumnSizing
1421 gtk_tree_view_column_get_sizing (GtkTreeViewColumn *tree_column)
1422 {
1423   g_return_val_if_fail (tree_column != NULL, 0);
1424   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), 0);
1425
1426   return tree_column->column_type;
1427 }
1428
1429 /**
1430  * gtk_tree_view_column_get_size:
1431  * @tree_column: A #GtkTreeViewColumn.
1432  *
1433  * Returns the current size of the @tree_column in pixels.
1434  *
1435  * Return value: The current size of the @tree_column.
1436  **/
1437 gint
1438 gtk_tree_view_column_get_size (GtkTreeViewColumn *tree_column)
1439 {
1440   g_return_val_if_fail (tree_column != NULL, 0);
1441   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), 0);
1442
1443   return tree_column->width;
1444 }
1445
1446 /**
1447  * gtk_tree_view_column_set_width:
1448  * @tree_column: A #GtkTreeViewColumn.
1449  * @width: The size to set the @tree_column to.
1450  *
1451  * Sets the size of the column in pixels, unless the the column type is
1452  * #GTK_TREE_VIEW_COLUMN_AUTOSIZE.  In this case, the value is discarded as the
1453  * size of the column is based on the calculated width of the column. The
1454  * width is clamped to the min/max width for the column.
1455  **/
1456 void
1457 gtk_tree_view_column_set_width (GtkTreeViewColumn *tree_column,
1458                                 gint               width)
1459 {
1460   g_return_if_fail (tree_column != NULL);
1461   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
1462   g_return_if_fail (width > 0);
1463
1464   if (tree_column->column_type == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
1465     return;
1466
1467   tree_column->requested_width = width;
1468   _gtk_tree_view_column_set_width (tree_column, width);
1469 }
1470
1471 /**
1472  * gtk_tree_view_column_get_width:
1473  * @tree_column: a #GtkTreeViewColumn
1474  *
1475  * Gets the value set by gtk_tree_view_column_set_width().
1476  *
1477  * Return value: the width of the column
1478  **/
1479 gint
1480 gtk_tree_view_column_get_width (GtkTreeViewColumn *tree_column)
1481 {
1482   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), 0);
1483
1484   return tree_column->width;
1485 }
1486
1487 /**
1488  * gtk_tree_view_column_set_min_width:
1489  * @tree_column: A #GtkTreeViewColumn.
1490  * @min_width: The minimum width of the column in pixels, or -1.
1491  *
1492  * Sets the minimum width of the @tree_column.  If @min_width is -1, then the
1493  * minimum width is unset.
1494  **/
1495 void
1496 gtk_tree_view_column_set_min_width (GtkTreeViewColumn *tree_column,
1497                                     gint               min_width)
1498 {
1499   gint real_min_width;
1500
1501   g_return_if_fail (tree_column != NULL);
1502   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
1503   g_return_if_fail (min_width >= -1);
1504
1505   if (min_width == tree_column->min_width)
1506     return;
1507
1508   if (tree_column->tree_view == NULL)
1509     {
1510       tree_column->min_width = min_width;
1511       return;
1512     }
1513
1514   real_min_width = (tree_column->min_width == -1) ?
1515     tree_column->button->requisition.width : tree_column->min_width;
1516
1517   /* We want to queue a resize if the either the old min_size or the
1518    * new min_size determined the size of the column */
1519   if (GTK_WIDGET_REALIZED (tree_column->tree_view))
1520     {
1521       if ((tree_column->min_width > tree_column->width) ||
1522           (tree_column->min_width == -1 &&
1523            tree_column->button->requisition.width > tree_column->width) ||
1524           (min_width > tree_column->width) ||
1525           (min_width == -1 &&
1526            tree_column->button->requisition.width > tree_column->width))
1527         gtk_widget_queue_resize (tree_column->tree_view);
1528     }
1529
1530   if (tree_column->max_width != -1 && tree_column->max_width < real_min_width)
1531     tree_column->max_width = real_min_width;
1532
1533   tree_column->min_width = min_width;
1534
1535   g_object_notify (G_OBJECT (tree_column), "min_width");
1536 }
1537
1538 /**
1539  * gtk_tree_view_column_get_min_width:
1540  * @tree_column: A #GtkTreeViewColumn.
1541  *
1542  * Returns the minimum width in pixels of the @tree_column, or -1 if no minimum
1543  * width is set.
1544  *
1545  * Return value: The minimum width of the @tree_column.
1546  **/
1547 gint
1548 gtk_tree_view_column_get_min_width (GtkTreeViewColumn *tree_column)
1549 {
1550   g_return_val_if_fail (tree_column != NULL, -1);
1551   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), -1);
1552
1553   return tree_column->min_width;
1554 }
1555
1556 /**
1557  * gtk_tree_view_column_set_max_width:
1558  * @tree_column: A #GtkTreeViewColumn.
1559  * @max_width: The maximum width of the column in pixels, or -1.
1560  *
1561  * Sets the maximum width of the @tree_column.  If @max_width is -1, then the
1562  * maximum width is unset.
1563  **/
1564 void
1565 gtk_tree_view_column_set_max_width (GtkTreeViewColumn *tree_column,
1566                                     gint               max_width)
1567 {
1568   gint real_max_width;
1569
1570   g_return_if_fail (tree_column != NULL);
1571   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
1572   g_return_if_fail (max_width >= -1);
1573
1574   if (max_width == tree_column->max_width)
1575     return;
1576
1577   if (tree_column->tree_view == NULL)
1578     {
1579       tree_column->max_width = max_width;
1580       return;
1581     }
1582
1583   real_max_width = tree_column->max_width == -1 ?
1584     tree_column->button->requisition.width : tree_column->max_width;
1585
1586   if (tree_column->tree_view &&
1587       GTK_WIDGET_REALIZED (tree_column->tree_view) &&
1588       ((tree_column->max_width < tree_column->width) ||
1589        (max_width != -1 && max_width < tree_column->width)))
1590     gtk_widget_queue_resize (tree_column->tree_view);
1591
1592   tree_column->max_width = max_width;
1593
1594   if (real_max_width > max_width)
1595     tree_column->max_width = max_width;
1596
1597   g_object_notify (G_OBJECT (tree_column), "max_width");
1598 }
1599
1600 /**
1601  * gtk_tree_view_column_get_max_width:
1602  * @tree_column: A #GtkTreeViewColumn.
1603  *
1604  * Returns the maximum width in pixels of the @tree_column, or -1 if no maximum
1605  * width is set.
1606  *
1607  * Return value: The maximum width of the @tree_column.
1608  **/
1609 gint
1610 gtk_tree_view_column_get_max_width (GtkTreeViewColumn *tree_column)
1611 {
1612   g_return_val_if_fail (tree_column != NULL, -1);
1613   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), -1);
1614
1615   return tree_column->max_width;
1616 }
1617
1618 /**
1619  * gtk_tree_view_column_clicked:
1620  * @tree_column: a #GtkTreeViewColumn
1621  *
1622  * Emits the "clicked" signal on the column.  This function will only work if
1623  * the user could have conceivably clicked on the button.
1624  **/
1625 void
1626 gtk_tree_view_column_clicked (GtkTreeViewColumn *tree_column)
1627 {
1628   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
1629
1630   if (tree_column->visible &&
1631       tree_column->button &&
1632       tree_column->clickable)
1633     gtk_button_clicked (GTK_BUTTON (tree_column->button));
1634 }
1635
1636 /**
1637  * gtk_tree_view_column_set_title:
1638  * @tree_column: A #GtkTreeViewColumn.
1639  * @title: The title of the @tree_column.
1640  *
1641  * Sets the title of the @tree_column.  If a custom widget has been set, then
1642  * this value is ignored.
1643  **/
1644 void
1645 gtk_tree_view_column_set_title (GtkTreeViewColumn *tree_column,
1646                                 const gchar       *title)
1647 {
1648   g_return_if_fail (tree_column != NULL);
1649   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
1650
1651   g_free (tree_column->title);
1652   if (title)
1653     tree_column->title = g_strdup (title);
1654   else
1655     tree_column->title = NULL;
1656
1657   gtk_tree_view_column_update_button (tree_column);
1658   g_object_notify (G_OBJECT (tree_column), "title");
1659 }
1660
1661 /**
1662  * gtk_tree_view_column_get_title:
1663  * @tree_column: A #GtkTreeViewColumn.
1664  *
1665  * Returns the title of the widget.  This value should not be modified.
1666  *
1667  * Return value: the title of the column.
1668  **/
1669 G_CONST_RETURN gchar *
1670 gtk_tree_view_column_get_title (GtkTreeViewColumn *tree_column)
1671 {
1672   g_return_val_if_fail (tree_column != NULL, NULL);
1673   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), NULL);
1674
1675   return tree_column->title;
1676 }
1677
1678 /**
1679  * gtk_tree_view_column_set_clickable:
1680  * @tree_column: A #GtkTreeViewColumn.
1681  * @clickable: TRUE if the header is active.
1682  *
1683  * Sets the header to be active if @active is TRUE.  When the header is active,
1684  * then it can take keyboard focus, and can be clicked.
1685  **/
1686 void
1687 gtk_tree_view_column_set_clickable (GtkTreeViewColumn *tree_column,
1688                                     gboolean           clickable)
1689 {
1690   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
1691
1692   if (tree_column->clickable == (clickable?TRUE:FALSE))
1693     return;
1694
1695   tree_column->clickable = (clickable?TRUE:FALSE);
1696   gtk_tree_view_column_update_button (tree_column);
1697   g_object_notify (G_OBJECT (tree_column), "clickable");
1698 }
1699
1700 /**
1701  * gtk_tree_view_column_get_clickable:
1702  * @tree_column: a #GtkTreeViewColumn
1703  *
1704  * Returns %TRUE if the user can click on the header for the column.
1705  *
1706  * Return value: whether the user can click the column header
1707  **/
1708 gboolean
1709 gtk_tree_view_column_get_clickable (GtkTreeViewColumn *tree_column)
1710 {
1711   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), FALSE);
1712
1713   return tree_column->clickable;
1714 }
1715
1716 /**
1717  * gtk_tree_view_column_set_widget:
1718  * @tree_column: A #GtkTreeViewColumn.
1719  * @widget: A child #GtkWidget, or NULL.
1720  *
1721  * Sets the widget in the header to be @widget.  If widget is NULL, then the
1722  * header button is set with a #GtkLabel set to the title of @tree_column.
1723  **/
1724 void
1725 gtk_tree_view_column_set_widget (GtkTreeViewColumn *tree_column,
1726                                  GtkWidget         *widget)
1727 {
1728   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
1729   g_return_if_fail (widget == NULL || GTK_IS_WIDGET (widget));
1730
1731   if (widget)
1732     {
1733       gtk_object_ref (GTK_OBJECT (widget));
1734       gtk_object_sink (GTK_OBJECT (widget));
1735     }
1736
1737   if (tree_column->child)
1738     gtk_object_unref (GTK_OBJECT (tree_column->child));
1739
1740   tree_column->child = widget;
1741   gtk_tree_view_column_update_button (tree_column);
1742   g_object_notify (G_OBJECT (tree_column), "widget");
1743 }
1744
1745 /**
1746  * gtk_tree_view_column_get_widget:
1747  * @tree_column: A #GtkTreeViewColumn.
1748  *
1749  * Returns the #GtkWidget in the button in the column header.  If a custom
1750  * widget has not been set, then this will be a #GtkAlignment with a #GtkLabel
1751  * in it.
1752  *
1753  * Return value: The #GtkWidget in the column header.
1754  **/
1755 GtkWidget *
1756 gtk_tree_view_column_get_widget (GtkTreeViewColumn *tree_column)
1757 {
1758   g_return_val_if_fail (tree_column != NULL, NULL);
1759   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), NULL);
1760
1761   return tree_column->child;
1762 }
1763
1764 /**
1765  * gtk_tree_view_column_set_alignment:
1766  * @tree_column: A #GtkTreeViewColumn.
1767  * @xalign: alignment (0.0 for left, 0.5 for center, 1.0 for right)
1768  *
1769  * Sets the alignment of the title or custom widget inside the column header.
1770  **/
1771 void
1772 gtk_tree_view_column_set_alignment (GtkTreeViewColumn *tree_column,
1773                                     gfloat             xalign)
1774 {
1775   g_return_if_fail (tree_column != NULL);
1776   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
1777
1778   if (tree_column->xalign == xalign)
1779     return;
1780
1781   tree_column->xalign = xalign;
1782   gtk_tree_view_column_update_button (tree_column);
1783   g_object_notify (G_OBJECT (tree_column), "alignment");
1784 }
1785
1786 /**
1787  * gtk_tree_view_column_get_alignment:
1788  * @tree_column: A #GtkTreeViewColumn.
1789  *
1790  * Returns the current x alignment of @tree_column.  This value can range
1791  * between 0.0 and 1.0.
1792  *
1793  * Return value: The current alignent of @tree_column.
1794  **/
1795 gfloat
1796 gtk_tree_view_column_get_alignment (GtkTreeViewColumn *tree_column)
1797 {
1798   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), 0.5);
1799
1800   return tree_column->xalign;
1801 }
1802
1803 void
1804 gtk_tree_view_column_set_reorderable (GtkTreeViewColumn *tree_column,
1805                                       gboolean           reorderable)
1806 {
1807   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
1808
1809   /*  if (reorderable)
1810       gtk_tree_view_column_set_clickable (tree_column, TRUE);*/
1811
1812   if (tree_column->reorderable == (reorderable?TRUE:FALSE))
1813     return;
1814
1815   tree_column->reorderable = (reorderable?TRUE:FALSE);
1816   gtk_tree_view_column_update_button (tree_column);
1817   g_object_notify (G_OBJECT (tree_column), "reorderable");
1818 }
1819
1820 gboolean
1821 gtk_tree_view_column_get_reorderable (GtkTreeViewColumn *tree_column)
1822 {
1823   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), FALSE);
1824
1825   return tree_column->reorderable;
1826 }
1827
1828
1829 /**
1830  * gtk_tree_view_column_set_sort_column_id:
1831  * @tree_column: a #GtkTreeViewColumn
1832  * @sort_column_id: The sort_column_id of the model to sort on.
1833  *
1834  * Sets the logical sort_column_id that this column sorts on when this
1835  * column is selected for sorting.  Doing so makes
1836  * the column header clickable.
1837  **/
1838 void
1839 gtk_tree_view_column_set_sort_column_id (GtkTreeViewColumn *tree_column,
1840                                          gint               sort_column_id)
1841 {
1842   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
1843   g_return_if_fail (sort_column_id >= 0);
1844
1845   if (tree_column->sort_column_id == sort_column_id)
1846     return;
1847
1848   tree_column->sort_column_id = sort_column_id;
1849
1850   /* Handle unsetting the id */
1851   if (sort_column_id == -1)
1852     {
1853       if (tree_column->sort_clicked_signal)
1854         {
1855           g_signal_handler_disconnect (G_OBJECT (tree_column), tree_column->sort_clicked_signal);
1856           tree_column->sort_clicked_signal = 0;
1857         }
1858
1859       if (tree_column->sort_column_changed_signal)
1860         {
1861           g_signal_handler_disconnect (G_OBJECT (tree_column), tree_column->sort_column_changed_signal);
1862           tree_column->sort_column_changed_signal = 0;
1863         }
1864
1865       gtk_tree_view_column_set_sort_order (tree_column, GTK_TREE_SORT_ASCENDING);
1866       gtk_tree_view_column_set_sort_indicator (tree_column, FALSE);
1867       return;
1868     }
1869
1870   gtk_tree_view_column_set_clickable (tree_column, TRUE);
1871
1872   if (! tree_column->sort_clicked_signal)
1873     tree_column->sort_clicked_signal = g_signal_connect (G_OBJECT (tree_column),
1874                                                          "clicked",
1875                                                          G_CALLBACK (gtk_tree_view_column_sort),
1876                                                          NULL);
1877
1878   gtk_tree_view_column_setup_sort_column_id_callback (tree_column);
1879 }
1880
1881 /**
1882  * gtk_tree_view_column_get_sort_column_id:
1883  * @tree_column: a #GtkTreeViewColumn
1884  *
1885  * Gets the logical sort_column_id that the model sorts on when this
1886  * coumn is selected for sorting. See gtk_tree_view_column_set_sort_column_id().
1887  *
1888  * Return value: the current sort_column_id for this column, or -1 if
1889  *               this column can't be used for sorting.
1890  **/
1891 gint
1892 gtk_tree_view_column_get_sort_column_id (GtkTreeViewColumn *tree_column)
1893 {
1894   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), 0);
1895
1896   return tree_column->sort_column_id;
1897 }
1898
1899 /**
1900  * gtk_tree_view_column_set_sort_indicator:
1901  * @tree_column: a #GtkTreeViewColumn
1902  * @setting: %TRUE to display an indicator that the column is sorted
1903  *
1904  * Call this function with a @setting of %TRUE to display an arrow in
1905  * the header button indicating the column is sorted. Call
1906  * gtk_tree_view_column_set_sort_order() to change the direction of
1907  * the arrow.
1908  *
1909  **/
1910 void
1911 gtk_tree_view_column_set_sort_indicator (GtkTreeViewColumn     *tree_column,
1912                                          gboolean               setting)
1913 {
1914   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
1915
1916   setting = setting != FALSE;
1917
1918   if (setting == tree_column->show_sort_indicator)
1919     return;
1920
1921   tree_column->show_sort_indicator = setting;
1922   gtk_tree_view_column_update_button (tree_column);
1923   g_object_notify (G_OBJECT (tree_column), "sort_indicator");
1924 }
1925
1926 /**
1927  * gtk_tree_view_column_get_sort_indicator:
1928  * @tree_column: a #GtkTreeViewColumn
1929  *
1930  * Gets the value set by gtk_tree_view_column_set_sort_indicator().
1931  *
1932  * Return value: whether the sort indicator arrow is displayed
1933  **/
1934 gboolean
1935 gtk_tree_view_column_get_sort_indicator  (GtkTreeViewColumn     *tree_column)
1936 {
1937   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), FALSE);
1938
1939   return tree_column->show_sort_indicator;
1940 }
1941
1942 /**
1943  * gtk_tree_view_column_set_sort_order:
1944  * @tree_column: a #GtkTreeViewColumn
1945  * @order: sort order that the sort indicator should indicate
1946  *
1947  * Changes the appearance of the sort indicator. (This <emphasis>does
1948  * not</emphasis> actually sort the model.  Use
1949  * gtk_tree_view_column_set_sort_column_id() if you want automatic sorting
1950  * support.  This function is primarily for custom sorting behavior, and should
1951  * be used in conjunction with #gtk_tree_sortable_set_sort_column() to do
1952  * that. For custom models, the mechanism will vary. The sort indicator changes
1953  * direction to indicate normal sort or reverse sort. Note that you must have
1954  * the sort indicator enabled to see anything when calling this function; see
1955  * gtk_tree_view_column_set_sort_indicator().
1956  *
1957  **/
1958 void
1959 gtk_tree_view_column_set_sort_order      (GtkTreeViewColumn     *tree_column,
1960                                           GtkTreeSortOrder       order)
1961 {
1962   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
1963
1964   if (order == tree_column->sort_order)
1965     return;
1966
1967   tree_column->sort_order = order;
1968   gtk_tree_view_column_update_button (tree_column);
1969   g_object_notify (G_OBJECT (tree_column), "sort_order");
1970 }
1971
1972 /**
1973  * gtk_tree_view_column_get_sort_order:
1974  * @tree_column: a #GtkTreeViewColumn
1975  *
1976  * Gets the value set by gtk_tree_view_column_set_sort_order().
1977  *
1978  * Return value: the sort order the sort indicator is indicating
1979  **/
1980 GtkTreeSortOrder
1981 gtk_tree_view_column_get_sort_order      (GtkTreeViewColumn     *tree_column)
1982 {
1983   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), 0);
1984
1985   return tree_column->sort_order;
1986 }
1987
1988 /**
1989  * gtk_tree_view_column_cell_set_cell_data:
1990  * @tree_column: A #GtkTreeViewColumn.
1991  * @tree_model: The #GtkTreeModel to to get the cell renderers attributes from.
1992  * @iter: The #GtkTreeIter to to get the cell renderer's attributes from.
1993  *
1994  * Sets the cell renderer based on the @tree_model and @tree_node.  That is, for
1995  * every attribute mapping in @tree_column, it will get a value from the set
1996  * column on the @tree_node, and use that value to set the attribute on the cell
1997  * renderer.  This is used primarily by the GtkTreeView.
1998  **/
1999 void
2000 gtk_tree_view_column_cell_set_cell_data (GtkTreeViewColumn *tree_column,
2001                                          GtkTreeModel      *tree_model,
2002                                          GtkTreeIter       *iter)
2003 {
2004   GSList *list;
2005   GValue value = { 0, };
2006   GList *cell_list;
2007
2008   g_return_if_fail (tree_column != NULL);
2009   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
2010   g_return_if_fail (tree_column->cell_list != NULL);
2011
2012   if (tree_model == NULL)
2013     return;
2014
2015   for (cell_list = tree_column->cell_list; cell_list; cell_list = cell_list->next)
2016     {
2017       GtkTreeViewColumnCellInfo *info = (GtkTreeViewColumnCellInfo *) cell_list->data;
2018       GObject *cell = (GObject *) info->cell;
2019
2020       list = info->attributes;
2021
2022       g_object_freeze_notify (cell);
2023
2024       while (list && list->next)
2025         {
2026           gtk_tree_model_get_value (tree_model, iter,
2027                                     GPOINTER_TO_INT (list->next->data),
2028                                     &value);
2029           g_object_set_property (cell, (gchar *) list->data, &value);
2030           g_value_unset (&value);
2031           list = list->next->next;
2032         }
2033
2034       if (info->func)
2035         (* info->func) (tree_column, info->cell, tree_model, iter, info->func_data);
2036       g_object_thaw_notify (G_OBJECT (info->cell));
2037     }
2038
2039 }
2040
2041 /**
2042  * gtk_tree_view_column_cell_get_size:
2043  * @tree_column: A #GtkTreeViewColumn.
2044  * @cell_area: The area a the column will be allocated, or %NULL
2045  * @x_offset: location to return x offset of cell relative to @cell_area, or %NULL
2046  * @y_offset: location to return y offset of cell relative to @cell_area, or %NULL
2047  * @width: location to return width needed to render a cell, or %NULL
2048  * @height: location to return height needed to render a cell, or %NULL
2049  *
2050  * Obtains the width and height needed to render the column.  This is used
2051  * primarily by the GtkTreeView.
2052  **/
2053 void
2054 gtk_tree_view_column_cell_get_size (GtkTreeViewColumn *tree_column,
2055                                     GdkRectangle      *cell_area,
2056                                     gint              *x_offset,
2057                                     gint              *y_offset,
2058                                     gint              *width,
2059                                     gint              *height)
2060 {
2061   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
2062
2063   gtk_cell_renderer_get_size (((GtkTreeViewColumnCellInfo *) tree_column->cell_list->data)->cell,
2064                               tree_column->tree_view,
2065                               cell_area,
2066                               x_offset,
2067                               y_offset,
2068                               width,
2069                               height);
2070
2071 }
2072
2073 /**
2074  * gtk_tree_view_column_cell_render:
2075  * @tree_column: A #GtkTreeViewColumn.
2076  * @window: a #GdkDrawable to draw to
2077  * @background_area: entire cell area (including tree expanders and maybe padding on the sides)
2078  * @cell_area: area normally rendered by a cell renderer
2079  * @expose_area: area that actually needs updating
2080  * @flags: flags that affect rendering
2081  *
2082  * Renders the cell contained by #tree_column. This is used primarily by the
2083  * GtkTreeView.
2084  **/
2085 void
2086 gtk_tree_view_column_cell_render (GtkTreeViewColumn *tree_column,
2087                                   GdkWindow         *window,
2088                                   GdkRectangle      *background_area,
2089                                   GdkRectangle      *cell_area,
2090                                   GdkRectangle      *expose_area,
2091                                   guint              flags)
2092 {
2093   gboolean visible;
2094   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
2095
2096   g_object_get (G_OBJECT ((((GtkTreeViewColumnCellInfo *) tree_column->cell_list->data)->cell)), "visible", &visible, NULL);
2097   if (visible)
2098   gtk_cell_renderer_render (((GtkTreeViewColumnCellInfo *) tree_column->cell_list->data)->cell,
2099                             window,
2100                             tree_column->tree_view,
2101                             background_area,
2102                             cell_area,
2103                             expose_area,
2104                             flags);
2105 }
2106
2107 /**
2108  * gtk_tree_view_column_cell_event:
2109  * @tree_column: A #GtkTreeViewColumn.
2110  * @event: a #GdkEvent
2111  * @path_string: widget-dependent string representation of the event location; e.g. for #GtkTreeView, a string representation of #GtkTreePath
2112  * @background_area: background area as passed to gtk_cell_renderer_render()
2113  * @cell_area: cell area as passed to gtk_cell_renderer_render()
2114  * @flags: render flags
2115  *
2116  * Handles an event.  This is used primarily by the GtkTreeView.
2117  *
2118  * Return value: %TRUE if the event was consumed/handled
2119  **/
2120 gboolean
2121 gtk_tree_view_column_cell_event (GtkTreeViewColumn *tree_column,
2122                                  GdkEvent          *event,
2123                                  gchar             *path_string,
2124                                  GdkRectangle      *background_area,
2125                                  GdkRectangle      *cell_area,
2126                                  guint              flags)
2127 {
2128   gboolean visible, can_activate;
2129
2130   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), FALSE);
2131
2132   g_object_get (G_OBJECT (((GtkTreeViewColumnCellInfo *) tree_column->cell_list->data)->cell),
2133                 "visible", &visible,
2134                 "can_activate", &can_activate,
2135                 NULL);
2136   if (visible && can_activate)
2137     {
2138       if (gtk_cell_renderer_event (((GtkTreeViewColumnCellInfo *) tree_column->cell_list->data)->cell,
2139                                    event,
2140                                    tree_column->tree_view,
2141                                    path_string,
2142                                    background_area,
2143                                    cell_area,
2144                                    flags))
2145         return TRUE;
2146
2147     }
2148   return FALSE;
2149 }
2150
2151 gboolean
2152 gtk_tree_view_column_cell_can_focus (GtkTreeViewColumn *tree_column)
2153 {
2154   GList *list;
2155   gboolean visible;
2156   gboolean can_activate;
2157
2158   for (list = tree_column->cell_list; list; list = list->next)
2159     {
2160       GtkTreeViewColumnCellInfo *info = (GtkTreeViewColumnCellInfo *) list->data;
2161       g_object_get (G_OBJECT (info->cell),
2162                     "can_activate", &can_activate,
2163                     "visible", &visible,
2164                     NULL);
2165       if (can_activate && visible)
2166         return TRUE;
2167     }
2168
2169   return FALSE;
2170 }
2171
2172
2173 gboolean
2174 gtk_tree_view_column_cell_is_visible (GtkTreeViewColumn *tree_column)
2175 {
2176   GList *list;
2177   gboolean visible;
2178
2179   for (list = tree_column->cell_list; list; list = list->next)
2180     {
2181       GtkTreeViewColumnCellInfo *info = (GtkTreeViewColumnCellInfo *) list->data;
2182       g_object_get (G_OBJECT (info->cell),
2183                     "visible", &visible,
2184                     NULL);
2185       if (visible)
2186         return TRUE;
2187     }
2188
2189   return FALSE;
2190 }