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 of the column. If @expand is FALSE, then
1214  * the @cell is allocated no more space than it needs. Any unused space is divided
1215  * evenly between cells for which @expand is TRUE.
1216  **/
1217 void
1218 gtk_tree_view_column_pack_start (GtkTreeViewColumn *tree_column,
1219                                  GtkCellRenderer   *cell,
1220                                  gboolean           expand)
1221 {
1222   GtkTreeViewColumnCellInfo *cell_info;
1223
1224   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
1225   g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
1226   g_return_if_fail (! gtk_tree_view_column_get_cell_info (tree_column, cell));
1227
1228   g_object_ref (G_OBJECT (cell));
1229   gtk_object_sink (GTK_OBJECT (cell));
1230
1231   cell_info = g_new0 (GtkTreeViewColumnCellInfo, 1);
1232   cell_info->cell = cell;
1233   cell_info->expand = expand ? TRUE : FALSE;
1234   cell_info->pack = GTK_PACK_START;
1235   cell_info->has_focus = 0;
1236   cell_info->attributes = NULL;
1237
1238   tree_column->cell_list = g_list_append (tree_column->cell_list, cell_info);
1239 }
1240
1241 /**
1242  * gtk_tree_view_column_pack_end:
1243  * @tree_column: A #GtkTreeViewColumn.
1244  * @cell: The #GtkCellRenderer.
1245  * @expand: %TRUE if @cell is to be given extra space allocated to box.
1246  *
1247  * Adds the @cell to end of the column. If @expand is FALSE, then the @cell
1248  * is allocated no more space than it needs. Any unused space is divided
1249  * evenly between cells for which @expand is TRUE.
1250  **/
1251 void
1252 gtk_tree_view_column_pack_end (GtkTreeViewColumn  *tree_column,
1253                                GtkCellRenderer    *cell,
1254                                gboolean            expand)
1255 {
1256   GtkTreeViewColumnCellInfo *cell_info;
1257
1258   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
1259   g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
1260   g_return_if_fail (! gtk_tree_view_column_get_cell_info (tree_column, cell));
1261
1262   g_object_ref (G_OBJECT (cell));
1263   gtk_object_sink (GTK_OBJECT (cell));
1264
1265   cell_info = g_new0 (GtkTreeViewColumnCellInfo, 1);
1266   cell_info->cell = cell;
1267   cell_info->expand = expand ? TRUE : FALSE;
1268   cell_info->pack = GTK_PACK_END;
1269   cell_info->has_focus = 0;
1270   cell_info->attributes = NULL;
1271
1272   tree_column->cell_list = g_list_append (tree_column->cell_list, cell_info);
1273 }
1274
1275
1276 /**
1277  * gtk_tree_view_column_clear:
1278  * @tree_column: A #GtkTreeViewColumn
1279  *
1280  * Unsets all the mappings on all renderers on the @tree_column.
1281  **/
1282 void
1283 gtk_tree_view_column_clear (GtkTreeViewColumn *tree_column)
1284 {
1285   GList *list;
1286   g_return_if_fail (tree_column != NULL);
1287
1288   for (list = tree_column->cell_list; list; list = list->next)
1289     {
1290       GtkTreeViewColumnCellInfo *info = (GtkTreeViewColumnCellInfo *)list->data;
1291
1292       gtk_tree_view_column_clear_attributes (tree_column, info->cell);
1293       g_object_unref (G_OBJECT (info->cell));
1294       g_free (info);
1295     }
1296
1297   g_list_free (tree_column->cell_list);
1298   tree_column->cell_list = NULL;
1299 }
1300
1301 /**
1302  * gtk_tree_view_column_get_cell_renderers:
1303  * @tree_column: A #GtkTreeViewColumn
1304  *
1305  * Returns a newly-allocated #GList of all the cell renderers in the column,
1306  * in no particular order.  The list must be freed with g_list_free().
1307  *
1308  * Return value: A list of #GtkCellRenderers
1309  **/
1310 GList *
1311 gtk_tree_view_column_get_cell_renderers (GtkTreeViewColumn *tree_column)
1312 {
1313   GList *retval = NULL, *list;
1314
1315   g_return_val_if_fail (tree_column != NULL, NULL);
1316
1317   for (list = tree_column->cell_list; list; list = list->next)
1318     {
1319       GtkTreeViewColumnCellInfo *info = (GtkTreeViewColumnCellInfo *)list->data;
1320
1321       retval = g_list_append (retval, info->cell);
1322     }
1323
1324   return retval;
1325 }
1326
1327 /**
1328  * gtk_tree_view_column_add_attribute:
1329  * @tree_column: A #GtkTreeViewColumn.
1330  * @cell_renderer: the #GtkCellRenderer to set attributes on
1331  * @attribute: An attribute on the renderer
1332  * @column: The column position on the model to get the attribute from.
1333  *
1334  * Adds an attribute mapping to the list in @tree_column.  The @column is the
1335  * column of the model to get a value from, and the @attribute is the
1336  * parameter on @cell_renderer to be set from the value. So for example
1337  * if column 2 of the model contains strings, you could have the
1338  * "text" attribute of a #GtkCellRendererText get its values from
1339  * column 2.
1340  **/
1341 void
1342 gtk_tree_view_column_add_attribute (GtkTreeViewColumn *tree_column,
1343                                     GtkCellRenderer   *cell_renderer,
1344                                     const gchar       *attribute,
1345                                     gint               column)
1346 {
1347   GtkTreeViewColumnCellInfo *info;
1348
1349   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
1350   info = gtk_tree_view_column_get_cell_info (tree_column, cell_renderer);
1351   g_return_if_fail (info != NULL);
1352
1353   info->attributes = g_slist_prepend (info->attributes, GINT_TO_POINTER (column));
1354   info->attributes = g_slist_prepend (info->attributes, g_strdup (attribute));
1355
1356   if (tree_column->tree_view)
1357     _gtk_tree_view_column_cell_set_dirty (tree_column, TRUE);
1358
1359 }
1360
1361 static void
1362 gtk_tree_view_column_set_attributesv (GtkTreeViewColumn *tree_column,
1363                                       GtkCellRenderer   *cell_renderer,
1364                                       va_list            args)
1365 {
1366   gchar *attribute;
1367   gint column;
1368
1369   attribute = va_arg (args, gchar *);
1370
1371   gtk_tree_view_column_clear_attributes (tree_column, cell_renderer);
1372
1373   while (attribute != NULL)
1374     {
1375       column = va_arg (args, gint);
1376       gtk_tree_view_column_add_attribute (tree_column, cell_renderer, attribute, column);
1377       attribute = va_arg (args, gchar *);
1378     }
1379 }
1380
1381 /**
1382  * gtk_tree_view_column_set_attributes:
1383  * @tree_column: A #GtkTreeViewColumn.
1384  * @cell_renderer: the #GtkCellRenderer we're setting the attributes of
1385  * @Varargs: A %NULL-terminated list of attributes.
1386  *
1387  * Sets the attributes in the list as the attributes of @tree_column.
1388  * The attributes should be in attribute/column order, as in
1389  * gtk_tree_view_column_add_attribute(). All existing attributes
1390  * are removed, and replaced with the new attributes.
1391  **/
1392 void
1393 gtk_tree_view_column_set_attributes (GtkTreeViewColumn *tree_column,
1394                                      GtkCellRenderer   *cell_renderer,
1395                                      ...)
1396 {
1397   va_list args;
1398
1399   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
1400   g_return_if_fail (GTK_IS_CELL_RENDERER (cell_renderer));
1401   g_return_if_fail (gtk_tree_view_column_get_cell_info (tree_column, cell_renderer));
1402
1403   va_start (args, cell_renderer);
1404   gtk_tree_view_column_set_attributesv (tree_column, cell_renderer, args);
1405   va_end (args);
1406 }
1407
1408
1409 /**
1410  * gtk_tree_view_column_set_cell_data_func:
1411  * @tree_column: A #GtkTreeViewColumn
1412  * @cell_renderer: A #GtkCellRenderer
1413  * @func: The #GtkTreeViewColumnFunc to use.
1414  * @func_data: The user data for @func.
1415  * @destroy: The destroy notification for @func_data
1416  *
1417  * Sets the #GtkTreeViewColumnFunc to use for the column.  This
1418  * function is used instead of the standard attributes mapping for
1419  * setting the column value, and should set the value of @tree_column's
1420  * cell renderer as appropriate.  @func may be %NULL to remove an
1421  * older one.
1422  **/
1423 void
1424 gtk_tree_view_column_set_cell_data_func (GtkTreeViewColumn   *tree_column,
1425                                          GtkCellRenderer     *cell_renderer,
1426                                          GtkTreeCellDataFunc  func,
1427                                          gpointer             func_data,
1428                                          GtkDestroyNotify     destroy)
1429 {
1430   GtkTreeViewColumnCellInfo *info;
1431
1432   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
1433   g_return_if_fail (GTK_IS_CELL_RENDERER (cell_renderer));
1434   info = gtk_tree_view_column_get_cell_info (tree_column, cell_renderer);
1435
1436   g_return_if_fail (info != NULL);
1437
1438   if (info->destroy)
1439     {
1440       GtkDestroyNotify d = info->destroy;
1441
1442       info->destroy = NULL;
1443       d (info->func_data);
1444     }
1445
1446   info->func = func;
1447   info->func_data = func_data;
1448   info->destroy = destroy;
1449
1450   if (tree_column->tree_view)
1451     _gtk_tree_view_column_cell_set_dirty (tree_column, TRUE);
1452 }
1453
1454
1455 /**
1456  * gtk_tree_view_column_clear_attributes:
1457  * @tree_column: a #GtkTreeViewColumn
1458  * @cell_renderer: a #GtkCellRenderer to clear the attribute mapping on.
1459  *
1460  * Clears all existing attributes previously set with
1461  * gtk_tree_view_column_set_attributes().
1462  **/
1463 void
1464 gtk_tree_view_column_clear_attributes (GtkTreeViewColumn *tree_column,
1465                                        GtkCellRenderer   *cell_renderer)
1466 {
1467   GtkTreeViewColumnCellInfo *info;
1468
1469   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
1470   g_return_if_fail (GTK_IS_CELL_RENDERER (cell_renderer));
1471
1472   info = gtk_tree_view_column_get_cell_info (tree_column, cell_renderer);
1473
1474   gtk_tree_view_column_clear_attributes_by_info (tree_column, info);
1475 }
1476
1477 static void
1478 gtk_tree_view_column_clear_attributes_by_info (GtkTreeViewColumn *tree_column,
1479                                                GtkTreeViewColumnCellInfo *info)
1480 {
1481   GSList *list;
1482
1483   list = info->attributes;
1484
1485   while (list && list->next)
1486     {
1487       g_free (list->data);
1488       list = list->next->next;
1489     }
1490   g_slist_free (info->attributes);
1491   info->attributes = NULL;
1492
1493   if (tree_column->tree_view)
1494     _gtk_tree_view_column_cell_set_dirty (tree_column, TRUE);
1495 }
1496
1497
1498 /**
1499  * gtk_tree_view_column_set_spacing:
1500  * @tree_column: A #GtkTreeViewColumn.
1501  * @spacing: distance between cell renderers in pixels.
1502  *
1503  * Sets the spacing field of @tree_column, which is the number of pixels to
1504  * place between cell renderers packed into it.
1505  **/
1506 void
1507 gtk_tree_view_column_set_spacing (GtkTreeViewColumn *tree_column,
1508                                   gint               spacing)
1509 {
1510   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
1511   g_return_if_fail (spacing >= 0);
1512
1513   if (tree_column->spacing == spacing)
1514     return;
1515
1516   tree_column->spacing = spacing;
1517   if (tree_column->tree_view)
1518     _gtk_tree_view_column_cell_set_dirty (tree_column, TRUE);
1519 }
1520
1521 /**
1522  * gtk_tree_view_column_get_spacing:
1523  * @tree_column: A #GtkTreeViewColumn.
1524  *
1525  * Returns the spacing of @tree_column.
1526  *
1527  * Return value: the spacing of @tree_column.
1528  **/
1529 gint
1530 gtk_tree_view_column_get_spacing (GtkTreeViewColumn *tree_column)
1531 {
1532   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), 0);
1533
1534   return tree_column->spacing;
1535 }
1536
1537 /* Options for manipulating the columns */
1538
1539 /**
1540  * gtk_tree_view_column_set_visible:
1541  * @tree_column: A #GtkTreeViewColumn.
1542  * @visible: %TRUE if the @tree_column is visible.
1543  *
1544  * Sets the visibility of @tree_column.
1545  **/
1546 void
1547 gtk_tree_view_column_set_visible (GtkTreeViewColumn *tree_column,
1548                                   gboolean           visible)
1549 {
1550   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
1551
1552   visible = !! visible;
1553
1554   if (tree_column->visible == visible)
1555     return;
1556
1557   tree_column->visible = visible;
1558
1559   if (tree_column->visible)
1560     _gtk_tree_view_column_cell_set_dirty (tree_column, TRUE);
1561
1562   gtk_tree_view_column_update_button (tree_column);
1563   g_object_notify (G_OBJECT (tree_column), "visible");
1564 }
1565
1566 /**
1567  * gtk_tree_view_column_get_visible:
1568  * @tree_column: A #GtkTreeViewColumn.
1569  *
1570  * Returns %TRUE if @tree_column is visible.
1571  *
1572  * Return value: whether the column is visible or not.  If it is visible, then
1573  * the tree will show the column.
1574  **/
1575 gboolean
1576 gtk_tree_view_column_get_visible (GtkTreeViewColumn *tree_column)
1577 {
1578   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), FALSE);
1579
1580   return tree_column->visible;
1581 }
1582
1583 /**
1584  * gtk_tree_view_column_set_resizable:
1585  * @tree_column: A #GtkTreeViewColumn
1586  * @resizable: %TRUE, if the column can be resized
1587  *
1588  * If @resizable is %TRUE, then the user can explicitly resize the column by
1589  * grabbing the outer edge of the column button.  If resizable is TRUE and
1590  * sizing mode of the column is #GTK_TREE_VIEW_COLUMN_AUTOSIZE, then the sizing
1591  * mode is changed to #GTK_TREE_VIEW_COLUMN_GROW_ONLY.
1592  **/
1593 void
1594 gtk_tree_view_column_set_resizable (GtkTreeViewColumn *tree_column,
1595                                     gboolean           resizable)
1596 {
1597   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
1598
1599   resizable = !! resizable;
1600
1601   if (tree_column->resizable == resizable)
1602     return;
1603
1604   tree_column->resizable = resizable;
1605
1606   if (resizable && tree_column->column_type == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
1607     gtk_tree_view_column_set_sizing (tree_column, GTK_TREE_VIEW_COLUMN_GROW_ONLY);
1608
1609   gtk_tree_view_column_update_button (tree_column);
1610
1611   g_object_notify (G_OBJECT (tree_column), "resizable");
1612 }
1613
1614 /**
1615  * gtk_tree_view_column_get_resizable:
1616  * @tree_column: A #GtkTreeViewColumn
1617  *
1618  * Returns #TRUE if the @tree_column can be resized by the end user.
1619  *
1620  * Return value: #TRUE, if the @tree_column can be resized.
1621  **/
1622 gboolean
1623 gtk_tree_view_column_get_resizable (GtkTreeViewColumn *tree_column)
1624 {
1625   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), FALSE);
1626
1627   return tree_column->resizable;
1628 }
1629
1630
1631 /**
1632  * gtk_tree_view_column_set_sizing:
1633  * @tree_column: A #GtkTreeViewColumn.
1634  * @type: The #GtkTreeViewColumnSizing.
1635  *
1636  * Sets the growth behavior of @tree_column to @type.
1637  **/
1638 void
1639 gtk_tree_view_column_set_sizing (GtkTreeViewColumn       *tree_column,
1640                                  GtkTreeViewColumnSizing  type)
1641 {
1642   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
1643
1644   if (type == tree_column->column_type)
1645     return;
1646
1647   if (type == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
1648     gtk_tree_view_column_set_resizable (tree_column, FALSE);
1649
1650 #if 0
1651   /* I was clearly on crack when I wrote this.  I'm not sure what's supposed to
1652    * be below so I'll leave it until I figure it out.
1653    */
1654   if (tree_column->column_type == GTK_TREE_VIEW_COLUMN_AUTOSIZE &&
1655       tree_column->requested_width != -1)
1656     {
1657       gtk_tree_view_column_set_sizing (tree_column, tree_column->requested_width);
1658     }
1659 #endif
1660   tree_column->column_type = type;
1661
1662   gtk_tree_view_column_update_button (tree_column);
1663
1664   g_object_notify (G_OBJECT (tree_column), "sizing");
1665 }
1666
1667 /**
1668  * gtk_tree_view_column_get_sizing:
1669  * @tree_column: A #GtkTreeViewColumn.
1670  *
1671  * Returns the current type of @tree_column.
1672  *
1673  * Return value: The type of @tree_column.
1674  **/
1675 GtkTreeViewColumnSizing
1676 gtk_tree_view_column_get_sizing (GtkTreeViewColumn *tree_column)
1677 {
1678   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), 0);
1679
1680   return tree_column->column_type;
1681 }
1682
1683 /**
1684  * gtk_tree_view_column_get_width:
1685  * @tree_column: A #GtkTreeViewColumn.
1686  *
1687  * Returns the current size of @tree_column in pixels.
1688  *
1689  * Return value: The current width of @tree_column.
1690  **/
1691 gint
1692 gtk_tree_view_column_get_width (GtkTreeViewColumn *tree_column)
1693 {
1694   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), 0);
1695
1696   return tree_column->width;
1697 }
1698
1699 /**
1700  * gtk_tree_view_column_set_fixed_width:
1701  * @tree_column: A #GtkTreeViewColumn.
1702  * @fixed_width: The size to set @tree_column to. Must be greater than 0.
1703  *
1704  * Sets the size of the column in pixels.  This is meaningful only if the sizing
1705  * type is #GTK_TREE_VIEW_COLUMN_FIXED.  The size of the column is clamped to
1706  * the min/max width for the column.  Please note that the min/max width of the
1707  * column doesn't actually affect the "fixed_width" property of the widget, just
1708  * the actual size when displayed.
1709  **/
1710 void
1711 gtk_tree_view_column_set_fixed_width (GtkTreeViewColumn *tree_column,
1712                                       gint               fixed_width)
1713 {
1714   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
1715   g_return_if_fail (fixed_width > 0);
1716
1717   tree_column->fixed_width = fixed_width;
1718
1719   if (tree_column->tree_view &&
1720       GTK_WIDGET_REALIZED (tree_column->tree_view) &&
1721       tree_column->column_type == GTK_TREE_VIEW_COLUMN_FIXED)
1722     {
1723       gtk_widget_queue_resize (tree_column->tree_view);
1724     }
1725
1726   g_object_notify (G_OBJECT (tree_column), "fixed_width");
1727 }
1728
1729 /**
1730  * gtk_tree_view_column_get_fixed_width:
1731  * @tree_column: a #GtkTreeViewColumn
1732  *
1733  * Gets the fixed width of the column.  This value is only meaning may not be
1734  * the actual width of the column on the screen, just what is requested.
1735  *
1736  * Return value: the fixed width of the column
1737  **/
1738 gint
1739 gtk_tree_view_column_get_fixed_width (GtkTreeViewColumn *tree_column)
1740 {
1741   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), 0);
1742
1743   return tree_column->fixed_width;
1744 }
1745
1746 /**
1747  * gtk_tree_view_column_set_min_width:
1748  * @tree_column: A #GtkTreeViewColumn.
1749  * @min_width: The minimum width of the column in pixels, or -1.
1750  *
1751  * Sets the minimum width of the @tree_column.  If @min_width is -1, then the
1752  * minimum width is unset.
1753  **/
1754 void
1755 gtk_tree_view_column_set_min_width (GtkTreeViewColumn *tree_column,
1756                                     gint               min_width)
1757 {
1758   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
1759   g_return_if_fail (min_width >= -1);
1760
1761   if (min_width == tree_column->min_width)
1762     return;
1763
1764   if (tree_column->visible &&
1765       tree_column->tree_view != NULL &&
1766       GTK_WIDGET_REALIZED (tree_column->tree_view))
1767     {
1768       if (min_width > tree_column->width)
1769         gtk_widget_queue_resize (tree_column->tree_view);
1770     }
1771
1772   tree_column->min_width = min_width;
1773   g_object_freeze_notify (G_OBJECT (tree_column));
1774   if (tree_column->max_width != -1 && tree_column->max_width < min_width)
1775     {
1776       tree_column->max_width = min_width;
1777       g_object_notify (G_OBJECT (tree_column), "max_width");
1778     }
1779   g_object_notify (G_OBJECT (tree_column), "min_width");
1780   g_object_thaw_notify (G_OBJECT (tree_column));
1781
1782   if (tree_column->column_type == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
1783     _gtk_tree_view_column_autosize (GTK_TREE_VIEW (tree_column->tree_view),
1784                                     tree_column);
1785 }
1786
1787 /**
1788  * gtk_tree_view_column_get_min_width:
1789  * @tree_column: A #GtkTreeViewColumn.
1790  *
1791  * Returns the minimum width in pixels of the @tree_column, or -1 if no minimum
1792  * width is set.
1793  *
1794  * Return value: The minimum width of the @tree_column.
1795  **/
1796 gint
1797 gtk_tree_view_column_get_min_width (GtkTreeViewColumn *tree_column)
1798 {
1799   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), -1);
1800
1801   return tree_column->min_width;
1802 }
1803
1804 /**
1805  * gtk_tree_view_column_set_max_width:
1806  * @tree_column: A #GtkTreeViewColumn.
1807  * @max_width: The maximum width of the column in pixels, or -1.
1808  *
1809  * Sets the maximum width of the @tree_column.  If @max_width is -1, then the
1810  * maximum width is unset.  Note, the column can actually be wider than max
1811  * width if it's the last column in a view.  In this case, the column expands to
1812  * fill any extra space.
1813  **/
1814 void
1815 gtk_tree_view_column_set_max_width (GtkTreeViewColumn *tree_column,
1816                                     gint               max_width)
1817 {
1818   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
1819   g_return_if_fail (max_width >= -1);
1820
1821   if (max_width == tree_column->max_width)
1822     return;
1823
1824   if (tree_column->visible &&
1825       tree_column->tree_view != NULL &&
1826       GTK_WIDGET_REALIZED (tree_column->tree_view))
1827     {
1828       if (max_width != -1 && max_width < tree_column->width)
1829         gtk_widget_queue_resize (tree_column->tree_view);
1830     }
1831
1832   tree_column->max_width = max_width;
1833   g_object_freeze_notify (G_OBJECT (tree_column));
1834   if (max_width != -1 && max_width < tree_column->min_width)
1835     {
1836       tree_column->min_width = max_width;
1837       g_object_notify (G_OBJECT (tree_column), "min_width");
1838     }
1839   g_object_notify (G_OBJECT (tree_column), "max_width");
1840   g_object_thaw_notify (G_OBJECT (tree_column));
1841
1842   if (tree_column->column_type == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
1843     _gtk_tree_view_column_autosize (GTK_TREE_VIEW (tree_column->tree_view),
1844                                     tree_column);
1845 }
1846
1847 /**
1848  * gtk_tree_view_column_get_max_width:
1849  * @tree_column: A #GtkTreeViewColumn.
1850  *
1851  * Returns the maximum width in pixels of the @tree_column, or -1 if no maximum
1852  * width is set.
1853  *
1854  * Return value: The maximum width of the @tree_column.
1855  **/
1856 gint
1857 gtk_tree_view_column_get_max_width (GtkTreeViewColumn *tree_column)
1858 {
1859   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), -1);
1860
1861   return tree_column->max_width;
1862 }
1863
1864 /**
1865  * gtk_tree_view_column_clicked:
1866  * @tree_column: a #GtkTreeViewColumn
1867  *
1868  * Emits the "clicked" signal on the column.  This function will only work if
1869  * @tree_column is clickable.
1870  **/
1871 void
1872 gtk_tree_view_column_clicked (GtkTreeViewColumn *tree_column)
1873 {
1874   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
1875
1876   if (tree_column->visible &&
1877       tree_column->button &&
1878       tree_column->clickable)
1879     gtk_button_clicked (GTK_BUTTON (tree_column->button));
1880 }
1881
1882 /**
1883  * gtk_tree_view_column_set_title:
1884  * @tree_column: A #GtkTreeViewColumn.
1885  * @title: The title of the @tree_column.
1886  *
1887  * Sets the title of the @tree_column.  If a custom widget has been set, then
1888  * this value is ignored.
1889  **/
1890 void
1891 gtk_tree_view_column_set_title (GtkTreeViewColumn *tree_column,
1892                                 const gchar       *title)
1893 {
1894   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
1895
1896   g_free (tree_column->title);
1897   if (title)
1898     tree_column->title = g_strdup (title);
1899   else
1900     tree_column->title = NULL;
1901
1902   gtk_tree_view_column_update_button (tree_column);
1903   g_object_notify (G_OBJECT (tree_column), "title");
1904 }
1905
1906 /**
1907  * gtk_tree_view_column_get_title:
1908  * @tree_column: A #GtkTreeViewColumn.
1909  *
1910  * Returns the title of the widget.
1911  *
1912  * Return value: the title of the column. This string should not be
1913  * modified or freed.
1914  **/
1915 G_CONST_RETURN gchar *
1916 gtk_tree_view_column_get_title (GtkTreeViewColumn *tree_column)
1917 {
1918   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), NULL);
1919
1920   return tree_column->title;
1921 }
1922
1923 /**
1924  * gtk_tree_view_column_set_clickable:
1925  * @tree_column: A #GtkTreeViewColumn.
1926  * @clickable: %TRUE if the header is active.
1927  *
1928  * Sets the header to be active if @active is %TRUE.  When the header is active,
1929  * then it can take keyboard focus, and can be clicked.
1930  **/
1931 void
1932 gtk_tree_view_column_set_clickable (GtkTreeViewColumn *tree_column,
1933                                     gboolean           clickable)
1934 {
1935   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
1936
1937   clickable = !! clickable;
1938   if (tree_column->clickable == clickable)
1939     return;
1940
1941   tree_column->clickable = clickable;
1942   gtk_tree_view_column_update_button (tree_column);
1943   g_object_notify (G_OBJECT (tree_column), "clickable");
1944 }
1945
1946 /**
1947  * gtk_tree_view_column_get_clickable:
1948  * @tree_column: a #GtkTreeViewColumn
1949  *
1950  * Returns %TRUE if the user can click on the header for the column.
1951  *
1952  * Return value: %TRUE if user can click the column header.
1953  **/
1954 gboolean
1955 gtk_tree_view_column_get_clickable (GtkTreeViewColumn *tree_column)
1956 {
1957   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), FALSE);
1958
1959   return tree_column->clickable;
1960 }
1961
1962 /**
1963  * gtk_tree_view_column_set_widget:
1964  * @tree_column: A #GtkTreeViewColumn.
1965  * @widget: A child #GtkWidget, or %NULL.
1966  *
1967  * Sets the widget in the header to be @widget.  If widget is %NULL, then the
1968  * header button is set with a #GtkLabel set to the title of @tree_column.
1969  **/
1970 void
1971 gtk_tree_view_column_set_widget (GtkTreeViewColumn *tree_column,
1972                                  GtkWidget         *widget)
1973 {
1974   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
1975   g_return_if_fail (widget == NULL || GTK_IS_WIDGET (widget));
1976
1977   if (widget)
1978     {
1979       gtk_object_ref (GTK_OBJECT (widget));
1980       gtk_object_sink (GTK_OBJECT (widget));
1981     }
1982
1983   if (tree_column->child)
1984     gtk_object_unref (GTK_OBJECT (tree_column->child));
1985
1986   tree_column->child = widget;
1987   gtk_tree_view_column_update_button (tree_column);
1988   g_object_notify (G_OBJECT (tree_column), "widget");
1989 }
1990
1991 /**
1992  * gtk_tree_view_column_get_widget:
1993  * @tree_column: A #GtkTreeViewColumn.
1994  *
1995  * Returns the #GtkWidget in the button on the column header.  If a custom
1996  * widget has not been set then %NULL is returned.
1997  *
1998  * Return value: The #GtkWidget in the column header, or %NULL
1999  **/
2000 GtkWidget *
2001 gtk_tree_view_column_get_widget (GtkTreeViewColumn *tree_column)
2002 {
2003   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), NULL);
2004
2005   return tree_column->child;
2006 }
2007
2008 /**
2009  * gtk_tree_view_column_set_alignment:
2010  * @tree_column: A #GtkTreeViewColumn.
2011  * @xalign: The alignment, which is between [0.0 and 1.0] inclusive.
2012  *
2013  * Sets the alignment of the title or custom widget inside the column header.
2014  * The alignment determines its location inside the button -- 0.0 for left, 0.5
2015  * for center, 1.0 for right.
2016  **/
2017 void
2018 gtk_tree_view_column_set_alignment (GtkTreeViewColumn *tree_column,
2019                                     gfloat             xalign)
2020 {
2021   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
2022
2023   xalign = CLAMP (xalign, 0.0, 1.0);
2024
2025   if (tree_column->xalign == xalign)
2026     return;
2027
2028   tree_column->xalign = xalign;
2029   gtk_tree_view_column_update_button (tree_column);
2030   g_object_notify (G_OBJECT (tree_column), "alignment");
2031 }
2032
2033 /**
2034  * gtk_tree_view_column_get_alignment:
2035  * @tree_column: A #GtkTreeViewColumn.
2036  *
2037  * Returns the current x alignment of @tree_column.  This value can range
2038  * between 0.0 and 1.0.
2039  *
2040  * Return value: The current alignent of @tree_column.
2041  **/
2042 gfloat
2043 gtk_tree_view_column_get_alignment (GtkTreeViewColumn *tree_column)
2044 {
2045   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), 0.5);
2046
2047   return tree_column->xalign;
2048 }
2049
2050 /**
2051  * gtk_tree_view_column_set_reorderable:
2052  * @tree_column: A #GtkTreeViewColumn
2053  * @reorderable: #TRUE, if the column can be reordered.
2054  *
2055  * If @reorderable is #TRUE, then the column can be reordered by the end user
2056  * dragging the header.
2057  **/
2058 void
2059 gtk_tree_view_column_set_reorderable (GtkTreeViewColumn *tree_column,
2060                                       gboolean           reorderable)
2061 {
2062   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
2063
2064   /*  if (reorderable)
2065       gtk_tree_view_column_set_clickable (tree_column, TRUE);*/
2066
2067   if (tree_column->reorderable == (reorderable?TRUE:FALSE))
2068     return;
2069
2070   tree_column->reorderable = (reorderable?TRUE:FALSE);
2071   gtk_tree_view_column_update_button (tree_column);
2072   g_object_notify (G_OBJECT (tree_column), "reorderable");
2073 }
2074
2075 /**
2076  * gtk_tree_view_column_get_reorderable:
2077  * @tree_column: A #GtkTreeViewColumn
2078  *
2079  * Returns #TRUE if the @tree_column can be reordered by the user.
2080  *
2081  * Return value: #TRUE if the @tree_column can be reordered by the user.
2082  **/
2083 gboolean
2084 gtk_tree_view_column_get_reorderable (GtkTreeViewColumn *tree_column)
2085 {
2086   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), FALSE);
2087
2088   return tree_column->reorderable;
2089 }
2090
2091
2092 /**
2093  * gtk_tree_view_column_set_sort_column_id:
2094  * @tree_column: a #GtkTreeViewColumn
2095  * @sort_column_id: The @sort_column_id of the model to sort on.
2096  *
2097  * Sets the logical @sort_column_id that this column sorts on when this column
2098  * is selected for sorting.  Doing so makes the column header clickable.
2099  **/
2100 void
2101 gtk_tree_view_column_set_sort_column_id (GtkTreeViewColumn *tree_column,
2102                                          gint               sort_column_id)
2103 {
2104   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
2105   g_return_if_fail (sort_column_id >= 0);
2106
2107   if (tree_column->sort_column_id == sort_column_id)
2108     return;
2109
2110   tree_column->sort_column_id = sort_column_id;
2111
2112   /* Handle unsetting the id */
2113   if (sort_column_id == -1)
2114     {
2115       if (tree_column->sort_clicked_signal)
2116         {
2117           g_signal_handler_disconnect (G_OBJECT (tree_column), tree_column->sort_clicked_signal);
2118           tree_column->sort_clicked_signal = 0;
2119         }
2120
2121       if (tree_column->sort_column_changed_signal)
2122         {
2123           g_signal_handler_disconnect (G_OBJECT (tree_column), tree_column->sort_column_changed_signal);
2124           tree_column->sort_column_changed_signal = 0;
2125         }
2126
2127       gtk_tree_view_column_set_sort_order (tree_column, GTK_SORT_ASCENDING);
2128       gtk_tree_view_column_set_sort_indicator (tree_column, FALSE);
2129       return;
2130     }
2131
2132   gtk_tree_view_column_set_clickable (tree_column, TRUE);
2133
2134   if (! tree_column->sort_clicked_signal)
2135     tree_column->sort_clicked_signal = g_signal_connect (G_OBJECT (tree_column),
2136                                                          "clicked",
2137                                                          G_CALLBACK (gtk_tree_view_column_sort),
2138                                                          NULL);
2139
2140   gtk_tree_view_column_setup_sort_column_id_callback (tree_column);
2141 }
2142
2143 /**
2144  * gtk_tree_view_column_get_sort_column_id:
2145  * @tree_column: a #GtkTreeViewColumn
2146  *
2147  * Gets the logical @sort_column_id that the model sorts on when this
2148  * column is selected for sorting.
2149  * See gtk_tree_view_column_set_sort_column_id().
2150  *
2151  * Return value: the current @sort_column_id for this column, or -1 if
2152  *               this column can't be used for sorting.
2153  **/
2154 gint
2155 gtk_tree_view_column_get_sort_column_id (GtkTreeViewColumn *tree_column)
2156 {
2157   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), 0);
2158
2159   return tree_column->sort_column_id;
2160 }
2161
2162 /**
2163  * gtk_tree_view_column_set_sort_indicator:
2164  * @tree_column: a #GtkTreeViewColumn
2165  * @setting: %TRUE to display an indicator that the column is sorted
2166  *
2167  * Call this function with a @setting of %TRUE to display an arrow in
2168  * the header button indicating the column is sorted. Call
2169  * gtk_tree_view_column_set_sort_order() to change the direction of
2170  * the arrow.
2171  *
2172  **/
2173 void
2174 gtk_tree_view_column_set_sort_indicator (GtkTreeViewColumn     *tree_column,
2175                                          gboolean               setting)
2176 {
2177   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
2178
2179   setting = setting != FALSE;
2180
2181   if (setting == tree_column->show_sort_indicator)
2182     return;
2183
2184   tree_column->show_sort_indicator = setting;
2185   gtk_tree_view_column_update_button (tree_column);
2186   g_object_notify (G_OBJECT (tree_column), "sort_indicator");
2187 }
2188
2189 /**
2190  * gtk_tree_view_column_get_sort_indicator:
2191  * @tree_column: a #GtkTreeViewColumn
2192  *
2193  * Gets the value set by gtk_tree_view_column_set_sort_indicator().
2194  *
2195  * Return value: whether the sort indicator arrow is displayed
2196  **/
2197 gboolean
2198 gtk_tree_view_column_get_sort_indicator  (GtkTreeViewColumn     *tree_column)
2199 {
2200   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), FALSE);
2201
2202   return tree_column->show_sort_indicator;
2203 }
2204
2205 /**
2206  * gtk_tree_view_column_set_sort_order:
2207  * @tree_column: a #GtkTreeViewColumn
2208  * @order: sort order that the sort indicator should indicate
2209  *
2210  * Changes the appearance of the sort indicator.
2211  *
2212  * This <emphasis>does not</emphasis> actually sort the model.  Use
2213  * gtk_tree_view_column_set_sort_column_id() if you want automatic sorting
2214  * support.  This function is primarily for custom sorting behavior, and should
2215  * be used in conjunction with gtk_tree_sortable_set_sort_column() to do
2216  * that. For custom models, the mechanism will vary.
2217  *
2218  * The sort indicator changes direction to indicate normal sort or reverse sort.
2219  * Note that you must have the sort indicator enabled to see anything when
2220  * calling this function; see gtk_tree_view_column_set_sort_indicator().
2221  **/
2222 void
2223 gtk_tree_view_column_set_sort_order      (GtkTreeViewColumn     *tree_column,
2224                                           GtkSortType            order)
2225 {
2226   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
2227
2228   if (order == tree_column->sort_order)
2229     return;
2230
2231   tree_column->sort_order = order;
2232   gtk_tree_view_column_update_button (tree_column);
2233   g_object_notify (G_OBJECT (tree_column), "sort_order");
2234 }
2235
2236 /**
2237  * gtk_tree_view_column_get_sort_order:
2238  * @tree_column: a #GtkTreeViewColumn
2239  *
2240  * Gets the value set by gtk_tree_view_column_set_sort_order().
2241  *
2242  * Return value: the sort order the sort indicator is indicating
2243  **/
2244 GtkSortType
2245 gtk_tree_view_column_get_sort_order      (GtkTreeViewColumn     *tree_column)
2246 {
2247   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), 0);
2248
2249   return tree_column->sort_order;
2250 }
2251
2252 /**
2253  * gtk_tree_view_column_cell_set_cell_data:
2254  * @tree_column: A #GtkTreeViewColumn.
2255  * @tree_model: The #GtkTreeModel to to get the cell renderers attributes from.
2256  * @iter: The #GtkTreeIter to to get the cell renderer's attributes from.
2257  * @is_expander: %TRUE, if the row has children
2258  * @is_expanded: %TRUE, if the row has visible children
2259  *
2260  * Sets the cell renderer based on the @tree_model and @iter.  That is, for
2261  * every attribute mapping in @tree_column, it will get a value from the set
2262  * column on the @iter, and use that value to set the attribute on the cell
2263  * renderer.  This is used primarily by the #GtkTreeView.
2264  **/
2265 void
2266 gtk_tree_view_column_cell_set_cell_data (GtkTreeViewColumn *tree_column,
2267                                          GtkTreeModel      *tree_model,
2268                                          GtkTreeIter       *iter,
2269                                          gboolean           is_expander,
2270                                          gboolean           is_expanded)
2271 {
2272   GSList *list;
2273   GValue value = { 0, };
2274   GList *cell_list;
2275
2276   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
2277   g_return_if_fail (tree_column->cell_list != NULL);
2278
2279   if (tree_model == NULL)
2280     return;
2281
2282   for (cell_list = tree_column->cell_list; cell_list; cell_list = cell_list->next)
2283     {
2284       GtkTreeViewColumnCellInfo *info = (GtkTreeViewColumnCellInfo *) cell_list->data;
2285       GObject *cell = (GObject *) info->cell;
2286
2287       list = info->attributes;
2288
2289       g_object_freeze_notify (cell);
2290       g_object_set (cell, "is_expander", is_expander, "is_expanded", is_expanded, NULL);
2291
2292       while (list && list->next)
2293         {
2294           gtk_tree_model_get_value (tree_model, iter,
2295                                     GPOINTER_TO_INT (list->next->data),
2296                                     &value);
2297           g_object_set_property (cell, (gchar *) list->data, &value);
2298           g_value_unset (&value);
2299           list = list->next->next;
2300         }
2301
2302       if (info->func)
2303         (* info->func) (tree_column, info->cell, tree_model, iter, info->func_data);
2304       g_object_thaw_notify (G_OBJECT (info->cell));
2305     }
2306
2307 }
2308
2309 /**
2310  * gtk_tree_view_column_cell_get_size:
2311  * @tree_column: A #GtkTreeViewColumn.
2312  * @cell_area: The area a cell in the column will be allocated, or %NULL
2313  * @x_offset: location to return x offset of a cell relative to @cell_area, or %NULL
2314  * @y_offset: location to return y offset of a cell relative to @cell_area, or %NULL
2315  * @width: location to return width needed to render a cell, or %NULL
2316  * @height: location to return height needed to render a cell, or %NULL
2317  *
2318  * Obtains the width and height needed to render the column.  This is used
2319  * primarily by the #GtkTreeView.
2320  **/
2321 void
2322 gtk_tree_view_column_cell_get_size (GtkTreeViewColumn *tree_column,
2323                                     GdkRectangle      *cell_area,
2324                                     gint              *x_offset,
2325                                     gint              *y_offset,
2326                                     gint              *width,
2327                                     gint              *height)
2328 {
2329   GList *list;
2330   gboolean first_cell = TRUE;
2331   gint focus_line_width;
2332
2333   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
2334
2335   if (height)
2336     * height = 0;
2337   if (width)
2338     * width = 0;
2339
2340   gtk_widget_style_get (tree_column->tree_view, "focus-line-width", &focus_line_width, NULL);
2341
2342   for (list = tree_column->cell_list; list; list = list->next)
2343     {
2344       GtkTreeViewColumnCellInfo *info = (GtkTreeViewColumnCellInfo *) list->data;
2345       gboolean visible;
2346       gint new_height = 0;
2347       gint new_width = 0;
2348       g_object_get (info->cell, "visible", &visible, NULL);
2349
2350       if (visible == FALSE)
2351         continue;
2352
2353       if (first_cell == FALSE && *width)
2354         *width += tree_column->spacing;
2355
2356       gtk_cell_renderer_get_size (info->cell,
2357                                   tree_column->tree_view,
2358                                   cell_area,
2359                                   x_offset,
2360                                   y_offset,
2361                                   &new_width,
2362                                   &new_height);
2363
2364       if (height)
2365         * height = MAX (*height, new_height + focus_line_width * 2);
2366       info->requested_width = MAX (info->requested_width, new_width + focus_line_width * 2);
2367       if (width)
2368         * width += info->requested_width;
2369       first_cell = FALSE;
2370     }
2371 }
2372
2373 /* both rendering and rendering focus are somewhat complicated, and a bit of
2374  * code.  Rather than duplicate them, we put them together to keep the code in
2375  * one place
2376  */
2377 enum {
2378   CELL_ACTION_RENDER,
2379   CELL_ACTION_FOCUS,
2380   CELL_ACTION_EVENT
2381 };
2382
2383 static gboolean
2384 gtk_tree_view_column_cell_process_action (GtkTreeViewColumn  *tree_column,
2385                                           GdkWindow          *window,
2386                                           GdkRectangle       *background_area,
2387                                           GdkRectangle       *cell_area,
2388                                           guint               flags,
2389                                           gint                action,
2390                                           GdkRectangle       *expose_area,     /* RENDER */
2391                                           GdkRectangle       *focus_rectangle, /* FOCUS  */
2392                                           GtkCellEditable   **editable_widget, /* EVENT  */
2393                                           GdkEvent           *event,           /* EVENT  */
2394                                           gchar              *path_string)     /* EVENT  */
2395 {
2396   GList *list;
2397   GdkRectangle real_cell_area;
2398   GdkRectangle real_background_area;
2399   gint expand_cell_count = 0;
2400   gint full_requested_width = 0;
2401   gint extra_space;
2402   gint min_x, min_y, max_x, max_y;
2403   gint focus_line_width;
2404   gint dx;
2405   gint special_cells;
2406
2407   min_x = G_MAXINT;
2408   min_y = G_MAXINT;
2409   max_x = 0;
2410   max_y = 0;
2411
2412   special_cells = _gtk_tree_view_column_count_special_cells (tree_column);
2413
2414   if (special_cells > 1 && action == CELL_ACTION_FOCUS)
2415     {
2416       GtkTreeViewColumnCellInfo *info = NULL;
2417       gboolean found_has_focus = FALSE;
2418
2419       /* one should have focus */
2420       for (list = tree_column->cell_list; list; list = list->next)
2421         {
2422           info = list->data;
2423           if (info && info->has_focus)
2424             {
2425               found_has_focus = TRUE;
2426               break;
2427             }
2428         }
2429
2430       if (!found_has_focus)
2431         {
2432           /* give the first one focus */
2433           info = gtk_tree_view_column_cell_first (tree_column)->data;
2434           info->has_focus = TRUE;
2435         }
2436     }
2437
2438   gtk_widget_style_get (GTK_WIDGET (tree_column->tree_view),
2439                         "focus-line-width", &focus_line_width,
2440                         NULL);
2441
2442   real_cell_area = *cell_area;
2443   real_background_area = *background_area;
2444   dx = real_cell_area.x - real_background_area.x - focus_line_width;
2445
2446   real_cell_area.x += focus_line_width;
2447
2448   /* Find out how many extra space we have to allocate */
2449   for (list = tree_column->cell_list; list; list = list->next)
2450     {
2451       GtkTreeViewColumnCellInfo *info = (GtkTreeViewColumnCellInfo *)list->data;
2452
2453       if (! info->cell->visible)
2454         continue;
2455
2456       if (info->expand == TRUE)
2457         expand_cell_count ++;
2458       full_requested_width += info->requested_width;
2459     }
2460
2461   extra_space = background_area->width - full_requested_width;
2462   if (extra_space < 0)
2463     extra_space = 0;
2464   else if (extra_space > 0 && expand_cell_count > 0)
2465     extra_space /= expand_cell_count;
2466
2467   /* iterate list for GTK_PACK_START cells */
2468   for (list = tree_column->cell_list; list; list = list->next)
2469     {
2470       GtkTreeViewColumnCellInfo *info = (GtkTreeViewColumnCellInfo *) list->data;
2471
2472       if (info->pack == GTK_PACK_END)
2473         continue;
2474
2475       if (! info->cell->visible)
2476         continue;
2477
2478       real_background_area.width = info->requested_width +
2479         (info->expand?extra_space:0);
2480       info->real_width = real_background_area.width;
2481
2482       real_cell_area.width = real_background_area.width;
2483       real_cell_area.width -= 2 * focus_line_width;
2484
2485       if (action == CELL_ACTION_RENDER)
2486         {
2487           gtk_cell_renderer_render (info->cell,
2488                                     window,
2489                                     tree_column->tree_view,
2490                                     &real_background_area,
2491                                     &real_cell_area,
2492                                     expose_area,
2493                                     flags);
2494         }
2495       else if (action == CELL_ACTION_FOCUS)
2496         {
2497           gint x_offset, y_offset, width, height;
2498
2499           gtk_cell_renderer_get_size (info->cell,
2500                                       tree_column->tree_view,
2501                                       &real_cell_area,
2502                                       &x_offset, &y_offset,
2503                                       &width, &height);
2504
2505           if (special_cells > 1)
2506             {
2507               if (info->has_focus)
2508                 {
2509                   min_x = real_cell_area.x + x_offset;
2510                   max_x = min_x + width;
2511                   min_y = real_cell_area.y + y_offset;
2512                   max_y = min_y + height;
2513                 }
2514             }
2515           else
2516             {
2517               if (min_x > (real_cell_area.x + x_offset))
2518                 min_x = real_cell_area.x + x_offset;
2519               if (max_x < real_cell_area.x + x_offset + width)
2520                 max_x = real_cell_area.x + x_offset + width;
2521               if (min_y > (real_cell_area.y + y_offset))
2522                 min_y = real_cell_area.y + y_offset;
2523               if (max_y < real_cell_area.y + y_offset + height)
2524                 max_y = real_cell_area.y + y_offset + height;
2525             }
2526         }
2527       else if (action == CELL_ACTION_EVENT)
2528         {
2529           gboolean try_event = FALSE;
2530
2531           if (event)
2532             {
2533               if (special_cells == 1)
2534                 {
2535                   /* only 1 activatable cell -> whole column can activate */
2536                   if (cell_area->x <= ((GdkEventButton *)event)->x &&
2537                       cell_area->x + cell_area->width > ((GdkEventButton *)event)->x)
2538                     try_event = TRUE;
2539                 }
2540               else if (real_cell_area.x <= ((GdkEventButton *)event)->x &&
2541                   real_cell_area.x + real_cell_area.width > ((GdkEventButton *)event)->x)
2542                   /* only activate cell if the user clicked on an individual
2543                    * cell
2544                    */
2545                 try_event = TRUE;
2546             }
2547           else if (special_cells > 1 && info->has_focus)
2548             try_event = TRUE;
2549           else if (special_cells == 1)
2550             try_event = TRUE;
2551
2552           if (try_event)
2553             {
2554               gboolean visible, mode;
2555
2556               g_object_get (G_OBJECT (info->cell),
2557                             "visible", &visible,
2558                             "mode", &mode,
2559                             NULL);
2560               if (visible && mode == GTK_CELL_RENDERER_MODE_ACTIVATABLE)
2561                 {
2562                   if (gtk_cell_renderer_activate (info->cell,
2563                                                   event,
2564                                                   tree_column->tree_view,
2565                                                   path_string,
2566                                                   background_area,
2567                                                   cell_area,
2568                                                   flags))
2569                     return TRUE;
2570                 }
2571               else if (visible && mode == GTK_CELL_RENDERER_MODE_EDITABLE)
2572                 {
2573                   *editable_widget =
2574                     gtk_cell_renderer_start_editing (info->cell,
2575                                                      event,
2576                                                      tree_column->tree_view,
2577                                                      path_string,
2578                                                      background_area,
2579                                                      cell_area,
2580                                                      flags);
2581
2582                   if (*editable_widget != NULL)
2583                     {
2584                       g_return_val_if_fail (GTK_IS_CELL_EDITABLE (*editable_widget), FALSE);
2585                       info->in_editing_mode = TRUE;
2586                       gtk_tree_view_column_focus_cell (tree_column, info->cell);
2587
2588                       return TRUE;
2589                     }
2590                 }
2591             }
2592         }
2593
2594       real_cell_area.x += (info->real_width + tree_column->spacing);
2595       real_background_area.x += (info->real_width + tree_column->spacing);
2596     }
2597
2598   /* iterate list for PACK_END cells */
2599   for (list = g_list_last (tree_column->cell_list); list; list = list->prev)
2600     {
2601       GtkTreeViewColumnCellInfo *info = (GtkTreeViewColumnCellInfo *) list->data;
2602
2603       if (info->pack == GTK_PACK_START)
2604         continue;
2605
2606       if (! info->cell->visible)
2607         continue;
2608
2609       real_background_area.width = info->requested_width +
2610         (info->expand?extra_space:0);
2611       info->real_width = real_background_area.width;
2612
2613       real_cell_area.width = real_background_area.width;
2614       real_cell_area.width -= 2 * focus_line_width;
2615
2616       if (action == CELL_ACTION_RENDER)
2617         {
2618           gtk_cell_renderer_render (info->cell,
2619                                     window,
2620                                     tree_column->tree_view,
2621                                     &real_background_area,
2622                                     &real_cell_area,
2623                                     expose_area,
2624                                     flags);
2625         }
2626       else if (action == CELL_ACTION_FOCUS)
2627         {
2628           gint x_offset, y_offset, width, height;
2629
2630           gtk_cell_renderer_get_size (info->cell,
2631                                       tree_column->tree_view,
2632                                       &real_cell_area,
2633                                       &x_offset, &y_offset,
2634                                       &width, &height);
2635
2636           if (special_cells > 1)
2637             {
2638               if (info->has_focus)
2639                 {
2640                   min_x = real_cell_area.x + x_offset;
2641                   max_x = min_x + width;
2642                   min_y = real_cell_area.y + y_offset;
2643                   max_y = min_y + height;
2644                 }
2645             }
2646           else
2647             {
2648               if (min_x > (real_cell_area.x + x_offset))
2649                 min_x = real_cell_area.x + x_offset;
2650               if (max_x < real_cell_area.x + x_offset + width)
2651                 max_x = real_cell_area.x + x_offset + width;
2652               if (min_y > (real_cell_area.y + y_offset))
2653                 min_y = real_cell_area.y + y_offset;
2654               if (max_y < real_cell_area.y + y_offset + height)
2655                 max_y = real_cell_area.y + y_offset + height;
2656             }
2657         }
2658       else if (action == CELL_ACTION_EVENT)
2659         {
2660           gboolean try_event = FALSE;
2661
2662           if (event)
2663             {
2664               if (special_cells == 1)
2665                 {
2666                   /* only 1 activatable cell -> whole column can activate */
2667                   if (cell_area->x <= ((GdkEventButton *)event)->x &&
2668                       cell_area->x + cell_area->width > ((GdkEventButton *)event)->x)
2669                     try_event = TRUE;
2670                 }
2671               else if (real_cell_area.x <= ((GdkEventButton *)event)->x &&
2672                   real_cell_area.x + real_cell_area.width > ((GdkEventButton *)event)->x)
2673                 /* only activate cell if the user clicked on an individual
2674                  * cell
2675                  */
2676                 try_event = TRUE;
2677             }
2678           else if (special_cells > 1 && info->has_focus)
2679             try_event = TRUE;
2680           else if (special_cells == 1)
2681             try_event = TRUE;
2682
2683           if (try_event)
2684             {
2685               gboolean visible, mode;
2686
2687               g_object_get (G_OBJECT (info->cell),
2688                             "visible", &visible,
2689                             "mode", &mode,
2690                             NULL);
2691               if (visible && mode == GTK_CELL_RENDERER_MODE_ACTIVATABLE)
2692                 {
2693                   if (gtk_cell_renderer_activate (info->cell,
2694                                                   event,
2695                                                   tree_column->tree_view,
2696                                                   path_string,
2697                                                   background_area,
2698                                                   cell_area,
2699                                                   flags))
2700                     return TRUE;
2701                 }
2702               else if (visible && mode == GTK_CELL_RENDERER_MODE_EDITABLE)
2703                 {
2704                   *editable_widget =
2705                     gtk_cell_renderer_start_editing (info->cell,
2706                                                      event,
2707                                                      tree_column->tree_view,
2708                                                      path_string,
2709                                                      background_area,
2710                                                      cell_area,
2711                                                      flags);
2712
2713                   if (*editable_widget != NULL)
2714                     {
2715                       g_return_val_if_fail (GTK_IS_CELL_EDITABLE (*editable_widget), FALSE);
2716                       info->in_editing_mode = TRUE;
2717                       gtk_tree_view_column_focus_cell (tree_column, info->cell);
2718
2719                       return TRUE;
2720                     }
2721                 }
2722             }
2723         }
2724
2725       real_cell_area.x += (info->real_width + tree_column->spacing);
2726       real_background_area.x += (info->real_width + tree_column->spacing);
2727     }
2728
2729   /* fill focus_rectangle when required */
2730   if (action == CELL_ACTION_FOCUS)
2731     {
2732       if (min_x >= max_x || min_y >= max_y)
2733         {
2734           *focus_rectangle = *cell_area;
2735           /* don't change the focus_rectangle, just draw it nicely inside
2736            * the cell area */
2737         }
2738       else
2739         {
2740           focus_rectangle->x = min_x - focus_line_width;
2741           focus_rectangle->y = min_y - focus_line_width;
2742           focus_rectangle->width = (max_x - min_x) + 2 * focus_line_width;
2743           focus_rectangle->height = (max_y - min_y) + 2 * focus_line_width;
2744         }
2745     }
2746
2747   return FALSE;
2748 }
2749
2750 /**
2751  * gtk_tree_view_column_cell_render:
2752  * @tree_column: A #GtkTreeViewColumn.
2753  * @window: a #GdkDrawable to draw to
2754  * @background_area: entire cell area (including tree expanders and maybe padding on the sides)
2755  * @cell_area: area normally rendered by a cell renderer
2756  * @expose_area: area that actually needs updating
2757  * @flags: flags that affect rendering
2758  *
2759  * Renders the cell contained by #tree_column. This is used primarily by the
2760  * #GtkTreeView.
2761  **/
2762 void
2763 _gtk_tree_view_column_cell_render (GtkTreeViewColumn *tree_column,
2764                                    GdkWindow         *window,
2765                                    GdkRectangle      *background_area,
2766                                    GdkRectangle      *cell_area,
2767                                    GdkRectangle      *expose_area,
2768                                    guint              flags)
2769 {
2770   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
2771   g_return_if_fail (background_area != NULL);
2772   g_return_if_fail (cell_area != NULL);
2773   g_return_if_fail (expose_area != NULL);
2774
2775   gtk_tree_view_column_cell_process_action (tree_column,
2776                                             window,
2777                                             background_area,
2778                                             cell_area,
2779                                             flags,
2780                                             CELL_ACTION_RENDER,
2781                                             expose_area,
2782                                             NULL, NULL, NULL, NULL);
2783 }
2784
2785 gboolean
2786 _gtk_tree_view_column_cell_event (GtkTreeViewColumn  *tree_column,
2787                                   GtkCellEditable   **editable_widget,
2788                                   GdkEvent           *event,
2789                                   gchar              *path_string,
2790                                   GdkRectangle       *background_area,
2791                                   GdkRectangle       *cell_area,
2792                                   guint               flags)
2793 {
2794   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), FALSE);
2795
2796   return gtk_tree_view_column_cell_process_action (tree_column,
2797                                                    NULL,
2798                                                    background_area,
2799                                                    cell_area,
2800                                                    flags,
2801                                                    CELL_ACTION_EVENT,
2802                                                    NULL, NULL,
2803                                                    editable_widget,
2804                                                    event,
2805                                                    path_string);
2806 }
2807
2808 /* cell list manipulation */
2809 static GList *
2810 gtk_tree_view_column_cell_first (GtkTreeViewColumn *tree_column)
2811 {
2812   GList *list = tree_column->cell_list;
2813
2814   /* first GTK_PACK_START cell we find */
2815   for ( ; list; list = list->next)
2816     {
2817       GtkTreeViewColumnCellInfo *info = list->data;
2818       if (info->pack == GTK_PACK_START)
2819         return list;
2820     }
2821
2822   /* hmm, else the *last* GTK_PACK_END cell */
2823   list = g_list_last (tree_column->cell_list);
2824
2825   for ( ; list; list = list->prev)
2826     {
2827       GtkTreeViewColumnCellInfo *info = list->data;
2828       if (info->pack == GTK_PACK_END)
2829         return list;
2830     }
2831
2832   return NULL;
2833 }
2834
2835 static GList *
2836 gtk_tree_view_column_cell_last (GtkTreeViewColumn *tree_column)
2837 {
2838   GList *list = tree_column->cell_list;
2839
2840   /* *first* GTK_PACK_END cell we find */
2841   for ( ; list ; list = list->next)
2842     {
2843       GtkTreeViewColumnCellInfo *info = list->data;
2844       if (info->pack == GTK_PACK_END)
2845         return list;
2846     }
2847
2848   /* hmm, else the last GTK_PACK_START cell */
2849   list = g_list_last (tree_column->cell_list);
2850
2851   for ( ; list; list = list->prev)
2852     {
2853       GtkTreeViewColumnCellInfo *info = list->data;
2854       if (info->pack == GTK_PACK_START)
2855         return list;
2856     }
2857
2858   return NULL;
2859 }
2860
2861 static GList *
2862 gtk_tree_view_column_cell_next (GtkTreeViewColumn *tree_column,
2863                                 GList             *current)
2864 {
2865   GList *list;
2866   GtkTreeViewColumnCellInfo *info = current->data;
2867
2868   if (info->pack == GTK_PACK_START)
2869     {
2870       for (list = current->next; list; list = list->next)
2871         {
2872           GtkTreeViewColumnCellInfo *inf = list->data;
2873           if (inf->pack == GTK_PACK_START)
2874             return list;
2875         }
2876
2877       /* out of GTK_PACK_START cells, get *last* GTK_PACK_END one */
2878       list = g_list_last (tree_column->cell_list);
2879       for (; list; list = list->prev)
2880         {
2881           GtkTreeViewColumnCellInfo *inf = list->data;
2882           if (inf->pack == GTK_PACK_END)
2883             return list;
2884         }
2885     }
2886
2887   for (list = current->prev; list; list = list->prev)
2888     {
2889       GtkTreeViewColumnCellInfo *inf = list->data;
2890       if (inf->pack == GTK_PACK_END)
2891         return list;
2892     }
2893
2894   return NULL;
2895 }
2896
2897 static GList *
2898 gtk_tree_view_column_cell_prev (GtkTreeViewColumn *tree_column,
2899                                 GList             *current)
2900 {
2901   GList *list;
2902   GtkTreeViewColumnCellInfo *info = current->data;
2903
2904   if (info->pack == GTK_PACK_END)
2905     {
2906       for (list = current->next; list; list = list->next)
2907         {
2908           GtkTreeViewColumnCellInfo *inf = list->data;
2909           if (inf->pack == GTK_PACK_END)
2910             return list;
2911         }
2912
2913       /* out of GTK_PACK_END, get last GTK_PACK_START one */
2914       list = g_list_last (tree_column->cell_list);
2915       for ( ; list; list = list->prev)
2916         {
2917           GtkTreeViewColumnCellInfo *inf = list->data;
2918           if (inf->pack == GTK_PACK_START)
2919             return list;
2920         }
2921     }
2922
2923   for (list = current->prev; list; list = list->prev)
2924     {
2925       GtkTreeViewColumnCellInfo *inf = list->data;
2926       if (inf->pack == GTK_PACK_START)
2927         return list;
2928     }
2929
2930   return NULL;
2931 }
2932
2933 gboolean
2934 _gtk_tree_view_column_cell_focus (GtkTreeViewColumn *tree_column,
2935                                   gint               direction,
2936                                   gboolean           left,
2937                                   gboolean           right)
2938 {
2939   gint count;
2940
2941   count = _gtk_tree_view_column_count_special_cells (tree_column);
2942
2943   /* if we are the current focus column and have multiple editable cells,
2944    * try to select the next one, else move the focus to the next column
2945    */
2946   if (GTK_TREE_VIEW (tree_column->tree_view)->priv->focus_column == tree_column)
2947     {
2948       if (count > 1)
2949         {
2950           GList *next, *prev;
2951           GList *list = tree_column->cell_list;
2952           GtkTreeViewColumnCellInfo *info = NULL;
2953
2954           /* find current focussed cell */
2955           for ( ; list; list = list->next)
2956             {
2957               info = list->data;
2958               if (info->has_focus)
2959                 break;
2960             }
2961
2962           /* not a focussed cell in the focus column? */
2963           if (!list || !info || !info->has_focus)
2964             return FALSE;
2965
2966           next = gtk_tree_view_column_cell_next (tree_column, list);
2967           prev = gtk_tree_view_column_cell_prev (tree_column, list);
2968
2969           info->has_focus = FALSE;
2970           if (direction > 0 && next)
2971             {
2972               info = next->data;
2973               info->has_focus = TRUE;
2974               return TRUE;
2975             }
2976           else if (direction > 0 && !next && !right)
2977             {
2978               /* keep focus on latest cell */
2979               info = gtk_tree_view_column_cell_last (tree_column)->data;
2980               info->has_focus = TRUE;
2981               return TRUE;
2982             }
2983           else if (direction < 0 && prev)
2984             {
2985               info = prev->data;
2986               info->has_focus = TRUE;
2987               return TRUE;
2988             }
2989           else if (direction < 0 && !prev && !left)
2990             {
2991               /* keep focus on first cell */
2992               info = gtk_tree_view_column_cell_first (tree_column)->data;
2993               info->has_focus = TRUE;
2994               return TRUE;
2995             }
2996         }
2997       return FALSE;
2998     }
2999
3000   /* we get focus, if we have multiple editable cells, give the correct one
3001    * focus
3002    */
3003   if (count > 1)
3004     {
3005       GList *list = tree_column->cell_list;
3006
3007       /* clear focus first */
3008       for ( ; list ; list = list->next)
3009         {
3010           GtkTreeViewColumnCellInfo *info = list->data;
3011           if (info->has_focus)
3012             info->has_focus = FALSE;
3013         }
3014
3015       if (direction > 0)
3016         ((GtkTreeViewColumnCellInfo *)gtk_tree_view_column_cell_first (tree_column)->data)->has_focus = TRUE;
3017       else if (direction < 0)
3018         ((GtkTreeViewColumnCellInfo *)gtk_tree_view_column_cell_last (tree_column)->data)->has_focus = TRUE;
3019     }
3020   return TRUE;
3021 }
3022
3023 void
3024 _gtk_tree_view_column_cell_draw_focus (GtkTreeViewColumn       *tree_column,
3025                                        GdkWindow               *window,
3026                                        GdkRectangle            *background_area,
3027                                        GdkRectangle            *cell_area,
3028                                        GdkRectangle            *expose_area,
3029                                        guint                    flags)
3030 {
3031   gint focus_line_width;
3032   GtkStateType cell_state;
3033
3034   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
3035   gtk_widget_style_get (GTK_WIDGET (tree_column->tree_view),
3036                         "focus-line-width", &focus_line_width, NULL);
3037   if (tree_column->editable_widget)
3038     {
3039       /* This function is only called on the editable row when editing.
3040        */
3041 #if 0
3042       gtk_paint_focus (tree_column->tree_view->style,
3043                        window,
3044                        GTK_WIDGET_STATE (tree_column->tree_view),
3045                        NULL,
3046                        tree_column->tree_view,
3047                        "treeview",
3048                        cell_area->x - focus_line_width,
3049                        cell_area->y - focus_line_width,
3050                        cell_area->width + 2 * focus_line_width,
3051                        cell_area->height + 2 * focus_line_width);
3052 #endif
3053     }
3054   else
3055     {
3056       GdkRectangle focus_rectangle;
3057       gtk_tree_view_column_cell_process_action (tree_column,
3058                                                 window,
3059                                                 background_area,
3060                                                 cell_area,
3061                                                 flags,
3062                                                 CELL_ACTION_FOCUS,
3063                                                 expose_area,
3064                                                 &focus_rectangle,
3065                                                 NULL, NULL, NULL);
3066
3067       cell_state = flags & GTK_CELL_RENDERER_SELECTED ? GTK_STATE_SELECTED :
3068               (flags & GTK_CELL_RENDERER_PRELIT ? GTK_STATE_PRELIGHT :
3069               (flags & GTK_CELL_RENDERER_INSENSITIVE ? GTK_STATE_INSENSITIVE : GTK_STATE_NORMAL));
3070       gtk_paint_focus (tree_column->tree_view->style,
3071                        window,
3072                        cell_state,
3073                        NULL,
3074                        tree_column->tree_view,
3075                        "treeview",
3076                        focus_rectangle.x,
3077                        focus_rectangle.y,
3078                        focus_rectangle.width,
3079                        focus_rectangle.height);
3080     }
3081 }
3082
3083 /**
3084  * gtk_tree_view_column_cell_is_visible:
3085  * @tree_column: A #GtkTreeViewColumn
3086  *
3087  * Returns #TRUE if any of the cells packed into the @tree_column are visible.
3088  * For this to be meaningful, you must first initialize the cells with
3089  * gtk_tree_view_column_cell_set_cell_data()
3090  *
3091  * Return value: #TRUE, if any of the cells packed into the @tree_column are currently visible
3092  **/
3093 gboolean
3094 gtk_tree_view_column_cell_is_visible (GtkTreeViewColumn *tree_column)
3095 {
3096   GList *list;
3097
3098   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), FALSE);
3099
3100   for (list = tree_column->cell_list; list; list = list->next)
3101     {
3102       GtkTreeViewColumnCellInfo *info = (GtkTreeViewColumnCellInfo *) list->data;
3103
3104       if (info->cell->visible)
3105         return TRUE;
3106     }
3107
3108   return FALSE;
3109 }
3110
3111 /**
3112  * gtk_tree_view_column_focus_cell:
3113  * @tree_view: A #GtkTreeView
3114  * @cell: A #GtkCellRenderer
3115  *
3116  * Sets the current keyboard focus to be at @cell, if the column contains
3117  * 2 or more editable and activatable cells.
3118  **/
3119 void
3120 gtk_tree_view_column_focus_cell (GtkTreeViewColumn *tree_column,
3121                                  GtkCellRenderer   *cell)
3122 {
3123   GList *list;
3124   gboolean found_cell = FALSE;
3125
3126   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
3127   g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
3128
3129   if (_gtk_tree_view_column_count_special_cells (tree_column) < 2)
3130     return;
3131
3132   for (list = tree_column->cell_list; list; list = list->next)
3133     {
3134       GtkTreeViewColumnCellInfo *info = list->data;
3135
3136       if (info->cell == cell)
3137         {
3138           info->has_focus = TRUE;
3139           found_cell = TRUE;
3140           break;
3141         }
3142     }
3143
3144   if (found_cell)
3145     {
3146       for (list = tree_column->cell_list; list; list = list->next)
3147         {
3148           GtkTreeViewColumnCellInfo *info = list->data;
3149
3150           if (info->cell != cell)
3151             info->has_focus = FALSE;
3152         }
3153
3154       /* FIXME: redraw? */
3155     }
3156 }
3157
3158 void
3159 _gtk_tree_view_column_cell_set_dirty (GtkTreeViewColumn *tree_column,
3160                                       gboolean           install_handler)
3161 {
3162   GList *list;
3163
3164   for (list = tree_column->cell_list; list; list = list->next)
3165     {
3166       GtkTreeViewColumnCellInfo *info = (GtkTreeViewColumnCellInfo *) list->data;
3167
3168       info->requested_width = 0;
3169     }
3170   tree_column->dirty = TRUE;
3171   tree_column->resized_width = MAX (tree_column->requested_width, tree_column->button_request);
3172   tree_column->requested_width = -1;
3173   tree_column->width = 0;
3174
3175   if (tree_column->tree_view &&
3176       GTK_WIDGET_REALIZED (tree_column->tree_view))
3177     {
3178       if (install_handler)
3179         _gtk_tree_view_install_mark_rows_col_dirty (GTK_TREE_VIEW (tree_column->tree_view));
3180       else
3181         GTK_TREE_VIEW (tree_column->tree_view)->priv->mark_rows_col_dirty = TRUE;
3182       gtk_widget_queue_resize (tree_column->tree_view);
3183     }
3184 }
3185
3186 void
3187 _gtk_tree_view_column_start_editing (GtkTreeViewColumn *tree_column,
3188                                      GtkCellEditable   *cell_editable)
3189 {
3190   g_return_if_fail (tree_column->editable_widget == NULL);
3191
3192   tree_column->editable_widget = cell_editable;
3193 }
3194
3195 void
3196 _gtk_tree_view_column_stop_editing (GtkTreeViewColumn *tree_column)
3197 {
3198   GList *list;
3199
3200   g_return_if_fail (tree_column->editable_widget != NULL);
3201
3202   tree_column->editable_widget = NULL;
3203   for (list = tree_column->cell_list; list; list = list->next)
3204     ((GtkTreeViewColumnCellInfo *)list->data)->in_editing_mode = FALSE;
3205 }
3206
3207 void
3208 _gtk_tree_view_column_get_neighbor_sizes (GtkTreeViewColumn *column,
3209                                           GtkCellRenderer   *cell,
3210                                           gint              *left,
3211                                           gint              *right)
3212 {
3213   GList *list;
3214
3215   if (left)
3216     {
3217       *left = 0;
3218       list = gtk_tree_view_column_cell_first (column);
3219
3220       for (; list; list = gtk_tree_view_column_cell_next (column, list))
3221         {
3222           GtkTreeViewColumnCellInfo *info =
3223             (GtkTreeViewColumnCellInfo *)list->data;
3224
3225           if (info->cell == cell)
3226             break;
3227
3228           *left += info->real_width;
3229         }
3230     }
3231
3232   if (right)
3233     {
3234       GList *next;
3235
3236       *right = 0;
3237       list = gtk_tree_view_column_cell_first (column);
3238
3239       for (; list; list = gtk_tree_view_column_cell_next (column, list))
3240         {
3241           GtkTreeViewColumnCellInfo *info =
3242             (GtkTreeViewColumnCellInfo *)list->data;
3243
3244           if (info->cell == cell)
3245             break;
3246         }
3247
3248       /* skip cell */
3249       next = gtk_tree_view_column_cell_next (column, list);
3250       if (list && next)
3251         {
3252           list = next;
3253           for ( ; list; list = gtk_tree_view_column_cell_next (column, list))
3254             {
3255               GtkTreeViewColumnCellInfo *info =
3256                 (GtkTreeViewColumnCellInfo *)list->data;
3257
3258               *right += info->real_width;
3259             }
3260         }
3261     }
3262 }