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