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