pintos-os.org Git - pspp/blob - src/ui/gui/pspp-sheet-view-column.c

   1 /* PSPPIRE - a graphical user interface for PSPP.
   2    Copyright (C) 2011, 2012 Free Software Foundation, Inc.
   3
   4    This program is free software: you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation, either version 3 of the License, or
   7    (at your option) any later version.
   8
   9    This program 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
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program.  If not, see <http://www.gnu.org/licenses/>. */
  16
  17 /* gtktreeviewcolumn.c
  18  * Copyright (C) 2000  Red Hat, Inc.,  Jonathan Blandford <jrb@redhat.com>
  19  *
  20  * This library is free software; you can redistribute it and/or
  21  * modify it under the terms of the GNU Library General Public
  22  * License as published by the Free Software Foundation; either
  23  * version 2 of the License, or (at your option) any later version.
  24  *
  25  * This library is distributed in the hope that it will be useful,
  26  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  27  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  28  * Library General Public License for more details.
  29  *
  30  * You should have received a copy of the GNU Library General Public
  31  * License along with this library; if not, write to the
  32  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  33  * Boston, MA 02111-1307, USA.
  34  */
  35
  36 #include <config.h>
  37
  38 #include "ui/gui/pspp-sheet-private.h"
  39
  40 #include <errno.h>
  41 #include <gtk/gtk.h>
  42 #include <stdlib.h>
  43 #include <string.h>
  44
  45 #include "ui/gui/psppire-marshal.h"
  46 #include "ui/gui/pspp-sheet-selection.h"
  47 #include "ui/gui/pspp-widget-facade.h"
  48
  49 #define P_(STRING) STRING
  50 #define GTK_PARAM_READABLE G_PARAM_READABLE|G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB
  51 #define GTK_PARAM_READWRITE G_PARAM_READWRITE|G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB
  52
  53 enum
  54 {
  55   PROP_0,
  56   PROP_VISIBLE,
  57   PROP_RESIZABLE,
  58   PROP_WIDTH,
  59   PROP_SPACING,
  60   PROP_FIXED_WIDTH,
  61   PROP_MIN_WIDTH,
  62   PROP_MAX_WIDTH,
  63   PROP_TITLE,
  64   PROP_EXPAND,
  65   PROP_CLICKABLE,
  66   PROP_WIDGET,
  67   PROP_ALIGNMENT,
  68   PROP_REORDERABLE,
  69   PROP_SORT_INDICATOR,
  70   PROP_SORT_ORDER,
  71   PROP_SORT_COLUMN_ID,
  72   PROP_QUICK_EDIT,
  73   PROP_SELECTED,
  74   PROP_SELECTABLE,
  75   PROP_ROW_HEAD,
  76   PROP_TABBABLE
  77 };
  78
  79 enum
  80 {
  81   CLICKED,
  82   QUERY_TOOLTIP,
  83   POPUP_MENU,
  84   BUTTON_PRESS_EVENT,
  85   LAST_SIGNAL
  86 };
  87
  88 typedef struct _PsppSheetViewColumnCellInfo PsppSheetViewColumnCellInfo;
  89 struct _PsppSheetViewColumnCellInfo
  90 {
  91   GtkCellRenderer *cell;
  92   GSList *attributes;
  93   PsppSheetCellDataFunc func;
  94   gpointer func_data;
  95   GDestroyNotify destroy;
  96   gint requested_width;
  97   gint real_width;
  98   guint expand : 1;
  99   guint pack : 1;
 100   guint has_focus : 1;
 101   guint in_editing_mode : 1;
 102 };
 103
 104 /* Type methods */
 105 static void pspp_sheet_view_column_cell_layout_init              (GtkCellLayoutIface      *iface);
 106
 107 /* GObject methods */
 108 static void pspp_sheet_view_column_set_property                  (GObject                 *object,
 109                                                                 guint                    prop_id,
 110                                                                 const GValue            *value,
 111                                                                 GParamSpec              *pspec);
 112 static void pspp_sheet_view_column_get_property                  (GObject                 *object,
 113                                                                 guint                    prop_id,
 114                                                                 GValue                  *value,
 115                                                                 GParamSpec              *pspec);
 116 static void pspp_sheet_view_column_finalize                      (GObject                 *object);
 117
 118 /* GtkCellLayout implementation */
 119 static void pspp_sheet_view_column_cell_layout_pack_start         (GtkCellLayout         *cell_layout,
 120                                                                  GtkCellRenderer       *cell,
 121                                                                  gboolean               expand);
 122 static void pspp_sheet_view_column_cell_layout_pack_end           (GtkCellLayout         *cell_layout,
 123                                                                  GtkCellRenderer       *cell,
 124                                                                  gboolean               expand);
 125 static void pspp_sheet_view_column_cell_layout_clear              (GtkCellLayout         *cell_layout);
 126 static void pspp_sheet_view_column_cell_layout_add_attribute      (GtkCellLayout         *cell_layout,
 127                                                                  GtkCellRenderer       *cell,
 128                                                                  const gchar           *attribute,
 129                                                                  gint                   column);
 130 static void pspp_sheet_view_column_cell_layout_set_cell_data_func (GtkCellLayout         *cell_layout,
 131                                                                  GtkCellRenderer       *cell,
 132                                                                  GtkCellLayoutDataFunc  func,
 133                                                                  gpointer               func_data,
 134                                                                  GDestroyNotify         destroy);
 135 static void pspp_sheet_view_column_cell_layout_clear_attributes   (GtkCellLayout         *cell_layout,
 136                                                                  GtkCellRenderer       *cell);
 137 static void pspp_sheet_view_column_cell_layout_reorder            (GtkCellLayout         *cell_layout,
 138                                                                  GtkCellRenderer       *cell,
 139                                                                  gint                   position);
 140 static GList *pspp_sheet_view_column_cell_layout_get_cells        (GtkCellLayout         *cell_layout);
 141
 142 /* Button handling code */
 143 static void pspp_sheet_view_column_create_button                 (PsppSheetViewColumn       *tree_column);
 144 void pspp_sheet_view_column_update_button                 (PsppSheetViewColumn       *tree_column);
 145
 146 /* Button signal handlers */
 147 static gint pspp_sheet_view_column_button_event                  (GtkWidget               *widget,
 148                                                                 GdkEvent                *event,
 149                                                                 gpointer                 data);
 150 static void pspp_sheet_view_column_button_clicked                (GtkWidget               *widget,
 151                                                                 gpointer                 data);
 152 static void pspp_sheet_view_column_button_popup_menu (GtkWidget *widget,
 153                                                       gpointer data);
 154 static gboolean pspp_sheet_view_column_mnemonic_activate         (GtkWidget *widget,
 155                                                                 gboolean   group_cycling,
 156                                                                 gpointer   data);
 157 static gboolean on_pspp_sheet_view_column_button_clicked (PsppSheetViewColumn *);
 158 static gboolean on_pspp_sheet_view_column_button_press_event (PsppSheetViewColumn *,
 159                                                               GdkEventButton *);
 160
 161 /* Property handlers */
 162 static void pspp_sheet_view_model_sort_column_changed            (GtkTreeSortable         *sortable,
 163                                                                 PsppSheetViewColumn       *tree_column);
 164
 165 /* Internal functions */
 166 static void pspp_sheet_view_column_sort                          (PsppSheetViewColumn       *tree_column,
 167                                                                 gpointer                 data);
 168 static void pspp_sheet_view_column_setup_sort_column_id_callback (PsppSheetViewColumn       *tree_column);
 169 static void pspp_sheet_view_column_set_attributesv               (PsppSheetViewColumn       *tree_column,
 170                                                                 GtkCellRenderer         *cell_renderer,
 171                                                                 va_list                  args);
 172 static PsppSheetViewColumnCellInfo *pspp_sheet_view_column_get_cell_info (PsppSheetViewColumn *tree_column,
 173                                                                       GtkCellRenderer   *cell_renderer);
 174
 175 /* cell list manipulation */
 176 static GList *pspp_sheet_view_column_cell_first                  (PsppSheetViewColumn      *tree_column);
 177 static GList *pspp_sheet_view_column_cell_last                   (PsppSheetViewColumn      *tree_column);
 178 static GList *pspp_sheet_view_column_cell_next                   (PsppSheetViewColumn      *tree_column,
 179                                                                 GList                  *current);
 180 static GList *pspp_sheet_view_column_cell_prev                   (PsppSheetViewColumn      *tree_column,
 181                                                                 GList                  *current);
 182 static void pspp_sheet_view_column_clear_attributes_by_info      (PsppSheetViewColumn      *tree_column,
 183                                                                 PsppSheetViewColumnCellInfo *info);
 184 /* GtkBuildable implementation */
 185 static void pspp_sheet_view_column_buildable_init                 (GtkBuildableIface     *iface);
 186
 187 static guint tree_column_signals[LAST_SIGNAL] = { 0 };
 188
 189 G_DEFINE_TYPE_WITH_CODE (PsppSheetViewColumn, pspp_sheet_view_column, G_TYPE_OBJECT,
 190                          G_IMPLEMENT_INTERFACE (GTK_TYPE_CELL_LAYOUT,
 191                                                 pspp_sheet_view_column_cell_layout_init)
 192                          G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE,
 193                                                 pspp_sheet_view_column_buildable_init))
 194
 195
 196 static void
 197 pspp_sheet_view_column_class_init (PsppSheetViewColumnClass *class)
 198 {
 199   GObjectClass *object_class;
 200
 201   object_class = (GObjectClass*) class;
 202
 203   class->clicked = on_pspp_sheet_view_column_button_clicked;
 204   class->button_press_event = on_pspp_sheet_view_column_button_press_event;
 205
 206   object_class->finalize = pspp_sheet_view_column_finalize;
 207   object_class->set_property = pspp_sheet_view_column_set_property;
 208   object_class->get_property = pspp_sheet_view_column_get_property;
 209
 210   tree_column_signals[CLICKED] =
 211     g_signal_new ("clicked",
 212                   G_OBJECT_CLASS_TYPE (object_class),
 213                   G_SIGNAL_RUN_LAST,
 214                   G_STRUCT_OFFSET (PsppSheetViewColumnClass, clicked),
 215                   g_signal_accumulator_true_handled, NULL,
 216                   psppire_marshal_BOOLEAN__VOID,
 217                   G_TYPE_BOOLEAN, 0);
 218
 219   tree_column_signals[POPUP_MENU] =
 220     g_signal_new ("popup-menu",
 221                   G_OBJECT_CLASS_TYPE (object_class),
 222                   G_SIGNAL_RUN_LAST,
 223                   0,
 224                   NULL, NULL,
 225                   g_cclosure_marshal_VOID__VOID,
 226                   G_TYPE_NONE, 0);
 227
 228   tree_column_signals[QUERY_TOOLTIP] =
 229     g_signal_new ("query-tooltip",
 230                   G_OBJECT_CLASS_TYPE (object_class),
 231                   G_SIGNAL_RUN_LAST,
 232                   0,
 233                   g_signal_accumulator_true_handled, NULL,
 234                   psppire_marshal_BOOLEAN__OBJECT,
 235                   G_TYPE_BOOLEAN, 1,
 236                   GTK_TYPE_TOOLTIP);
 237
 238   tree_column_signals[BUTTON_PRESS_EVENT] =
 239     g_signal_new ("button-press-event",
 240                   G_OBJECT_CLASS_TYPE (object_class),
 241                   G_SIGNAL_RUN_FIRST | G_SIGNAL_RUN_LAST,
 242                   G_STRUCT_OFFSET (PsppSheetViewColumnClass, button_press_event),
 243                   g_signal_accumulator_true_handled, NULL,
 244                   psppire_marshal_BOOLEAN__BOXED,
 245                   G_TYPE_BOOLEAN, 1,
 246                   GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
 247
 248   g_object_class_install_property (object_class,
 249                                    PROP_VISIBLE,
 250                                    g_param_spec_boolean ("visible",
 251                                                         P_("Visible"),
 252                                                         P_("Whether to display the column"),
 253                                                          TRUE,
 254                                                          GTK_PARAM_READWRITE));
 255
 256   g_object_class_install_property (object_class,
 257                                    PROP_RESIZABLE,
 258                                    g_param_spec_boolean ("resizable",
 259                                                          P_("Resizable"),
 260                                                          P_("Column is user-resizable"),
 261                                                          FALSE,
 262                                                          GTK_PARAM_READWRITE));
 263
 264   g_object_class_install_property (object_class,
 265                                    PROP_WIDTH,
 266                                    g_param_spec_int ("width",
 267                                                      P_("Width"),
 268                                                      P_("Current width of the column"),
 269                                                      0,
 270                                                      G_MAXINT,
 271                                                      0,
 272                                                      GTK_PARAM_READABLE));
 273   g_object_class_install_property (object_class,
 274                                    PROP_SPACING,
 275                                    g_param_spec_int ("spacing",
 276                                                      P_("Spacing"),
 277                                                      P_("Space which is inserted between cells"),
 278                                                      0,
 279                                                      G_MAXINT,
 280                                                      0,
 281                                                      GTK_PARAM_READWRITE));
 282
 283   g_object_class_install_property (object_class,
 284                                    PROP_FIXED_WIDTH,
 285                                    g_param_spec_int ("fixed-width",
 286                                                      P_("Fixed Width"),
 287                                                      P_("Current fixed width of the column"),
 288                                                      1,
 289                                                      G_MAXINT,
 290                                                      100,
 291                                                      GTK_PARAM_READWRITE));
 292
 293   g_object_class_install_property (object_class,
 294                                    PROP_MIN_WIDTH,
 295                                    g_param_spec_int ("min-width",
 296                                                      P_("Minimum Width"),
 297                                                      P_("Minimum allowed width of the column"),
 298                                                      -1,
 299                                                      G_MAXINT,
 300                                                      -1,
 301                                                      GTK_PARAM_READWRITE));
 302
 303   g_object_class_install_property (object_class,
 304                                    PROP_MAX_WIDTH,
 305                                    g_param_spec_int ("max-width",
 306                                                      P_("Maximum Width"),
 307                                                      P_("Maximum allowed width of the column"),
 308                                                      -1,
 309                                                      G_MAXINT,
 310                                                      -1,
 311                                                      GTK_PARAM_READWRITE));
 312
 313   g_object_class_install_property (object_class,
 314                                    PROP_TITLE,
 315                                    g_param_spec_string ("title",
 316                                                         P_("Title"),
 317                                                         P_("Title to appear in column header"),
 318                                                         "",
 319                                                         GTK_PARAM_READWRITE));
 320
 321   g_object_class_install_property (object_class,
 322                                    PROP_EXPAND,
 323                                    g_param_spec_boolean ("expand",
 324                                                          P_("Expand"),
 325                                                          P_("Column gets share of extra width allocated to the widget"),
 326                                                          FALSE,
 327                                                          GTK_PARAM_READWRITE));
 328
 329   g_object_class_install_property (object_class,
 330                                    PROP_CLICKABLE,
 331                                    g_param_spec_boolean ("clickable",
 332                                                         P_("Clickable"),
 333                                                         P_("Whether the header can be clicked"),
 334                                                          FALSE,
 335                                                          GTK_PARAM_READWRITE));
 336
 337
 338   g_object_class_install_property (object_class,
 339                                    PROP_WIDGET,
 340                                    g_param_spec_object ("widget",
 341                                                         P_("Widget"),
 342                                                         P_("Widget to put in column header button instead of column title"),
 343                                                         GTK_TYPE_WIDGET,
 344                                                         GTK_PARAM_READWRITE));
 345
 346   g_object_class_install_property (object_class,
 347                                    PROP_ALIGNMENT,
 348                                    g_param_spec_float ("alignment",
 349                                                        P_("Alignment"),
 350                                                        P_("X Alignment of the column header text or widget"),
 351                                                        0.0,
 352                                                        1.0,
 353                                                        0.0,
 354                                                        GTK_PARAM_READWRITE));
 355
 356   g_object_class_install_property (object_class,
 357                                    PROP_REORDERABLE,
 358                                    g_param_spec_boolean ("reorderable",
 359                                                          P_("Reorderable"),
 360                                                          P_("Whether the column can be reordered around the headers"),
 361                                                          FALSE,
 362                                                          GTK_PARAM_READWRITE));
 363
 364   g_object_class_install_property (object_class,
 365                                    PROP_SORT_INDICATOR,
 366                                    g_param_spec_boolean ("sort-indicator",
 367                                                         P_("Sort indicator"),
 368                                                         P_("Whether to show a sort indicator"),
 369                                                          FALSE,
 370                                                          GTK_PARAM_READWRITE));
 371
 372   g_object_class_install_property (object_class,
 373                                    PROP_SORT_ORDER,
 374                                    g_param_spec_enum ("sort-order",
 375                                                       P_("Sort order"),
 376                                                       P_("Sort direction the sort indicator should indicate"),
 377                                                       GTK_TYPE_SORT_TYPE,
 378                                                       GTK_SORT_ASCENDING,
 379                                                       GTK_PARAM_READWRITE));
 380
 381   /**
 382    * PsppSheetViewColumn:sort-column-id:
 383    *
 384    * Logical sort column ID this column sorts on when selected for sorting. Setting the sort column ID makes the column header
 385    * clickable. Set to %-1 to make the column unsortable.
 386    *
 387    * Since: 2.18
 388    **/
 389   g_object_class_install_property (object_class,
 390                                    PROP_SORT_COLUMN_ID,
 391                                    g_param_spec_int ("sort-column-id",
 392                                                      P_("Sort column ID"),
 393                                                      P_("Logical sort column ID this column sorts on when selected for sorting"),
 394                                                      -1,
 395                                                      G_MAXINT,
 396                                                      -1,
 397                                                      GTK_PARAM_READWRITE));
 398
 399   g_object_class_install_property (object_class,
 400                                    PROP_QUICK_EDIT,
 401                                    g_param_spec_boolean ("quick-edit",
 402                                                          P_("Quick edit"),
 403                                                          P_("If true, editing starts upon the first click in the column.  If false, the first click selects the column and a second click is needed to begin editing.  This has no effect on cells that are not editable."),
 404                                                          TRUE,
 405                                                          GTK_PARAM_READWRITE));
 406
 407   g_object_class_install_property (object_class,
 408                                    PROP_SELECTED,
 409                                    g_param_spec_boolean ("selected",
 410                                                          P_("Selected"),
 411                                                          P_("If true, this column is selected as part of a rectangular selection."),
 412                                                          FALSE,
 413                                                          GTK_PARAM_READWRITE));
 414
 415   g_object_class_install_property (object_class,
 416                                    PROP_SELECTABLE,
 417                                    g_param_spec_boolean ("selectable",
 418                                                          P_("Selectable"),
 419                                                          P_("If true, this column may be selected as part of a rectangular selection."),
 420                                                          TRUE,
 421                                                          GTK_PARAM_READWRITE));
 422
 423   g_object_class_install_property (object_class,
 424                                    PROP_ROW_HEAD,
 425                                    g_param_spec_boolean ("row-head",
 426                                                          P_("Row head"),
 427                                                          P_("If true, this column is a \"row head\", equivalent to a column head.  If rectangular selection is enabled, then shift+click and control+click in the column select row ranges and toggle row selection, respectively.  The column should ordinarily include a button cell; clicking on the button will select the row (and deselect all other rows)."),
 428                                                          FALSE,
 429                                                          GTK_PARAM_READWRITE));
 430
 431   g_object_class_install_property (object_class,
 432                                    PROP_TABBABLE,
 433                                    g_param_spec_boolean ("tabbable",
 434                                                          P_("Tabbable"),
 435                                                          P_("If true, Tab and Shift+Tab visit this column.  If false, Tab and Shift+Tab skip this column."),
 436                                                          TRUE,
 437                                                          GTK_PARAM_READWRITE));
 438 }
 439
 440
 441 static void _cell_layout_buildable_custom_tag_end (GtkBuildable *buildable,
 442                                                    GtkBuilder   *builder,
 443                                                    GObject      *child,
 444                                                    const gchar  *tagname,
 445                                                    gpointer     *data);
 446
 447
 448 static void _cell_layout_buildable_add_child (GtkBuildable      *buildable,
 449                                                   GtkBuilder        *builder,
 450                                                   GObject           *child,
 451                                                   const gchar       *type);
 452
 453
 454 static gboolean _cell_layout_buildable_custom_tag_start (GtkBuildable  *buildable,
 455                                              GtkBuilder    *builder,
 456                                              GObject       *child,
 457                                              const gchar   *tagname,
 458                                              GMarkupParser *parser,
 459                                          gpointer      *data);
 460
 461
 462 static void
 463 pspp_sheet_view_column_buildable_init (GtkBuildableIface *iface)
 464 {
 465   iface->add_child = _cell_layout_buildable_add_child;
 466   iface->custom_tag_start = _cell_layout_buildable_custom_tag_start;
 467   iface->custom_tag_end = _cell_layout_buildable_custom_tag_end;
 468 }
 469
 470 static void
 471 pspp_sheet_view_column_cell_layout_init (GtkCellLayoutIface *iface)
 472 {
 473   iface->pack_start = pspp_sheet_view_column_cell_layout_pack_start;
 474   iface->pack_end = pspp_sheet_view_column_cell_layout_pack_end;
 475   iface->clear = pspp_sheet_view_column_cell_layout_clear;
 476   iface->add_attribute = pspp_sheet_view_column_cell_layout_add_attribute;
 477   iface->set_cell_data_func = pspp_sheet_view_column_cell_layout_set_cell_data_func;
 478   iface->clear_attributes = pspp_sheet_view_column_cell_layout_clear_attributes;
 479   iface->reorder = pspp_sheet_view_column_cell_layout_reorder;
 480   iface->get_cells = pspp_sheet_view_column_cell_layout_get_cells;
 481 }
 482
 483 static void
 484 pspp_sheet_view_column_init (PsppSheetViewColumn *tree_column)
 485 {
 486   tree_column->button = NULL;
 487   tree_column->xalign = 0.0;
 488   tree_column->width = 0;
 489   tree_column->spacing = 0;
 490   tree_column->requested_width = -1;
 491   tree_column->min_width = -1;
 492   tree_column->max_width = -1;
 493   tree_column->resized_width = 0;
 494   tree_column->visible = TRUE;
 495   tree_column->resizable = FALSE;
 496   tree_column->expand = FALSE;
 497   tree_column->clickable = FALSE;
 498   tree_column->dirty = TRUE;
 499   tree_column->selected = FALSE;
 500   tree_column->selectable = TRUE;
 501   tree_column->row_head = FALSE;
 502   tree_column->tabbable = TRUE;
 503   tree_column->sort_order = GTK_SORT_ASCENDING;
 504   tree_column->show_sort_indicator = FALSE;
 505   tree_column->property_changed_signal = 0;
 506   tree_column->sort_clicked_signal = 0;
 507   tree_column->sort_column_changed_signal = 0;
 508   tree_column->sort_column_id = -1;
 509   tree_column->reorderable = FALSE;
 510   tree_column->maybe_reordered = FALSE;
 511   tree_column->fixed_width = 1;
 512   tree_column->use_resized_width = FALSE;
 513   tree_column->title = g_strdup ("");
 514   tree_column->quick_edit = TRUE;
 515   tree_column->need_button = FALSE;
 516 }
 517
 518 static void
 519 pspp_sheet_view_column_finalize (GObject *object)
 520 {
 521   PsppSheetViewColumn *tree_column = (PsppSheetViewColumn *) object;
 522   GList *list;
 523
 524   for (list = tree_column->cell_list; list; list = list->next)
 525     {
 526       PsppSheetViewColumnCellInfo *info = (PsppSheetViewColumnCellInfo *) list->data;
 527
 528       if (info->destroy)
 529         {
 530           GDestroyNotify d = info->destroy;
 531
 532           info->destroy = NULL;
 533           d (info->func_data);
 534         }
 535       pspp_sheet_view_column_clear_attributes_by_info (tree_column, info);
 536       g_object_unref (info->cell);
 537       g_free (info);
 538     }
 539
 540   g_free (tree_column->title);
 541   g_list_free (tree_column->cell_list);
 542
 543   if (tree_column->child)
 544     g_object_unref (tree_column->child);
 545
 546   G_OBJECT_CLASS (pspp_sheet_view_column_parent_class)->finalize (object);
 547 }
 548
 549 static void
 550 pspp_sheet_view_column_set_property (GObject         *object,
 551                                    guint            prop_id,
 552                                    const GValue    *value,
 553                                    GParamSpec      *pspec)
 554 {
 555   PsppSheetViewColumn *tree_column;
 556
 557   tree_column = PSPP_SHEET_VIEW_COLUMN (object);
 558
 559   switch (prop_id)
 560     {
 561     case PROP_VISIBLE:
 562       pspp_sheet_view_column_set_visible (tree_column,
 563                                         g_value_get_boolean (value));
 564       break;
 565
 566     case PROP_RESIZABLE:
 567       pspp_sheet_view_column_set_resizable (tree_column,
 568                                           g_value_get_boolean (value));
 569       break;
 570
 571     case PROP_FIXED_WIDTH:
 572       pspp_sheet_view_column_set_fixed_width (tree_column,
 573                                             g_value_get_int (value));
 574       break;
 575
 576     case PROP_MIN_WIDTH:
 577       pspp_sheet_view_column_set_min_width (tree_column,
 578                                           g_value_get_int (value));
 579       break;
 580
 581     case PROP_MAX_WIDTH:
 582       pspp_sheet_view_column_set_max_width (tree_column,
 583                                           g_value_get_int (value));
 584       break;
 585
 586     case PROP_SPACING:
 587       pspp_sheet_view_column_set_spacing (tree_column,
 588                                         g_value_get_int (value));
 589       break;
 590
 591     case PROP_TITLE:
 592       pspp_sheet_view_column_set_title (tree_column,
 593                                       g_value_get_string (value));
 594       break;
 595
 596     case PROP_EXPAND:
 597       pspp_sheet_view_column_set_expand (tree_column,
 598                                        g_value_get_boolean (value));
 599       break;
 600
 601     case PROP_CLICKABLE:
 602       pspp_sheet_view_column_set_clickable (tree_column,
 603                                           g_value_get_boolean (value));
 604       break;
 605
 606     case PROP_WIDGET:
 607       pspp_sheet_view_column_set_widget (tree_column,
 608                                        (GtkWidget*) g_value_get_object (value));
 609       break;
 610
 611     case PROP_ALIGNMENT:
 612       pspp_sheet_view_column_set_alignment (tree_column,
 613                                           g_value_get_float (value));
 614       break;
 615
 616     case PROP_REORDERABLE:
 617       pspp_sheet_view_column_set_reorderable (tree_column,
 618                                             g_value_get_boolean (value));
 619       break;
 620
 621     case PROP_SORT_INDICATOR:
 622       pspp_sheet_view_column_set_sort_indicator (tree_column,
 623                                                g_value_get_boolean (value));
 624       break;
 625
 626     case PROP_SORT_ORDER:
 627       pspp_sheet_view_column_set_sort_order (tree_column,
 628                                            g_value_get_enum (value));
 629       break;
 630
 631     case PROP_SORT_COLUMN_ID:
 632       pspp_sheet_view_column_set_sort_column_id (tree_column,
 633                                                g_value_get_int (value));
 634       break;
 635
 636     case PROP_QUICK_EDIT:
 637       pspp_sheet_view_column_set_quick_edit (tree_column,
 638                                              g_value_get_boolean (value));
 639       break;
 640
 641     case PROP_SELECTED:
 642       pspp_sheet_view_column_set_selected (tree_column,
 643                                              g_value_get_boolean (value));
 644       break;
 645
 646     case PROP_SELECTABLE:
 647       pspp_sheet_view_column_set_selectable (tree_column,
 648                                              g_value_get_boolean (value));
 649       break;
 650
 651     case PROP_ROW_HEAD:
 652       pspp_sheet_view_column_set_row_head (tree_column,
 653                                              g_value_get_boolean (value));
 654       break;
 655
 656     case PROP_TABBABLE:
 657       pspp_sheet_view_column_set_tabbable (tree_column,
 658                                            g_value_get_boolean (value));
 659       break;
 660
 661     default:
 662       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 663       break;
 664     }
 665 }
 666
 667 static void
 668 pspp_sheet_view_column_get_property (GObject         *object,
 669                                    guint            prop_id,
 670                                    GValue          *value,
 671                                    GParamSpec      *pspec)
 672 {
 673   PsppSheetViewColumn *tree_column;
 674
 675   tree_column = PSPP_SHEET_VIEW_COLUMN (object);
 676
 677   switch (prop_id)
 678     {
 679     case PROP_VISIBLE:
 680       g_value_set_boolean (value,
 681                            pspp_sheet_view_column_get_visible (tree_column));
 682       break;
 683
 684     case PROP_RESIZABLE:
 685       g_value_set_boolean (value,
 686                            pspp_sheet_view_column_get_resizable (tree_column));
 687       break;
 688
 689     case PROP_WIDTH:
 690       g_value_set_int (value,
 691                        pspp_sheet_view_column_get_width (tree_column));
 692       break;
 693
 694     case PROP_SPACING:
 695       g_value_set_int (value,
 696                        pspp_sheet_view_column_get_spacing (tree_column));
 697       break;
 698
 699     case PROP_FIXED_WIDTH:
 700       g_value_set_int (value,
 701                        pspp_sheet_view_column_get_fixed_width (tree_column));
 702       break;
 703
 704     case PROP_MIN_WIDTH:
 705       g_value_set_int (value,
 706                        pspp_sheet_view_column_get_min_width (tree_column));
 707       break;
 708
 709     case PROP_MAX_WIDTH:
 710       g_value_set_int (value,
 711                        pspp_sheet_view_column_get_max_width (tree_column));
 712       break;
 713
 714     case PROP_TITLE:
 715       g_value_set_string (value,
 716                           pspp_sheet_view_column_get_title (tree_column));
 717       break;
 718
 719     case PROP_EXPAND:
 720       g_value_set_boolean (value,
 721                           pspp_sheet_view_column_get_expand (tree_column));
 722       break;
 723
 724     case PROP_CLICKABLE:
 725       g_value_set_boolean (value,
 726                            pspp_sheet_view_column_get_clickable (tree_column));
 727       break;
 728
 729     case PROP_WIDGET:
 730       g_value_set_object (value,
 731                           (GObject*) pspp_sheet_view_column_get_widget (tree_column));
 732       break;
 733
 734     case PROP_ALIGNMENT:
 735       g_value_set_float (value,
 736                          pspp_sheet_view_column_get_alignment (tree_column));
 737       break;
 738
 739     case PROP_REORDERABLE:
 740       g_value_set_boolean (value,
 741                            pspp_sheet_view_column_get_reorderable (tree_column));
 742       break;
 743
 744     case PROP_SORT_INDICATOR:
 745       g_value_set_boolean (value,
 746                            pspp_sheet_view_column_get_sort_indicator (tree_column));
 747       break;
 748
 749     case PROP_SORT_ORDER:
 750       g_value_set_enum (value,
 751                         pspp_sheet_view_column_get_sort_order (tree_column));
 752       break;
 753
 754     case PROP_SORT_COLUMN_ID:
 755       g_value_set_int (value,
 756                        pspp_sheet_view_column_get_sort_column_id (tree_column));
 757       break;
 758
 759     case PROP_QUICK_EDIT:
 760       g_value_set_boolean (value,
 761                            pspp_sheet_view_column_get_quick_edit (tree_column));
 762       break;
 763
 764     case PROP_SELECTED:
 765       g_value_set_boolean (value,
 766                            pspp_sheet_view_column_get_selected (tree_column));
 767       break;
 768
 769     case PROP_SELECTABLE:
 770       g_value_set_boolean (value,
 771                            pspp_sheet_view_column_get_selectable (tree_column));
 772       break;
 773
 774     case PROP_ROW_HEAD:
 775       g_value_set_boolean (value,
 776                            pspp_sheet_view_column_get_row_head (tree_column));
 777       break;
 778
 779     case PROP_TABBABLE:
 780       g_value_set_boolean (value,
 781                            pspp_sheet_view_column_get_tabbable (tree_column));
 782       break;
 783
 784     default:
 785       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 786       break;
 787     }
 788 }
 789
 790 /* Implementation of GtkCellLayout interface
 791  */
 792
 793 static void
 794 pspp_sheet_view_column_cell_layout_pack_start (GtkCellLayout   *cell_layout,
 795                                              GtkCellRenderer *cell,
 796                                              gboolean         expand)
 797 {
 798   PsppSheetViewColumn *column;
 799   PsppSheetViewColumnCellInfo *cell_info;
 800
 801   g_return_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (cell_layout));
 802   column = PSPP_SHEET_VIEW_COLUMN (cell_layout);
 803   g_return_if_fail (! pspp_sheet_view_column_get_cell_info (column, cell));
 804
 805   g_object_ref_sink (cell);
 806
 807   cell_info = g_new0 (PsppSheetViewColumnCellInfo, 1);
 808   cell_info->cell = cell;
 809   cell_info->expand = expand ? TRUE : FALSE;
 810   cell_info->pack = GTK_PACK_START;
 811   cell_info->has_focus = 0;
 812   cell_info->attributes = NULL;
 813
 814   column->cell_list = g_list_append (column->cell_list, cell_info);
 815 }
 816
 817 static void
 818 pspp_sheet_view_column_cell_layout_pack_end (GtkCellLayout   *cell_layout,
 819                                            GtkCellRenderer *cell,
 820                                            gboolean         expand)
 821 {
 822   PsppSheetViewColumn *column;
 823   PsppSheetViewColumnCellInfo *cell_info;
 824
 825   g_return_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (cell_layout));
 826   column = PSPP_SHEET_VIEW_COLUMN (cell_layout);
 827   g_return_if_fail (! pspp_sheet_view_column_get_cell_info (column, cell));
 828
 829   g_object_ref_sink (cell);
 830
 831   cell_info = g_new0 (PsppSheetViewColumnCellInfo, 1);
 832   cell_info->cell = cell;
 833   cell_info->expand = expand ? TRUE : FALSE;
 834   cell_info->pack = GTK_PACK_END;
 835   cell_info->has_focus = 0;
 836   cell_info->attributes = NULL;
 837
 838   column->cell_list = g_list_append (column->cell_list, cell_info);
 839 }
 840
 841 static void
 842 pspp_sheet_view_column_cell_layout_clear (GtkCellLayout *cell_layout)
 843 {
 844   PsppSheetViewColumn *column;
 845
 846   g_return_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (cell_layout));
 847   column = PSPP_SHEET_VIEW_COLUMN (cell_layout);
 848
 849   while (column->cell_list)
 850     {
 851       PsppSheetViewColumnCellInfo *info = (PsppSheetViewColumnCellInfo *)column->cell_list->data;
 852
 853       pspp_sheet_view_column_cell_layout_clear_attributes (cell_layout, info->cell);
 854       g_object_unref (info->cell);
 855       g_free (info);
 856       column->cell_list = g_list_delete_link (column->cell_list,
 857                                               column->cell_list);
 858     }
 859 }
 860
 861 static void
 862 pspp_sheet_view_column_cell_layout_add_attribute (GtkCellLayout   *cell_layout,
 863                                                 GtkCellRenderer *cell,
 864                                                 const gchar     *attribute,
 865                                                 gint             column)
 866 {
 867   PsppSheetViewColumn *tree_column;
 868   PsppSheetViewColumnCellInfo *info;
 869
 870   g_return_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (cell_layout));
 871   tree_column = PSPP_SHEET_VIEW_COLUMN (cell_layout);
 872
 873   info = pspp_sheet_view_column_get_cell_info (tree_column, cell);
 874   g_return_if_fail (info != NULL);
 875
 876   info->attributes = g_slist_prepend (info->attributes, GINT_TO_POINTER (column));
 877   info->attributes = g_slist_prepend (info->attributes, g_strdup (attribute));
 878
 879   if (tree_column->tree_view)
 880     _pspp_sheet_view_column_cell_set_dirty (tree_column);
 881 }
 882
 883 static void
 884 pspp_sheet_view_column_cell_layout_set_cell_data_func (GtkCellLayout         *cell_layout,
 885                                                      GtkCellRenderer       *cell,
 886                                                      GtkCellLayoutDataFunc  func,
 887                                                      gpointer               func_data,
 888                                                      GDestroyNotify         destroy)
 889 {
 890   PsppSheetViewColumn *column;
 891   PsppSheetViewColumnCellInfo *info;
 892
 893   g_return_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (cell_layout));
 894   column = PSPP_SHEET_VIEW_COLUMN (cell_layout);
 895
 896   info = pspp_sheet_view_column_get_cell_info (column, cell);
 897   g_return_if_fail (info != NULL);
 898
 899   if (info->destroy)
 900     {
 901       GDestroyNotify d = info->destroy;
 902
 903       info->destroy = NULL;
 904       d (info->func_data);
 905     }
 906
 907   info->func = (PsppSheetCellDataFunc)func;
 908   info->func_data = func_data;
 909   info->destroy = destroy;
 910
 911   if (column->tree_view)
 912     _pspp_sheet_view_column_cell_set_dirty (column);
 913 }
 914
 915 static void
 916 pspp_sheet_view_column_cell_layout_clear_attributes (GtkCellLayout    *cell_layout,
 917                                                    GtkCellRenderer  *cell_renderer)
 918 {
 919   PsppSheetViewColumn *column;
 920   PsppSheetViewColumnCellInfo *info;
 921
 922   g_return_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (cell_layout));
 923   column = PSPP_SHEET_VIEW_COLUMN (cell_layout);
 924
 925   info = pspp_sheet_view_column_get_cell_info (column, cell_renderer);
 926   if (info)
 927     pspp_sheet_view_column_clear_attributes_by_info (column, info);
 928 }
 929
 930 static void
 931 pspp_sheet_view_column_cell_layout_reorder (GtkCellLayout   *cell_layout,
 932                                           GtkCellRenderer *cell,
 933                                           gint             position)
 934 {
 935   GList *link;
 936   PsppSheetViewColumn *column;
 937   PsppSheetViewColumnCellInfo *info;
 938
 939   g_return_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (cell_layout));
 940   column = PSPP_SHEET_VIEW_COLUMN (cell_layout);
 941
 942   info = pspp_sheet_view_column_get_cell_info (column, cell);
 943
 944   g_return_if_fail (info != NULL);
 945   g_return_if_fail (position >= 0);
 946
 947   link = g_list_find (column->cell_list, info);
 948
 949   g_return_if_fail (link != NULL);
 950
 951   column->cell_list = g_list_delete_link (column->cell_list, link);
 952   column->cell_list = g_list_insert (column->cell_list, info, position);
 953
 954   if (column->tree_view)
 955     gtk_widget_queue_draw (column->tree_view);
 956 }
 957
 958 static void
 959 pspp_sheet_view_column_clear_attributes_by_info (PsppSheetViewColumn *tree_column,
 960                                                PsppSheetViewColumnCellInfo *info)
 961 {
 962   GSList *list;
 963
 964   list = info->attributes;
 965
 966   while (list && list->next)
 967     {
 968       g_free (list->data);
 969       list = list->next->next;
 970     }
 971   g_slist_free (info->attributes);
 972   info->attributes = NULL;
 973
 974   if (tree_column->tree_view)
 975     _pspp_sheet_view_column_cell_set_dirty (tree_column);
 976 }
 977
 978 static gboolean
 979 on_query_tooltip (GtkWidget  *widget,
 980                   gint        x,
 981                   gint        y,
 982                   gboolean    keyboard_mode,
 983                   GtkTooltip *tooltip,
 984                   gpointer    user_data)
 985 {
 986   PsppSheetViewColumn *tree_column = user_data;
 987   gboolean handled;
 988
 989   g_signal_emit (tree_column, tree_column_signals[QUERY_TOOLTIP], 0,
 990                  tooltip, &handled);
 991   return handled;
 992 }
 993
 994 static gboolean
 995 on_button_pressed (GtkWidget *widget, GdkEventButton *event,
 996                    gpointer user_data)
 997 {
 998   PsppSheetViewColumn *tree_column = user_data;
 999   gboolean handled;
1000
1001   /* XXX See "Implement GtkWidget::popup_menu" in GTK+ reference manual. */
1002   g_signal_emit (tree_column, tree_column_signals[BUTTON_PRESS_EVENT],
1003                  0, event, &handled);
1004   return handled;
1005 }
1006
1007 /* Helper functions
1008  */
1009
1010 /* Button handling code
1011  */
1012 static void
1013 pspp_sheet_view_column_create_button (PsppSheetViewColumn *tree_column)
1014 {
1015   PsppSheetView *tree_view;
1016   GtkWidget *child;
1017   GtkWidget *hbox;
1018
1019   tree_view = (PsppSheetView *) tree_column->tree_view;
1020
1021   g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
1022   g_return_if_fail (tree_column->button == NULL);
1023
1024   gtk_widget_push_composite_child ();
1025   tree_column->button = gtk_button_new ();
1026   gtk_widget_add_events (tree_column->button, GDK_POINTER_MOTION_MASK);
1027   gtk_widget_pop_composite_child ();
1028
1029   /* make sure we own a reference to it as well. */
1030   if (tree_view->priv->header_window)
1031     gtk_widget_set_parent_window (tree_column->button, tree_view->priv->header_window);
1032   gtk_widget_set_parent (tree_column->button, GTK_WIDGET (tree_view));
1033
1034   g_signal_connect (tree_column->button, "event",
1035                     G_CALLBACK (pspp_sheet_view_column_button_event),
1036                     tree_column);
1037   g_signal_connect (tree_column->button, "clicked",
1038                     G_CALLBACK (pspp_sheet_view_column_button_clicked),
1039                     tree_column);
1040   g_signal_connect (tree_column->button, "popup-menu",
1041                     G_CALLBACK (pspp_sheet_view_column_button_popup_menu),
1042                     tree_column);
1043   g_signal_connect (tree_column->button, "button-press-event",
1044                     G_CALLBACK (on_button_pressed), tree_column);
1045
1046   g_signal_connect (tree_column->button, "query-tooltip",
1047                     G_CALLBACK (on_query_tooltip), tree_column);
1048   g_object_set (tree_column->button, "has-tooltip", TRUE, NULL);
1049
1050   tree_column->alignment = gtk_alignment_new (tree_column->xalign, 0.5, 0.0, 0.0);
1051
1052   hbox = gtk_hbox_new (FALSE, 2);
1053   tree_column->arrow = gtk_arrow_new (GTK_ARROW_DOWN, GTK_SHADOW_IN);
1054
1055   if (tree_column->child)
1056     child = tree_column->child;
1057   else
1058     {
1059       child = gtk_label_new (tree_column->title);
1060       gtk_widget_show (child);
1061     }
1062
1063   g_signal_connect (child, "mnemonic-activate",
1064                     G_CALLBACK (pspp_sheet_view_column_mnemonic_activate),
1065                     tree_column);
1066
1067   if (tree_column->xalign <= 0.5)
1068     gtk_box_pack_end (GTK_BOX (hbox), tree_column->arrow, FALSE, FALSE, 0);
1069   else
1070     gtk_box_pack_start (GTK_BOX (hbox), tree_column->arrow, FALSE, FALSE, 0);
1071
1072   gtk_box_pack_start (GTK_BOX (hbox), tree_column->alignment, TRUE, TRUE, 0);
1073
1074   gtk_container_add (GTK_CONTAINER (tree_column->alignment), child);
1075   gtk_container_add (GTK_CONTAINER (tree_column->button), hbox);
1076
1077   gtk_widget_show (hbox);
1078   gtk_widget_show (tree_column->alignment);
1079   pspp_sheet_view_column_update_button (tree_column);
1080 }
1081
1082 void
1083 pspp_sheet_view_column_update_button (PsppSheetViewColumn *tree_column)
1084 {
1085   gint sort_column_id = -1;
1086   GtkWidget *hbox;
1087   GtkWidget *alignment;
1088   GtkWidget *arrow;
1089   GtkWidget *current_child;
1090   GtkArrowType arrow_type = GTK_ARROW_NONE;
1091   GtkTreeModel *model;
1092   gboolean can_focus;
1093
1094   if (tree_column->tree_view)
1095     model = pspp_sheet_view_get_model (PSPP_SHEET_VIEW (tree_column->tree_view));
1096   else
1097     model = NULL;
1098
1099   /* Create a button if necessary */
1100   if (tree_column->need_button &&
1101       tree_column->visible &&
1102       tree_column->button == NULL &&
1103       tree_column->tree_view &&
1104       gtk_widget_get_realized (tree_column->tree_view))
1105     pspp_sheet_view_column_create_button (tree_column);
1106
1107   if (! tree_column->button)
1108     return;
1109
1110   hbox = gtk_bin_get_child (GTK_BIN (tree_column->button));
1111   alignment = tree_column->alignment;
1112   arrow = tree_column->arrow;
1113   current_child = gtk_bin_get_child (GTK_BIN (alignment));
1114
1115   /* Set up the actual button */
1116   gtk_alignment_set (GTK_ALIGNMENT (alignment), tree_column->xalign,
1117                      0.5, 0.0, 0.0);
1118
1119   if (tree_column->child)
1120     {
1121       if (current_child != tree_column->child)
1122         {
1123           gtk_container_remove (GTK_CONTAINER (alignment),
1124                                 current_child);
1125           gtk_container_add (GTK_CONTAINER (alignment),
1126                              tree_column->child);
1127         }
1128     }
1129   else
1130     {
1131       if (current_child == NULL)
1132         {
1133           current_child = gtk_label_new (NULL);
1134           gtk_widget_show (current_child);
1135           gtk_container_add (GTK_CONTAINER (alignment),
1136                              current_child);
1137         }
1138
1139       g_return_if_fail (GTK_IS_LABEL (current_child));
1140
1141       if (tree_column->title)
1142         gtk_label_set_text_with_mnemonic (GTK_LABEL (current_child),
1143                                           tree_column->title);
1144       else
1145         gtk_label_set_text_with_mnemonic (GTK_LABEL (current_child),
1146                                           "");
1147     }
1148
1149   if (GTK_IS_TREE_SORTABLE (model))
1150     gtk_tree_sortable_get_sort_column_id (GTK_TREE_SORTABLE (model),
1151                                           &sort_column_id,
1152                                           NULL);
1153
1154   if (tree_column->show_sort_indicator)
1155     {
1156       gboolean alternative;
1157
1158       g_object_get (gtk_widget_get_settings (tree_column->tree_view),
1159                     "gtk-alternative-sort-arrows", &alternative,
1160                     NULL);
1161
1162       switch (tree_column->sort_order)
1163         {
1164           case GTK_SORT_ASCENDING:
1165             arrow_type = alternative ? GTK_ARROW_UP : GTK_ARROW_DOWN;
1166             break;
1167
1168           case GTK_SORT_DESCENDING:
1169             arrow_type = alternative ? GTK_ARROW_DOWN : GTK_ARROW_UP;
1170             break;
1171
1172           default:
1173             g_warning (G_STRLOC": bad sort order");
1174             break;
1175         }
1176     }
1177
1178   gtk_arrow_set (GTK_ARROW (arrow),
1179                  arrow_type,
1180                  GTK_SHADOW_IN);
1181
1182   /* Put arrow on the right if the text is left-or-center justified, and on the
1183    * left otherwise; do this by packing boxes, so flipping text direction will
1184    * reverse things
1185    */
1186   g_object_ref (arrow);
1187   gtk_container_remove (GTK_CONTAINER (hbox), arrow);
1188
1189   if (tree_column->xalign <= 0.5)
1190     {
1191       gtk_box_pack_end (GTK_BOX (hbox), arrow, FALSE, FALSE, 0);
1192     }
1193   else
1194     {
1195       gtk_box_pack_start (GTK_BOX (hbox), arrow, FALSE, FALSE, 0);
1196       /* move it to the front */
1197       gtk_box_reorder_child (GTK_BOX (hbox), arrow, 0);
1198     }
1199   g_object_unref (arrow);
1200
1201   if (tree_column->show_sort_indicator
1202       || (GTK_IS_TREE_SORTABLE (model) && tree_column->sort_column_id >= 0))
1203     gtk_widget_show (arrow);
1204   else
1205     gtk_widget_hide (arrow);
1206
1207   /* It's always safe to hide the button.  It isn't always safe to show it, as
1208    * if you show it before it's realized, it'll get the wrong window. */
1209   if (tree_column->button &&
1210       tree_column->tree_view != NULL &&
1211       gtk_widget_get_realized (tree_column->tree_view))
1212     {
1213       if (tree_column->visible)
1214         {
1215           gtk_widget_show_now (tree_column->button);
1216           if (tree_column->window)
1217             {
1218               if (tree_column->resizable)
1219                 {
1220                   gdk_window_show (tree_column->window);
1221                   gdk_window_raise (tree_column->window);
1222                 }
1223               else
1224                 {
1225                   gdk_window_hide (tree_column->window);
1226                 }
1227             }
1228         }
1229       else
1230         {
1231           gtk_widget_hide (tree_column->button);
1232           if (tree_column->window)
1233             gdk_window_hide (tree_column->window);
1234         }
1235     }
1236
1237   can_focus = pspp_sheet_view_column_can_focus (tree_column);
1238   gtk_widget_set_can_focus (tree_column->button, can_focus);
1239   if (!can_focus && gtk_widget_has_focus (tree_column->button))
1240     {
1241       GtkWidget *toplevel = gtk_widget_get_toplevel (tree_column->tree_view);
1242       if (gtk_widget_is_toplevel (toplevel))
1243         {
1244           gtk_window_set_focus (GTK_WINDOW (toplevel), NULL);
1245         }
1246     }
1247
1248   /* Queue a resize on the assumption that we always want to catch all changes
1249    * and columns don't change all that often.
1250    */
1251   if (gtk_widget_get_realized (tree_column->tree_view))
1252      gtk_widget_queue_resize (tree_column->tree_view);
1253
1254 }
1255
1256 /* Button signal handlers
1257  */
1258
1259 static gint
1260 pspp_sheet_view_column_button_event (GtkWidget *widget,
1261                                    GdkEvent  *event,
1262                                    gpointer   data)
1263 {
1264   PsppSheetViewColumn *column = (PsppSheetViewColumn *) data;
1265
1266   g_return_val_if_fail (event != NULL, FALSE);
1267
1268   if (event->type == GDK_BUTTON_PRESS &&
1269       column->reorderable &&
1270       ((GdkEventButton *)event)->button == 1)
1271     {
1272       column->maybe_reordered = TRUE;
1273       gdk_window_get_pointer (gtk_button_get_event_window (GTK_BUTTON (widget)),
1274                               &column->drag_x,
1275                               &column->drag_y,
1276                               NULL);
1277       gtk_widget_grab_focus (widget);
1278     }
1279
1280   if (event->type == GDK_BUTTON_RELEASE ||
1281       event->type == GDK_LEAVE_NOTIFY)
1282     column->maybe_reordered = FALSE;
1283
1284   if (event->type == GDK_MOTION_NOTIFY &&
1285       column->maybe_reordered &&
1286       (gtk_drag_check_threshold (widget,
1287                                  column->drag_x,
1288                                  column->drag_y,
1289                                  (gint) ((GdkEventMotion *)event)->x,
1290                                  (gint) ((GdkEventMotion *)event)->y)))
1291     {
1292       column->maybe_reordered = FALSE;
1293       _pspp_sheet_view_column_start_drag (PSPP_SHEET_VIEW (column->tree_view), column);
1294       return TRUE;
1295     }
1296   if (column->clickable == FALSE)
1297     {
1298       switch (event->type)
1299         {
1300         case GDK_MOTION_NOTIFY:
1301         case GDK_BUTTON_RELEASE:
1302         case GDK_ENTER_NOTIFY:
1303         case GDK_LEAVE_NOTIFY:
1304           return TRUE;
1305         default:
1306           return FALSE;
1307         }
1308     }
1309   return FALSE;
1310 }
1311
1312 static gboolean
1313 all_rows_selected (PsppSheetView *sheet_view)
1314 {
1315   PsppSheetSelection *selection = sheet_view->priv->selection;
1316   gint n_rows, n_selected_rows;
1317
1318   n_rows = sheet_view->priv->row_count;
1319   n_selected_rows = pspp_sheet_selection_count_selected_rows (selection);
1320
1321   return n_rows > 0 && n_selected_rows >= n_rows;
1322 }
1323
1324 static gboolean
1325 on_pspp_sheet_view_column_button_press_event (PsppSheetViewColumn *column,
1326                                               GdkEventButton *event)
1327 {
1328   PsppSheetView *sheet_view = PSPP_SHEET_VIEW (column->tree_view);
1329   PsppSheetSelection *selection;
1330   GSignalInvocationHint *hint;
1331   guint modifiers;
1332
1333   /* We only want to run first, not last, but combining that with return type
1334      `gboolean' makes GObject warn, so just ignore the run_last call. */
1335   hint = g_signal_get_invocation_hint (column);
1336   g_return_val_if_fail (hint != NULL, FALSE);
1337   if (hint->run_type != G_SIGNAL_RUN_FIRST)
1338     return FALSE;
1339
1340   g_return_val_if_fail (sheet_view != NULL, FALSE);
1341
1342   selection = sheet_view->priv->selection;
1343   g_return_val_if_fail (selection != NULL, FALSE);
1344
1345   if (pspp_sheet_selection_get_mode (selection) != PSPP_SHEET_SELECTION_RECTANGLE)
1346     return FALSE;
1347
1348   modifiers = event->state & gtk_accelerator_get_default_mod_mask ();
1349   if (event->type == GDK_BUTTON_PRESS && event->button == 3)
1350     {
1351       if (pspp_sheet_selection_count_selected_columns (selection) <= 1
1352           || !all_rows_selected (sheet_view))
1353         {
1354           pspp_sheet_selection_select_all (selection);
1355           pspp_sheet_selection_unselect_all_columns (selection);
1356           pspp_sheet_selection_select_column (selection, column);
1357           sheet_view->priv->anchor_column = column;
1358         }
1359       return FALSE;
1360     }
1361   else if (event->type == GDK_BUTTON_PRESS && event->button == 1
1362            && modifiers == GDK_CONTROL_MASK)
1363     {
1364       gboolean is_selected;
1365
1366       if (!all_rows_selected (sheet_view))
1367         {
1368           pspp_sheet_selection_select_all (selection);
1369           pspp_sheet_selection_unselect_all_columns (selection);
1370         }
1371       sheet_view->priv->anchor_column = column;
1372
1373       is_selected = pspp_sheet_view_column_get_selected (column);
1374       pspp_sheet_view_column_set_selected (column, !is_selected);
1375
1376       return TRUE;
1377     }
1378   else if (event->type == GDK_BUTTON_PRESS && event->button == 1
1379            && modifiers == GDK_SHIFT_MASK)
1380     {
1381       if (!all_rows_selected (sheet_view))
1382         {
1383           pspp_sheet_selection_select_all (selection);
1384           pspp_sheet_selection_unselect_all_columns (selection);
1385           sheet_view->priv->anchor_column = column;
1386         }
1387       else if (sheet_view->priv->anchor_column == NULL)
1388         sheet_view->priv->anchor_column = column;
1389
1390       pspp_sheet_selection_unselect_all_columns (selection);
1391       pspp_sheet_selection_select_column_range (selection,
1392                                                 sheet_view->priv->anchor_column,
1393                                                 column);
1394       return TRUE;
1395     }
1396
1397   return FALSE;
1398 }
1399
1400 static gboolean
1401 on_pspp_sheet_view_column_button_clicked (PsppSheetViewColumn *column)
1402 {
1403   PsppSheetSelection *selection;
1404   PsppSheetView *sheet_view;
1405
1406   sheet_view = PSPP_SHEET_VIEW (pspp_sheet_view_column_get_tree_view (column));
1407   selection = pspp_sheet_view_get_selection (sheet_view);
1408   if (pspp_sheet_selection_get_mode (selection) == PSPP_SHEET_SELECTION_RECTANGLE)
1409     {
1410       pspp_sheet_selection_select_all (selection);
1411       if (pspp_sheet_view_column_get_row_head (column))
1412         pspp_sheet_selection_select_all_columns (selection);
1413       else
1414         {
1415           pspp_sheet_selection_unselect_all_columns (selection);
1416           pspp_sheet_selection_select_column (selection, column);
1417         }
1418       sheet_view->priv->anchor_column = column;
1419       return TRUE;
1420     }
1421   return FALSE;
1422 }
1423
1424 static void
1425 pspp_sheet_view_column_button_clicked (GtkWidget *widget, gpointer data)
1426 {
1427   PsppSheetViewColumn *column = data;
1428   gboolean handled;
1429
1430   g_signal_emit (column, tree_column_signals[CLICKED], 0, &handled);
1431 }
1432
1433 static void
1434 pspp_sheet_view_column_button_popup_menu (GtkWidget *widget, gpointer data)
1435 {
1436   g_signal_emit_by_name (data, "popup-menu");
1437 }
1438
1439 static gboolean
1440 pspp_sheet_view_column_mnemonic_activate (GtkWidget *widget,
1441                                         gboolean   group_cycling,
1442                                         gpointer   data)
1443 {
1444   PsppSheetViewColumn *column = (PsppSheetViewColumn *)data;
1445
1446   g_return_val_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (column), FALSE);
1447
1448   PSPP_SHEET_VIEW (column->tree_view)->priv->focus_column = column;
1449   if (column->clickable)
1450     gtk_button_clicked (GTK_BUTTON (column->button));
1451   else if (gtk_widget_get_can_focus (column->button))
1452     gtk_widget_grab_focus (column->button);
1453   else
1454     gtk_widget_grab_focus (column->tree_view);
1455
1456   return TRUE;
1457 }
1458
1459 static void
1460 pspp_sheet_view_model_sort_column_changed (GtkTreeSortable   *sortable,
1461                                          PsppSheetViewColumn *column)
1462 {
1463   gint sort_column_id;
1464   GtkSortType order;
1465
1466   if (gtk_tree_sortable_get_sort_column_id (sortable,
1467                                             &sort_column_id,
1468                                             &order))
1469     {
1470       if (sort_column_id == column->sort_column_id)
1471         {
1472           pspp_sheet_view_column_set_sort_indicator (column, TRUE);
1473           pspp_sheet_view_column_set_sort_order (column, order);
1474         }
1475       else
1476         {
1477           pspp_sheet_view_column_set_sort_indicator (column, FALSE);
1478         }
1479     }
1480   else
1481     {
1482       pspp_sheet_view_column_set_sort_indicator (column, FALSE);
1483     }
1484 }
1485
1486 static void
1487 pspp_sheet_view_column_sort (PsppSheetViewColumn *tree_column,
1488                            gpointer           data)
1489 {
1490   gint sort_column_id;
1491   GtkSortType order;
1492   gboolean has_sort_column;
1493   gboolean has_default_sort_func;
1494
1495   g_return_if_fail (tree_column->tree_view != NULL);
1496
1497   has_sort_column =
1498     gtk_tree_sortable_get_sort_column_id (GTK_TREE_SORTABLE (PSPP_SHEET_VIEW (tree_column->tree_view)->priv->model),
1499                                           &sort_column_id,
1500                                           &order);
1501   has_default_sort_func =
1502     gtk_tree_sortable_has_default_sort_func (GTK_TREE_SORTABLE (PSPP_SHEET_VIEW (tree_column->tree_view)->priv->model));
1503
1504   if (has_sort_column &&
1505       sort_column_id == tree_column->sort_column_id)
1506     {
1507       if (order == GTK_SORT_ASCENDING)
1508         gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (PSPP_SHEET_VIEW (tree_column->tree_view)->priv->model),
1509                                               tree_column->sort_column_id,
1510                                               GTK_SORT_DESCENDING);
1511       else if (order == GTK_SORT_DESCENDING && has_default_sort_func)
1512         gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (PSPP_SHEET_VIEW (tree_column->tree_view)->priv->model),
1513                                               GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID,
1514                                               GTK_SORT_ASCENDING);
1515       else
1516         gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (PSPP_SHEET_VIEW (tree_column->tree_view)->priv->model),
1517                                               tree_column->sort_column_id,
1518                                               GTK_SORT_ASCENDING);
1519     }
1520   else
1521     {
1522       gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (PSPP_SHEET_VIEW (tree_column->tree_view)->priv->model),
1523                                             tree_column->sort_column_id,
1524                                             GTK_SORT_ASCENDING);
1525     }
1526 }
1527
1528
1529 static void
1530 pspp_sheet_view_column_setup_sort_column_id_callback (PsppSheetViewColumn *tree_column)
1531 {
1532   GtkTreeModel *model;
1533
1534   if (tree_column->tree_view == NULL)
1535     return;
1536
1537   model = pspp_sheet_view_get_model (PSPP_SHEET_VIEW (tree_column->tree_view));
1538
1539   if (model == NULL)
1540     return;
1541
1542   if (GTK_IS_TREE_SORTABLE (model) &&
1543       tree_column->sort_column_id != -1)
1544     {
1545       gint real_sort_column_id;
1546       GtkSortType real_order;
1547
1548       if (tree_column->sort_column_changed_signal == 0)
1549         tree_column->sort_column_changed_signal =
1550           g_signal_connect (model, "sort-column-changed",
1551                             G_CALLBACK (pspp_sheet_view_model_sort_column_changed),
1552                             tree_column);
1553
1554       if (gtk_tree_sortable_get_sort_column_id (GTK_TREE_SORTABLE (model),
1555                                                 &real_sort_column_id,
1556                                                 &real_order) &&
1557           (real_sort_column_id == tree_column->sort_column_id))
1558         {
1559           pspp_sheet_view_column_set_sort_indicator (tree_column, TRUE);
1560           pspp_sheet_view_column_set_sort_order (tree_column, real_order);
1561         }
1562       else
1563         {
1564           pspp_sheet_view_column_set_sort_indicator (tree_column, FALSE);
1565         }
1566    }
1567 }
1568
1569
1570 /* Exported Private Functions.
1571  * These should only be called by gtktreeview.c or gtktreeviewcolumn.c
1572  */
1573
1574 void
1575 _pspp_sheet_view_column_realize_button (PsppSheetViewColumn *column)
1576 {
1577   GtkAllocation allocation;
1578   PsppSheetView *tree_view;
1579   GdkWindowAttr attr;
1580   guint attributes_mask;
1581   gboolean rtl;
1582
1583   tree_view = (PsppSheetView *)column->tree_view;
1584   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
1585
1586   g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
1587   g_return_if_fail (gtk_widget_get_realized (GTK_WIDGET (tree_view)));
1588   g_return_if_fail (tree_view->priv->header_window != NULL);
1589   if (!column->need_button || !column->button)
1590     return;
1591
1592   g_return_if_fail (column->button != NULL);
1593
1594   gtk_widget_set_parent_window (column->button, tree_view->priv->header_window);
1595
1596   if (column->visible)
1597     gtk_widget_show (column->button);
1598
1599   attr.window_type = GDK_WINDOW_CHILD;
1600   attr.wclass = GDK_INPUT_ONLY;
1601   attr.visual = gtk_widget_get_visual (GTK_WIDGET (tree_view));
1602   attr.event_mask = gtk_widget_get_events (GTK_WIDGET (tree_view)) |
1603                     (GDK_BUTTON_PRESS_MASK |
1604                      GDK_BUTTON_RELEASE_MASK |
1605                      GDK_POINTER_MOTION_MASK |
1606                      GDK_POINTER_MOTION_HINT_MASK |
1607                      GDK_KEY_PRESS_MASK);
1608   attributes_mask = GDK_WA_CURSOR | GDK_WA_X | GDK_WA_Y;
1609   attr.cursor = gdk_cursor_new_for_display (gdk_window_get_display (tree_view->priv->header_window),
1610                                             GDK_SB_H_DOUBLE_ARROW);
1611   attr.y = 0;
1612   attr.width = TREE_VIEW_DRAG_WIDTH;
1613   attr.height = tree_view->priv->header_height;
1614   gtk_widget_get_allocation (column->button, &allocation);
1615   attr.x = (allocation.x + (rtl ? 0 : allocation.width)) - TREE_VIEW_DRAG_WIDTH / 2;
1616   column->window = gdk_window_new (tree_view->priv->header_window,
1617                                    &attr, attributes_mask);
1618   gdk_window_set_user_data (column->window, tree_view);
1619
1620   pspp_sheet_view_column_update_button (column);
1621
1622   gdk_cursor_unref (attr.cursor);
1623 }
1624
1625 void
1626 _pspp_sheet_view_column_unrealize_button (PsppSheetViewColumn *column)
1627 {
1628   g_return_if_fail (column != NULL);
1629   if (column->window != NULL)
1630     {
1631       gdk_window_set_user_data (column->window, NULL);
1632       gdk_window_destroy (column->window);
1633       column->window = NULL;
1634     }
1635 }
1636
1637 void
1638 _pspp_sheet_view_column_unset_model (PsppSheetViewColumn *column,
1639                                    GtkTreeModel      *old_model)
1640 {
1641   if (column->sort_column_changed_signal)
1642     {
1643       g_signal_handler_disconnect (old_model,
1644                                    column->sort_column_changed_signal);
1645       column->sort_column_changed_signal = 0;
1646     }
1647   pspp_sheet_view_column_set_sort_indicator (column, FALSE);
1648 }
1649
1650 void
1651 _pspp_sheet_view_column_set_tree_view (PsppSheetViewColumn *column,
1652                                      PsppSheetView       *tree_view)
1653 {
1654   g_assert (column->tree_view == NULL);
1655
1656   column->tree_view = GTK_WIDGET (tree_view);
1657   if (column->need_button)
1658     pspp_sheet_view_column_create_button (column);
1659
1660   column->property_changed_signal =
1661           g_signal_connect_swapped (tree_view,
1662                                     "notify::model",
1663                                     G_CALLBACK (pspp_sheet_view_column_setup_sort_column_id_callback),
1664                                     column);
1665
1666   pspp_sheet_view_column_setup_sort_column_id_callback (column);
1667 }
1668
1669 void
1670 _pspp_sheet_view_column_unset_tree_view (PsppSheetViewColumn *column)
1671 {
1672   if (column->tree_view && column->button)
1673     {
1674       gtk_container_remove (GTK_CONTAINER (column->tree_view), column->button);
1675     }
1676   if (column->property_changed_signal)
1677     {
1678       g_signal_handler_disconnect (column->tree_view, column->property_changed_signal);
1679       column->property_changed_signal = 0;
1680     }
1681
1682   if (column->sort_column_changed_signal)
1683     {
1684       g_signal_handler_disconnect (pspp_sheet_view_get_model (PSPP_SHEET_VIEW (column->tree_view)),
1685                                    column->sort_column_changed_signal);
1686       column->sort_column_changed_signal = 0;
1687     }
1688
1689   column->tree_view = NULL;
1690   column->button = NULL;
1691 }
1692
1693 gboolean
1694 _pspp_sheet_view_column_has_editable_cell (PsppSheetViewColumn *column)
1695 {
1696   GList *list;
1697
1698   for (list = column->cell_list; list; list = list->next)
1699     {
1700       GtkCellRendererMode mode;
1701       g_object_get (((PsppSheetViewColumnCellInfo *)list->data)->cell, "mode", &mode, NULL);
1702       if (mode == GTK_CELL_RENDERER_MODE_EDITABLE)
1703         return TRUE;
1704     }
1705
1706   return FALSE;
1707 }
1708
1709 /* gets cell being edited */
1710 GtkCellRenderer *
1711 _pspp_sheet_view_column_get_edited_cell (PsppSheetViewColumn *column)
1712 {
1713   GList *list;
1714
1715   for (list = column->cell_list; list; list = list->next)
1716     if (((PsppSheetViewColumnCellInfo *)list->data)->in_editing_mode)
1717       return ((PsppSheetViewColumnCellInfo *)list->data)->cell;
1718
1719   return NULL;
1720 }
1721
1722 gint
1723 _pspp_sheet_view_column_count_special_cells (PsppSheetViewColumn *column)
1724 {
1725   gint i = 0;
1726   GList *list;
1727
1728   for (list = column->cell_list; list; list = list->next)
1729     {
1730       PsppSheetViewColumnCellInfo *cellinfo = list->data;
1731
1732       GtkCellRendererMode mode;
1733       g_object_get (cellinfo->cell, "mode", &mode, NULL);
1734
1735       if ((mode == GTK_CELL_RENDERER_MODE_EDITABLE ||
1736           mode == GTK_CELL_RENDERER_MODE_ACTIVATABLE) &&
1737           gtk_cell_renderer_get_visible (cellinfo->cell))
1738         i++;
1739     }
1740
1741   return i;
1742 }
1743
1744 GtkCellRenderer *
1745 _pspp_sheet_view_column_get_cell_at_pos (PsppSheetViewColumn *column,
1746                                        gint               x)
1747 {
1748   GList *list;
1749   gint current_x = 0;
1750
1751   list = pspp_sheet_view_column_cell_first (column);
1752   for (; list; list = pspp_sheet_view_column_cell_next (column, list))
1753    {
1754      PsppSheetViewColumnCellInfo *cellinfo = list->data;
1755      if (current_x <= x && x <= current_x + cellinfo->real_width)
1756        return cellinfo->cell;
1757      current_x += cellinfo->real_width;
1758    }
1759
1760   return NULL;
1761 }
1762
1763 /* Public Functions */
1764
1765
1766 /**
1767  * pspp_sheet_view_column_new:
1768  *
1769  * Creates a new #PsppSheetViewColumn.
1770  *
1771  * Return value: A newly created #PsppSheetViewColumn.
1772  **/
1773 PsppSheetViewColumn *
1774 pspp_sheet_view_column_new (void)
1775 {
1776   PsppSheetViewColumn *tree_column;
1777
1778   tree_column = g_object_new (PSPP_TYPE_SHEET_VIEW_COLUMN, NULL);
1779
1780   return tree_column;
1781 }
1782
1783 /**
1784  * pspp_sheet_view_column_new_with_attributes:
1785  * @title: The title to set the header to.
1786  * @cell: The #GtkCellRenderer.
1787  * @Varargs: A %NULL-terminated list of attributes.
1788  *
1789  * Creates a new #PsppSheetViewColumn with a number of default values.  This is
1790  * equivalent to calling pspp_sheet_view_column_set_title(),
1791  * pspp_sheet_view_column_pack_start(), and
1792  * pspp_sheet_view_column_set_attributes() on the newly created #PsppSheetViewColumn.
1793  *
1794  * Here's a simple example:
1795  * |[
1796  *  enum { TEXT_COLUMN, COLOR_COLUMN, N_COLUMNS };
1797  *  ...
1798  *  {
1799  *    PsppSheetViewColumn *column;
1800  *    GtkCellRenderer   *renderer = gtk_cell_renderer_text_new ();
1801  *
1802  *    column = pspp_sheet_view_column_new_with_attributes ("Title",
1803  *                                                       renderer,
1804  *                                                       "text", TEXT_COLUMN,
1805  *                                                       "foreground", COLOR_COLUMN,
1806  *                                                       NULL);
1807  *  }
1808  * ]|
1809  *
1810  * Return value: A newly created #PsppSheetViewColumn.
1811  **/
1812 PsppSheetViewColumn *
1813 pspp_sheet_view_column_new_with_attributes (const gchar     *title,
1814                                           GtkCellRenderer *cell,
1815                                           ...)
1816 {
1817   PsppSheetViewColumn *retval;
1818   va_list args;
1819
1820   retval = pspp_sheet_view_column_new ();
1821
1822   pspp_sheet_view_column_set_title (retval, title);
1823   pspp_sheet_view_column_pack_start (retval, cell, TRUE);
1824
1825   va_start (args, cell);
1826   pspp_sheet_view_column_set_attributesv (retval, cell, args);
1827   va_end (args);
1828
1829   return retval;
1830 }
1831
1832 static PsppSheetViewColumnCellInfo *
1833 pspp_sheet_view_column_get_cell_info (PsppSheetViewColumn *tree_column,
1834                                     GtkCellRenderer   *cell_renderer)
1835 {
1836   GList *list;
1837   for (list = tree_column->cell_list; list; list = list->next)
1838     if (((PsppSheetViewColumnCellInfo *)list->data)->cell == cell_renderer)
1839       return (PsppSheetViewColumnCellInfo *) list->data;
1840   return NULL;
1841 }
1842
1843
1844 /**
1845  * pspp_sheet_view_column_pack_start:
1846  * @tree_column: A #PsppSheetViewColumn.
1847  * @cell: The #GtkCellRenderer.
1848  * @expand: %TRUE if @cell is to be given extra space allocated to @tree_column.
1849  *
1850  * Packs the @cell into the beginning of the column. If @expand is %FALSE, then
1851  * the @cell is allocated no more space than it needs. Any unused space is divided
1852  * evenly between cells for which @expand is %TRUE.
1853  **/
1854 void
1855 pspp_sheet_view_column_pack_start (PsppSheetViewColumn *tree_column,
1856                                  GtkCellRenderer   *cell,
1857                                  gboolean           expand)
1858 {
1859   gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (tree_column), cell, expand);
1860 }
1861
1862 /**
1863  * pspp_sheet_view_column_pack_end:
1864  * @tree_column: A #PsppSheetViewColumn.
1865  * @cell: The #GtkCellRenderer.
1866  * @expand: %TRUE if @cell is to be given extra space allocated to @tree_column.
1867  *
1868  * Adds the @cell to end of the column. If @expand is %FALSE, then the @cell
1869  * is allocated no more space than it needs. Any unused space is divided
1870  * evenly between cells for which @expand is %TRUE.
1871  **/
1872 void
1873 pspp_sheet_view_column_pack_end (PsppSheetViewColumn  *tree_column,
1874                                GtkCellRenderer    *cell,
1875                                gboolean            expand)
1876 {
1877   gtk_cell_layout_pack_end (GTK_CELL_LAYOUT (tree_column), cell, expand);
1878 }
1879
1880 /**
1881  * pspp_sheet_view_column_clear:
1882  * @tree_column: A #PsppSheetViewColumn
1883  *
1884  * Unsets all the mappings on all renderers on the @tree_column.
1885  **/
1886 void
1887 pspp_sheet_view_column_clear (PsppSheetViewColumn *tree_column)
1888 {
1889   gtk_cell_layout_clear (GTK_CELL_LAYOUT (tree_column));
1890 }
1891
1892 static GList *
1893 pspp_sheet_view_column_cell_layout_get_cells (GtkCellLayout *layout)
1894 {
1895   PsppSheetViewColumn *tree_column = PSPP_SHEET_VIEW_COLUMN (layout);
1896   GList *retval = NULL, *list;
1897
1898   g_return_val_if_fail (tree_column != NULL, NULL);
1899
1900   for (list = tree_column->cell_list; list; list = list->next)
1901     {
1902       PsppSheetViewColumnCellInfo *info = (PsppSheetViewColumnCellInfo *)list->data;
1903
1904       retval = g_list_append (retval, info->cell);
1905     }
1906
1907   return retval;
1908 }
1909
1910 /**
1911  * pspp_sheet_view_column_get_cell_renderers:
1912  * @tree_column: A #PsppSheetViewColumn
1913  *
1914  * Returns a newly-allocated #GList of all the cell renderers in the column,
1915  * in no particular order.  The list must be freed with g_list_free().
1916  *
1917  * Return value: A list of #GtkCellRenderers
1918  *
1919  * Deprecated: 2.18: use gtk_cell_layout_get_cells() instead.
1920  **/
1921 GList *
1922 pspp_sheet_view_column_get_cell_renderers (PsppSheetViewColumn *tree_column)
1923 {
1924   return pspp_sheet_view_column_cell_layout_get_cells (GTK_CELL_LAYOUT (tree_column));
1925 }
1926
1927 /**
1928  * pspp_sheet_view_column_add_attribute:
1929  * @tree_column: A #PsppSheetViewColumn.
1930  * @cell_renderer: the #GtkCellRenderer to set attributes on
1931  * @attribute: An attribute on the renderer
1932  * @column: The column position on the model to get the attribute from.
1933  *
1934  * Adds an attribute mapping to the list in @tree_column.  The @column is the
1935  * column of the model to get a value from, and the @attribute is the
1936  * parameter on @cell_renderer to be set from the value. So for example
1937  * if column 2 of the model contains strings, you could have the
1938  * "text" attribute of a #GtkCellRendererText get its values from
1939  * column 2.
1940  **/
1941 void
1942 pspp_sheet_view_column_add_attribute (PsppSheetViewColumn *tree_column,
1943                                     GtkCellRenderer   *cell_renderer,
1944                                     const gchar       *attribute,
1945                                     gint               column)
1946 {
1947   gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (tree_column),
1948                                  cell_renderer, attribute, column);
1949 }
1950
1951 static void
1952 pspp_sheet_view_column_set_attributesv (PsppSheetViewColumn *tree_column,
1953                                       GtkCellRenderer   *cell_renderer,
1954                                       va_list            args)
1955 {
1956   gchar *attribute;
1957   gint column;
1958
1959   attribute = va_arg (args, gchar *);
1960
1961   pspp_sheet_view_column_clear_attributes (tree_column, cell_renderer);
1962
1963   while (attribute != NULL)
1964     {
1965       column = va_arg (args, gint);
1966       pspp_sheet_view_column_add_attribute (tree_column, cell_renderer, attribute, column);
1967       attribute = va_arg (args, gchar *);
1968     }
1969 }
1970
1971 /**
1972  * pspp_sheet_view_column_set_attributes:
1973  * @tree_column: A #PsppSheetViewColumn.
1974  * @cell_renderer: the #GtkCellRenderer we're setting the attributes of
1975  * @Varargs: A %NULL-terminated list of attributes.
1976  *
1977  * Sets the attributes in the list as the attributes of @tree_column.
1978  * The attributes should be in attribute/column order, as in
1979  * pspp_sheet_view_column_add_attribute(). All existing attributes
1980  * are removed, and replaced with the new attributes.
1981  **/
1982 void
1983 pspp_sheet_view_column_set_attributes (PsppSheetViewColumn *tree_column,
1984                                      GtkCellRenderer   *cell_renderer,
1985                                      ...)
1986 {
1987   va_list args;
1988
1989   g_return_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column));
1990   g_return_if_fail (GTK_IS_CELL_RENDERER (cell_renderer));
1991   g_return_if_fail (pspp_sheet_view_column_get_cell_info (tree_column, cell_renderer));
1992
1993   va_start (args, cell_renderer);
1994   pspp_sheet_view_column_set_attributesv (tree_column, cell_renderer, args);
1995   va_end (args);
1996 }
1997
1998
1999 /**
2000  * pspp_sheet_view_column_set_cell_data_func:
2001  * @tree_column: A #PsppSheetViewColumn
2002  * @cell_renderer: A #GtkCellRenderer
2003  * @func: The #PsppSheetViewColumnFunc to use.
2004  * @func_data: The user data for @func.
2005  * @destroy: The destroy notification for @func_data
2006  *
2007  * Sets the #PsppSheetViewColumnFunc to use for the column.  This
2008  * function is used instead of the standard attributes mapping for
2009  * setting the column value, and should set the value of @tree_column's
2010  * cell renderer as appropriate.  @func may be %NULL to remove an
2011  * older one.
2012  **/
2013 void
2014 pspp_sheet_view_column_set_cell_data_func (PsppSheetViewColumn   *tree_column,
2015                                          GtkCellRenderer     *cell_renderer,
2016                                          PsppSheetCellDataFunc  func,
2017                                          gpointer             func_data,
2018                                          GDestroyNotify       destroy)
2019 {
2020   gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (tree_column),
2021                                       cell_renderer,
2022                                       (GtkCellLayoutDataFunc)func,
2023                                       func_data, destroy);
2024 }
2025
2026
2027 /**
2028  * pspp_sheet_view_column_clear_attributes:
2029  * @tree_column: a #PsppSheetViewColumn
2030  * @cell_renderer: a #GtkCellRenderer to clear the attribute mapping on.
2031  *
2032  * Clears all existing attributes previously set with
2033  * pspp_sheet_view_column_set_attributes().
2034  **/
2035 void
2036 pspp_sheet_view_column_clear_attributes (PsppSheetViewColumn *tree_column,
2037                                        GtkCellRenderer   *cell_renderer)
2038 {
2039   gtk_cell_layout_clear_attributes (GTK_CELL_LAYOUT (tree_column),
2040                                     cell_renderer);
2041 }
2042
2043 /**
2044  * pspp_sheet_view_column_set_spacing:
2045  * @tree_column: A #PsppSheetViewColumn.
2046  * @spacing: distance between cell renderers in pixels.
2047  *
2048  * Sets the spacing field of @tree_column, which is the number of pixels to
2049  * place between cell renderers packed into it.
2050  **/
2051 void
2052 pspp_sheet_view_column_set_spacing (PsppSheetViewColumn *tree_column,
2053                                   gint               spacing)
2054 {
2055   g_return_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column));
2056   g_return_if_fail (spacing >= 0);
2057
2058   if (tree_column->spacing == spacing)
2059     return;
2060
2061   tree_column->spacing = spacing;
2062   if (tree_column->tree_view)
2063     _pspp_sheet_view_column_cell_set_dirty (tree_column);
2064 }
2065
2066 /**
2067  * pspp_sheet_view_column_get_spacing:
2068  * @tree_column: A #PsppSheetViewColumn.
2069  *
2070  * Returns the spacing of @tree_column.
2071  *
2072  * Return value: the spacing of @tree_column.
2073  **/
2074 gint
2075 pspp_sheet_view_column_get_spacing (PsppSheetViewColumn *tree_column)
2076 {
2077   g_return_val_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column), 0);
2078
2079   return tree_column->spacing;
2080 }
2081
2082 /* Options for manipulating the columns */
2083
2084 /**
2085  * pspp_sheet_view_column_set_visible:
2086  * @tree_column: A #PsppSheetViewColumn.
2087  * @visible: %TRUE if the @tree_column is visible.
2088  *
2089  * Sets the visibility of @tree_column.
2090  **/
2091 void
2092 pspp_sheet_view_column_set_visible (PsppSheetViewColumn *tree_column,
2093                                   gboolean           visible)
2094 {
2095   g_return_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column));
2096
2097   visible = !! visible;
2098
2099   if (tree_column->visible == visible)
2100     return;
2101
2102   tree_column->visible = visible;
2103
2104   if (tree_column->visible)
2105     _pspp_sheet_view_column_cell_set_dirty (tree_column);
2106
2107   pspp_sheet_view_column_update_button (tree_column);
2108   g_object_notify (G_OBJECT (tree_column), "visible");
2109 }
2110
2111 /**
2112  * pspp_sheet_view_column_get_visible:
2113  * @tree_column: A #PsppSheetViewColumn.
2114  *
2115  * Returns %TRUE if @tree_column is visible.
2116  *
2117  * Return value: whether the column is visible or not.  If it is visible, then
2118  * the tree will show the column.
2119  **/
2120 gboolean
2121 pspp_sheet_view_column_get_visible (PsppSheetViewColumn *tree_column)
2122 {
2123   g_return_val_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column), FALSE);
2124
2125   return tree_column->visible;
2126 }
2127
2128 /**
2129  * pspp_sheet_view_column_set_resizable:
2130  * @tree_column: A #PsppSheetViewColumn
2131  * @resizable: %TRUE, if the column can be resized
2132  *
2133  * If @resizable is %TRUE, then the user can explicitly resize the column by
2134  * grabbing the outer edge of the column button.
2135  **/
2136 void
2137 pspp_sheet_view_column_set_resizable (PsppSheetViewColumn *tree_column,
2138                                     gboolean           resizable)
2139 {
2140   g_return_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column));
2141
2142   resizable = !! resizable;
2143
2144   if (tree_column->resizable == resizable)
2145     return;
2146
2147   tree_column->resizable = resizable;
2148
2149   pspp_sheet_view_column_update_button (tree_column);
2150
2151   g_object_notify (G_OBJECT (tree_column), "resizable");
2152 }
2153
2154 /**
2155  * pspp_sheet_view_column_get_resizable:
2156  * @tree_column: A #PsppSheetViewColumn
2157  *
2158  * Returns %TRUE if the @tree_column can be resized by the end user.
2159  *
2160  * Return value: %TRUE, if the @tree_column can be resized.
2161  **/
2162 gboolean
2163 pspp_sheet_view_column_get_resizable (PsppSheetViewColumn *tree_column)
2164 {
2165   g_return_val_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column), FALSE);
2166
2167   return tree_column->resizable;
2168 }
2169
2170
2171 /**
2172  * pspp_sheet_view_column_get_width:
2173  * @tree_column: A #PsppSheetViewColumn.
2174  *
2175  * Returns the current size of @tree_column in pixels.
2176  *
2177  * Return value: The current width of @tree_column.
2178  **/
2179 gint
2180 pspp_sheet_view_column_get_width (PsppSheetViewColumn *tree_column)
2181 {
2182   g_return_val_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column), 0);
2183
2184   return tree_column->width;
2185 }
2186
2187 /**
2188  * pspp_sheet_view_column_set_fixed_width:
2189  * @tree_column: A #PsppSheetViewColumn.
2190  * @fixed_width: The size to set @tree_column to. Must be greater than 0.
2191  *
2192  * Sets the size of the column in pixels.  The size of the column is clamped to
2193  * the min/max width for the column.  Please note that the min/max width of the
2194  * column doesn't actually affect the "fixed_width" property of the widget, just
2195  * the actual size when displayed.
2196  **/
2197 void
2198 pspp_sheet_view_column_set_fixed_width (PsppSheetViewColumn *tree_column,
2199                                       gint               fixed_width)
2200 {
2201   g_return_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column));
2202   g_return_if_fail (fixed_width > 0);
2203
2204   tree_column->fixed_width = fixed_width;
2205   tree_column->use_resized_width = FALSE;
2206
2207   if (tree_column->tree_view &&
2208       gtk_widget_get_realized (tree_column->tree_view))
2209     {
2210       gtk_widget_queue_resize (tree_column->tree_view);
2211     }
2212
2213   g_object_notify (G_OBJECT (tree_column), "fixed-width");
2214 }
2215
2216 /**
2217  * pspp_sheet_view_column_get_fixed_width:
2218  * @tree_column: a #PsppSheetViewColumn
2219  *
2220  * Gets the fixed width of the column.  This value is only meaning may not be
2221  * the actual width of the column on the screen, just what is requested.
2222  *
2223  * Return value: the fixed width of the column
2224  **/
2225 gint
2226 pspp_sheet_view_column_get_fixed_width (PsppSheetViewColumn *tree_column)
2227 {
2228   g_return_val_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column), 0);
2229
2230   return tree_column->fixed_width;
2231 }
2232
2233 /**
2234  * pspp_sheet_view_column_set_min_width:
2235  * @tree_column: A #PsppSheetViewColumn.
2236  * @min_width: The minimum width of the column in pixels, or -1.
2237  *
2238  * Sets the minimum width of the @tree_column.  If @min_width is -1, then the
2239  * minimum width is unset.
2240  **/
2241 void
2242 pspp_sheet_view_column_set_min_width (PsppSheetViewColumn *tree_column,
2243                                     gint               min_width)
2244 {
2245   g_return_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column));
2246   g_return_if_fail (min_width >= -1);
2247
2248   if (min_width == tree_column->min_width)
2249     return;
2250
2251   if (tree_column->visible &&
2252       tree_column->tree_view != NULL &&
2253       gtk_widget_get_realized (tree_column->tree_view))
2254     {
2255       if (min_width > tree_column->width)
2256         gtk_widget_queue_resize (tree_column->tree_view);
2257     }
2258
2259   tree_column->min_width = min_width;
2260   g_object_freeze_notify (G_OBJECT (tree_column));
2261   if (tree_column->max_width != -1 && tree_column->max_width < min_width)
2262     {
2263       tree_column->max_width = min_width;
2264       g_object_notify (G_OBJECT (tree_column), "max-width");
2265     }
2266   g_object_notify (G_OBJECT (tree_column), "min-width");
2267   g_object_thaw_notify (G_OBJECT (tree_column));
2268 }
2269
2270 /**
2271  * pspp_sheet_view_column_get_min_width:
2272  * @tree_column: A #PsppSheetViewColumn.
2273  *
2274  * Returns the minimum width in pixels of the @tree_column, or -1 if no minimum
2275  * width is set.
2276  *
2277  * Return value: The minimum width of the @tree_column.
2278  **/
2279 gint
2280 pspp_sheet_view_column_get_min_width (PsppSheetViewColumn *tree_column)
2281 {
2282   g_return_val_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column), -1);
2283
2284   return tree_column->min_width;
2285 }
2286
2287 /**
2288  * pspp_sheet_view_column_set_max_width:
2289  * @tree_column: A #PsppSheetViewColumn.
2290  * @max_width: The maximum width of the column in pixels, or -1.
2291  *
2292  * Sets the maximum width of the @tree_column.  If @max_width is -1, then the
2293  * maximum width is unset.  Note, the column can actually be wider than max
2294  * width if it's the last column in a view.  In this case, the column expands to
2295  * fill any extra space.
2296  **/
2297 void
2298 pspp_sheet_view_column_set_max_width (PsppSheetViewColumn *tree_column,
2299                                     gint               max_width)
2300 {
2301   g_return_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column));
2302   g_return_if_fail (max_width >= -1);
2303
2304   if (max_width == tree_column->max_width)
2305     return;
2306
2307   if (tree_column->visible &&
2308       tree_column->tree_view != NULL &&
2309       gtk_widget_get_realized (tree_column->tree_view))
2310     {
2311       if (max_width != -1 && max_width < tree_column->width)
2312         gtk_widget_queue_resize (tree_column->tree_view);
2313     }
2314
2315   tree_column->max_width = max_width;
2316   g_object_freeze_notify (G_OBJECT (tree_column));
2317   if (max_width != -1 && max_width < tree_column->min_width)
2318     {
2319       tree_column->min_width = max_width;
2320       g_object_notify (G_OBJECT (tree_column), "min-width");
2321     }
2322   g_object_notify (G_OBJECT (tree_column), "max-width");
2323   g_object_thaw_notify (G_OBJECT (tree_column));
2324 }
2325
2326 /**
2327  * pspp_sheet_view_column_get_max_width:
2328  * @tree_column: A #PsppSheetViewColumn.
2329  *
2330  * Returns the maximum width in pixels of the @tree_column, or -1 if no maximum
2331  * width is set.
2332  *
2333  * Return value: The maximum width of the @tree_column.
2334  **/
2335 gint
2336 pspp_sheet_view_column_get_max_width (PsppSheetViewColumn *tree_column)
2337 {
2338   g_return_val_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column), -1);
2339
2340   return tree_column->max_width;
2341 }
2342
2343 /**
2344  * pspp_sheet_view_column_clicked:
2345  * @tree_column: a #PsppSheetViewColumn
2346  *
2347  * Emits the "clicked" signal on the column.  This function will only work if
2348  * @tree_column is clickable.
2349  **/
2350 void
2351 pspp_sheet_view_column_clicked (PsppSheetViewColumn *tree_column)
2352 {
2353   g_return_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column));
2354
2355   if (tree_column->visible &&
2356       tree_column->button &&
2357       tree_column->clickable)
2358     gtk_button_clicked (GTK_BUTTON (tree_column->button));
2359 }
2360
2361 /**
2362  * pspp_sheet_view_column_set_title:
2363  * @tree_column: A #PsppSheetViewColumn.
2364  * @title: The title of the @tree_column.
2365  *
2366  * Sets the title of the @tree_column.  If a custom widget has been set, then
2367  * this value is ignored.
2368  **/
2369 void
2370 pspp_sheet_view_column_set_title (PsppSheetViewColumn *tree_column,
2371                                 const gchar       *title)
2372 {
2373   gchar *new_title;
2374
2375   g_return_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column));
2376
2377   new_title = g_strdup (title);
2378   g_free (tree_column->title);
2379   tree_column->title = new_title;
2380
2381   pspp_sheet_view_column_update_button (tree_column);
2382   g_object_notify (G_OBJECT (tree_column), "title");
2383 }
2384
2385 /**
2386  * pspp_sheet_view_column_get_title:
2387  * @tree_column: A #PsppSheetViewColumn.
2388  *
2389  * Returns the title of the widget.
2390  *
2391  * Return value: the title of the column. This string should not be
2392  * modified or freed.
2393  **/
2394 const gchar *
2395 pspp_sheet_view_column_get_title (PsppSheetViewColumn *tree_column)
2396 {
2397   g_return_val_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column), NULL);
2398
2399   return tree_column->title;
2400 }
2401
2402 /**
2403  * pspp_sheet_view_column_set_expand:
2404  * @tree_column: A #PsppSheetViewColumn
2405  * @expand: %TRUE if the column should take available extra space, %FALSE if not
2406  *
2407  * Sets the column to take available extra space.  This space is shared equally
2408  * amongst all columns that have the expand set to %TRUE.  If no column has this
2409  * option set, then the last column gets all extra space.  By default, every
2410  * column is created with this %FALSE.
2411  *
2412  * Since: 2.4
2413  **/
2414 void
2415 pspp_sheet_view_column_set_expand (PsppSheetViewColumn *tree_column,
2416                                  gboolean           expand)
2417 {
2418   g_return_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column));
2419
2420   expand = !!expand;
2421   if (tree_column->expand == expand)
2422     return;
2423   tree_column->expand = expand;
2424
2425   if (tree_column->visible &&
2426       tree_column->tree_view != NULL &&
2427       gtk_widget_get_realized (tree_column->tree_view))
2428     {
2429       /* We want to continue using the original width of the
2430        * column that includes additional space added by the user
2431        * resizing the columns and possibly extra (expanded) space, which
2432        * are not included in the resized width.
2433        */
2434       tree_column->use_resized_width = FALSE;
2435
2436       gtk_widget_queue_resize (tree_column->tree_view);
2437     }
2438
2439   g_object_notify (G_OBJECT (tree_column), "expand");
2440 }
2441
2442 /**
2443  * pspp_sheet_view_column_get_expand:
2444  * @tree_column: a #PsppSheetViewColumn
2445  *
2446  * Return %TRUE if the column expands to take any available space.
2447  *
2448  * Return value: %TRUE, if the column expands
2449  *
2450  * Since: 2.4
2451  **/
2452 gboolean
2453 pspp_sheet_view_column_get_expand (PsppSheetViewColumn *tree_column)
2454 {
2455   g_return_val_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column), FALSE);
2456
2457   return tree_column->expand;
2458 }
2459
2460 /**
2461  * pspp_sheet_view_column_set_clickable:
2462  * @tree_column: A #PsppSheetViewColumn.
2463  * @clickable: %TRUE if the header is active.
2464  *
2465  * Sets the header to be active if @active is %TRUE.  When the header is active,
2466  * then it can take keyboard focus, and can be clicked.
2467  **/
2468 void
2469 pspp_sheet_view_column_set_clickable (PsppSheetViewColumn *tree_column,
2470                                     gboolean           clickable)
2471 {
2472   g_return_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column));
2473
2474   clickable = !! clickable;
2475   if (tree_column->clickable == clickable)
2476     return;
2477
2478   tree_column->clickable = clickable;
2479   pspp_sheet_view_column_update_button (tree_column);
2480   g_object_notify (G_OBJECT (tree_column), "clickable");
2481 }
2482
2483 /**
2484  * pspp_sheet_view_column_get_clickable:
2485  * @tree_column: a #PsppSheetViewColumn
2486  *
2487  * Returns %TRUE if the user can click on the header for the column.
2488  *
2489  * Return value: %TRUE if user can click the column header.
2490  **/
2491 gboolean
2492 pspp_sheet_view_column_get_clickable (PsppSheetViewColumn *tree_column)
2493 {
2494   g_return_val_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column), FALSE);
2495
2496   return tree_column->clickable;
2497 }
2498
2499 /**
2500  * pspp_sheet_view_column_set_widget:
2501  * @tree_column: A #PsppSheetViewColumn.
2502  * @widget: (allow-none): A child #GtkWidget, or %NULL.
2503  *
2504  * Sets the widget in the header to be @widget.  If widget is %NULL, then the
2505  * header button is set with a #GtkLabel set to the title of @tree_column.
2506  **/
2507 void
2508 pspp_sheet_view_column_set_widget (PsppSheetViewColumn *tree_column,
2509                                  GtkWidget         *widget)
2510 {
2511   g_return_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column));
2512   g_return_if_fail (widget == NULL || GTK_IS_WIDGET (widget));
2513
2514   if (widget)
2515     g_object_ref_sink (widget);
2516
2517   if (tree_column->child)
2518     g_object_unref (tree_column->child);
2519
2520   tree_column->child = widget;
2521   pspp_sheet_view_column_update_button (tree_column);
2522   g_object_notify (G_OBJECT (tree_column), "widget");
2523 }
2524
2525 /**
2526  * pspp_sheet_view_column_get_widget:
2527  * @tree_column: A #PsppSheetViewColumn.
2528  *
2529  * Returns the #GtkWidget in the button on the column header.  If a custom
2530  * widget has not been set then %NULL is returned.
2531  *
2532  * Return value: The #GtkWidget in the column header, or %NULL
2533  **/
2534 GtkWidget *
2535 pspp_sheet_view_column_get_widget (PsppSheetViewColumn *tree_column)
2536 {
2537   g_return_val_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column), NULL);
2538
2539   return tree_column->child;
2540 }
2541
2542 /**
2543  * pspp_sheet_view_column_set_alignment:
2544  * @tree_column: A #PsppSheetViewColumn.
2545  * @xalign: The alignment, which is between [0.0 and 1.0] inclusive.
2546  *
2547  * Sets the alignment of the title or custom widget inside the column header.
2548  * The alignment determines its location inside the button -- 0.0 for left, 0.5
2549  * for center, 1.0 for right.
2550  **/
2551 void
2552 pspp_sheet_view_column_set_alignment (PsppSheetViewColumn *tree_column,
2553                                     gfloat             xalign)
2554 {
2555   g_return_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column));
2556
2557   xalign = CLAMP (xalign, 0.0, 1.0);
2558
2559   if (tree_column->xalign == xalign)
2560     return;
2561
2562   tree_column->xalign = xalign;
2563   pspp_sheet_view_column_update_button (tree_column);
2564   g_object_notify (G_OBJECT (tree_column), "alignment");
2565 }
2566
2567 /**
2568  * pspp_sheet_view_column_get_alignment:
2569  * @tree_column: A #PsppSheetViewColumn.
2570  *
2571  * Returns the current x alignment of @tree_column.  This value can range
2572  * between 0.0 and 1.0.
2573  *
2574  * Return value: The current alignent of @tree_column.
2575  **/
2576 gfloat
2577 pspp_sheet_view_column_get_alignment (PsppSheetViewColumn *tree_column)
2578 {
2579   g_return_val_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column), 0.5);
2580
2581   return tree_column->xalign;
2582 }
2583
2584 /**
2585  * pspp_sheet_view_column_set_reorderable:
2586  * @tree_column: A #PsppSheetViewColumn
2587  * @reorderable: %TRUE, if the column can be reordered.
2588  *
2589  * If @reorderable is %TRUE, then the column can be reordered by the end user
2590  * dragging the header.
2591  **/
2592 void
2593 pspp_sheet_view_column_set_reorderable (PsppSheetViewColumn *tree_column,
2594                                       gboolean           reorderable)
2595 {
2596   g_return_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column));
2597
2598   /*  if (reorderable)
2599       pspp_sheet_view_column_set_clickable (tree_column, TRUE);*/
2600
2601   reorderable = !!reorderable;
2602   if (tree_column->reorderable == reorderable)
2603     return;
2604
2605   tree_column->reorderable = reorderable;
2606   pspp_sheet_view_column_update_button (tree_column);
2607   g_object_notify (G_OBJECT (tree_column), "reorderable");
2608 }
2609
2610 /**
2611  * pspp_sheet_view_column_get_reorderable:
2612  * @tree_column: A #PsppSheetViewColumn
2613  *
2614  * Returns %TRUE if the @tree_column can be reordered by the user.
2615  *
2616  * Return value: %TRUE if the @tree_column can be reordered by the user.
2617  **/
2618 gboolean
2619 pspp_sheet_view_column_get_reorderable (PsppSheetViewColumn *tree_column)
2620 {
2621   g_return_val_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column), FALSE);
2622
2623   return tree_column->reorderable;
2624 }
2625
2626 /**
2627  * pspp_sheet_view_column_set_quick_edit:
2628  * @tree_column: A #PsppSheetViewColumn
2629  * @quick_edit: If true, editing starts upon the first click in the column.  If
2630  * false, the first click selects the column and a second click is needed to
2631  * begin editing.  This has no effect on cells that are not editable.
2632  **/
2633 void
2634 pspp_sheet_view_column_set_quick_edit (PsppSheetViewColumn *tree_column,
2635                                       gboolean           quick_edit)
2636 {
2637   g_return_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column));
2638
2639   quick_edit = !!quick_edit;
2640   if (tree_column->quick_edit != quick_edit)
2641     {
2642       tree_column->quick_edit = quick_edit;
2643       g_object_notify (G_OBJECT (tree_column), "quick-edit");
2644     }
2645 }
2646
2647 /**
2648  * pspp_sheet_view_column_get_quick_edit:
2649  * @tree_column: A #PsppSheetViewColumn
2650  *
2651  * Returns %TRUE if editing starts upon the first click in the column.  Returns
2652  * %FALSE, the first click selects the column and a second click is needed to
2653  * begin editing.  This is not meaningful for cells that are not editable.
2654  *
2655  * Return value: %TRUE if editing starts upon the first click.
2656  **/
2657 gboolean
2658 pspp_sheet_view_column_get_quick_edit (PsppSheetViewColumn *tree_column)
2659 {
2660   g_return_val_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column), FALSE);
2661
2662   return tree_column->quick_edit;
2663 }
2664
2665
2666 /**
2667  * pspp_sheet_view_column_set_selected:
2668  * @tree_column: A #PsppSheetViewColumn
2669  * @selected: If true, the column is selected as part of a rectangular
2670  * selection.
2671  **/
2672 void
2673 pspp_sheet_view_column_set_selected (PsppSheetViewColumn *tree_column,
2674                                       gboolean           selected)
2675 {
2676   g_return_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column));
2677
2678   selected = !!selected;
2679   if (tree_column->selected != selected)
2680     {
2681       PsppSheetSelection *selection;
2682       PsppSheetView *sheet_view;
2683
2684       if (tree_column->tree_view != NULL)
2685         gtk_widget_queue_draw (GTK_WIDGET (tree_column->tree_view));
2686       tree_column->selected = selected;
2687       g_object_notify (G_OBJECT (tree_column), "selected");
2688
2689       sheet_view = PSPP_SHEET_VIEW (pspp_sheet_view_column_get_tree_view (
2690                                       tree_column));
2691       selection = pspp_sheet_view_get_selection (sheet_view);
2692       _pspp_sheet_selection_emit_changed (selection);
2693     }
2694 }
2695
2696 /**
2697  * pspp_sheet_view_column_get_selected:
2698  * @tree_column: A #PsppSheetViewColumn
2699  *
2700  * Returns %TRUE if the column is selected as part of a rectangular
2701  * selection.
2702  *
2703  * Return value: %TRUE if the column is selected as part of a rectangular
2704  * selection.
2705  **/
2706 gboolean
2707 pspp_sheet_view_column_get_selected (PsppSheetViewColumn *tree_column)
2708 {
2709   g_return_val_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column), FALSE);
2710
2711   return tree_column->selected;
2712 }
2713
2714 /**
2715  * pspp_sheet_view_column_set_selectable:
2716  * @tree_column: A #PsppSheetViewColumn
2717  * @selectable: If true, the column may be selected as part of a rectangular
2718  * selection.
2719  **/
2720 void
2721 pspp_sheet_view_column_set_selectable (PsppSheetViewColumn *tree_column,
2722                                       gboolean           selectable)
2723 {
2724   g_return_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column));
2725
2726   selectable = !!selectable;
2727   if (tree_column->selectable != selectable)
2728     {
2729       if (tree_column->tree_view != NULL)
2730         gtk_widget_queue_draw (GTK_WIDGET (tree_column->tree_view));
2731       tree_column->selectable = selectable;
2732       g_object_notify (G_OBJECT (tree_column), "selectable");
2733     }
2734 }
2735
2736 /**
2737  * pspp_sheet_view_column_get_selectable:
2738  * @tree_column: A #PsppSheetViewColumn
2739  *
2740  * Returns %TRUE if the column may be selected as part of a rectangular
2741  * selection.
2742  *
2743  * Return value: %TRUE if the column may be selected as part of a rectangular
2744  * selection.
2745  **/
2746 gboolean
2747 pspp_sheet_view_column_get_selectable (PsppSheetViewColumn *tree_column)
2748 {
2749   g_return_val_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column), FALSE);
2750
2751   return tree_column->selectable;
2752 }
2753
2754
2755 /**
2756  * pspp_sheet_view_column_set_row_head:
2757  * @tree_column: A #PsppSheetViewColumn
2758  * @row_head: If true, the column is a "row head", analogous to a column head.
2759  * See the description of the row-head property for more information.
2760  **/
2761 void
2762 pspp_sheet_view_column_set_row_head (PsppSheetViewColumn *tree_column,
2763                                       gboolean           row_head)
2764 {
2765   g_return_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column));
2766
2767   row_head = !!row_head;
2768   if (tree_column->row_head != row_head)
2769     {
2770       tree_column->row_head = row_head;
2771       g_object_notify (G_OBJECT (tree_column), "row_head");
2772     }
2773 }
2774
2775 /**
2776  * pspp_sheet_view_column_get_row_head:
2777  * @tree_column: A #PsppSheetViewColumn
2778  *
2779  * Returns %TRUE if the column is a row head.
2780  *
2781  * Return value: %TRUE if the column is a row head.
2782  **/
2783 gboolean
2784 pspp_sheet_view_column_get_row_head (PsppSheetViewColumn *tree_column)
2785 {
2786   g_return_val_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column), FALSE);
2787
2788   return tree_column->row_head;
2789 }
2790
2791
2792 /**
2793  * pspp_sheet_view_column_set_tabbable:
2794  * @tree_column: A #PsppSheetViewColumn
2795  * @tabbable: If true, the column is "tabbable", meaning that Tab and Shift+Tab
2796  * in the sheet visit this column.  If false, Tab and Shift+Tab skip this
2797  * column.
2798  **/
2799 void
2800 pspp_sheet_view_column_set_tabbable (PsppSheetViewColumn *tree_column,
2801                                      gboolean           tabbable)
2802 {
2803   g_return_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column));
2804
2805   tabbable = !!tabbable;
2806   if (tree_column->tabbable != tabbable)
2807     {
2808       tree_column->tabbable = tabbable;
2809       g_object_notify (G_OBJECT (tree_column), "tabbable");
2810     }
2811 }
2812
2813 /**
2814  * pspp_sheet_view_column_get_tabbable:
2815  * @tree_column: A #PsppSheetViewColumn
2816  *
2817  * Returns %TRUE if the column is tabbable.
2818  *
2819  * Return value: %TRUE if the column is tabbable.
2820  **/
2821 gboolean
2822 pspp_sheet_view_column_get_tabbable (PsppSheetViewColumn *tree_column)
2823 {
2824   g_return_val_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column), FALSE);
2825
2826   return tree_column->tabbable;
2827 }
2828
2829
2830 /**
2831  * pspp_sheet_view_column_set_sort_column_id:
2832  * @tree_column: a #PsppSheetViewColumn
2833  * @sort_column_id: The @sort_column_id of the model to sort on.
2834  *
2835  * Sets the logical @sort_column_id that this column sorts on when this column
2836  * is selected for sorting.  Doing so makes the column header clickable.
2837  **/
2838 void
2839 pspp_sheet_view_column_set_sort_column_id (PsppSheetViewColumn *tree_column,
2840                                          gint               sort_column_id)
2841 {
2842   g_return_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column));
2843   g_return_if_fail (sort_column_id >= -1);
2844
2845   if (tree_column->sort_column_id == sort_column_id)
2846     return;
2847
2848   tree_column->sort_column_id = sort_column_id;
2849
2850   /* Handle unsetting the id */
2851   if (sort_column_id == -1)
2852     {
2853       GtkTreeModel *model = pspp_sheet_view_get_model (PSPP_SHEET_VIEW (tree_column->tree_view));
2854
2855       if (tree_column->sort_clicked_signal)
2856         {
2857           g_signal_handler_disconnect (tree_column, tree_column->sort_clicked_signal);
2858           tree_column->sort_clicked_signal = 0;
2859         }
2860
2861       if (tree_column->sort_column_changed_signal)
2862         {
2863           g_signal_handler_disconnect (model, tree_column->sort_column_changed_signal);
2864           tree_column->sort_column_changed_signal = 0;
2865         }
2866
2867       pspp_sheet_view_column_set_sort_order (tree_column, GTK_SORT_ASCENDING);
2868       pspp_sheet_view_column_set_sort_indicator (tree_column, FALSE);
2869       pspp_sheet_view_column_set_clickable (tree_column, FALSE);
2870       g_object_notify (G_OBJECT (tree_column), "sort-column-id");
2871       return;
2872     }
2873
2874   pspp_sheet_view_column_set_clickable (tree_column, TRUE);
2875
2876   if (! tree_column->sort_clicked_signal)
2877     tree_column->sort_clicked_signal = g_signal_connect (tree_column,
2878                                                          "clicked",
2879                                                          G_CALLBACK (pspp_sheet_view_column_sort),
2880                                                          NULL);
2881
2882   pspp_sheet_view_column_setup_sort_column_id_callback (tree_column);
2883   g_object_notify (G_OBJECT (tree_column), "sort-column-id");
2884 }
2885
2886 /**
2887  * pspp_sheet_view_column_get_sort_column_id:
2888  * @tree_column: a #PsppSheetViewColumn
2889  *
2890  * Gets the logical @sort_column_id that the model sorts on when this
2891  * column is selected for sorting.
2892  * See pspp_sheet_view_column_set_sort_column_id().
2893  *
2894  * Return value: the current @sort_column_id for this column, or -1 if
2895  *               this column can't be used for sorting.
2896  **/
2897 gint
2898 pspp_sheet_view_column_get_sort_column_id (PsppSheetViewColumn *tree_column)
2899 {
2900   g_return_val_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column), 0);
2901
2902   return tree_column->sort_column_id;
2903 }
2904
2905 /**
2906  * pspp_sheet_view_column_set_sort_indicator:
2907  * @tree_column: a #PsppSheetViewColumn
2908  * @setting: %TRUE to display an indicator that the column is sorted
2909  *
2910  * Call this function with a @setting of %TRUE to display an arrow in
2911  * the header button indicating the column is sorted. Call
2912  * pspp_sheet_view_column_set_sort_order() to change the direction of
2913  * the arrow.
2914  *
2915  **/
2916 void
2917 pspp_sheet_view_column_set_sort_indicator (PsppSheetViewColumn     *tree_column,
2918                                          gboolean               setting)
2919 {
2920   g_return_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column));
2921
2922   setting = setting != FALSE;
2923
2924   if (setting == tree_column->show_sort_indicator)
2925     return;
2926
2927   tree_column->show_sort_indicator = setting;
2928   pspp_sheet_view_column_update_button (tree_column);
2929   g_object_notify (G_OBJECT (tree_column), "sort-indicator");
2930 }
2931
2932 /**
2933  * pspp_sheet_view_column_get_sort_indicator:
2934  * @tree_column: a #PsppSheetViewColumn
2935  *
2936  * Gets the value set by pspp_sheet_view_column_set_sort_indicator().
2937  *
2938  * Return value: whether the sort indicator arrow is displayed
2939  **/
2940 gboolean
2941 pspp_sheet_view_column_get_sort_indicator  (PsppSheetViewColumn     *tree_column)
2942 {
2943   g_return_val_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column), FALSE);
2944
2945   return tree_column->show_sort_indicator;
2946 }
2947
2948 /**
2949  * pspp_sheet_view_column_set_sort_order:
2950  * @tree_column: a #PsppSheetViewColumn
2951  * @order: sort order that the sort indicator should indicate
2952  *
2953  * Changes the appearance of the sort indicator.
2954  *
2955  * This <emphasis>does not</emphasis> actually sort the model.  Use
2956  * pspp_sheet_view_column_set_sort_column_id() if you want automatic sorting
2957  * support.  This function is primarily for custom sorting behavior, and should
2958  * be used in conjunction with gtk_tree_sortable_set_sort_column() to do
2959  * that. For custom models, the mechanism will vary.
2960  *
2961  * The sort indicator changes direction to indicate normal sort or reverse sort.
2962  * Note that you must have the sort indicator enabled to see anything when
2963  * calling this function; see pspp_sheet_view_column_set_sort_indicator().
2964  **/
2965 void
2966 pspp_sheet_view_column_set_sort_order      (PsppSheetViewColumn     *tree_column,
2967                                           GtkSortType            order)
2968 {
2969   g_return_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column));
2970
2971   if (order == tree_column->sort_order)
2972     return;
2973
2974   tree_column->sort_order = order;
2975   pspp_sheet_view_column_update_button (tree_column);
2976   g_object_notify (G_OBJECT (tree_column), "sort-order");
2977 }
2978
2979 /**
2980  * pspp_sheet_view_column_get_sort_order:
2981  * @tree_column: a #PsppSheetViewColumn
2982  *
2983  * Gets the value set by pspp_sheet_view_column_set_sort_order().
2984  *
2985  * Return value: the sort order the sort indicator is indicating
2986  **/
2987 GtkSortType
2988 pspp_sheet_view_column_get_sort_order      (PsppSheetViewColumn     *tree_column)
2989 {
2990   g_return_val_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column), 0);
2991
2992   return tree_column->sort_order;
2993 }
2994
2995 /**
2996  * pspp_sheet_view_column_cell_set_cell_data:
2997  * @tree_column: A #PsppSheetViewColumn.
2998  * @tree_model: The #GtkTreeModel to to get the cell renderers attributes from.
2999  * @iter: The #GtkTreeIter to to get the cell renderer's attributes from.
3000  *
3001  * Sets the cell renderer based on the @tree_model and @iter.  That is, for
3002  * every attribute mapping in @tree_column, it will get a value from the set
3003  * column on the @iter, and use that value to set the attribute on the cell
3004  * renderer.  This is used primarily by the #PsppSheetView.
3005  **/
3006 void
3007 pspp_sheet_view_column_cell_set_cell_data (PsppSheetViewColumn *tree_column,
3008                                          GtkTreeModel      *tree_model,
3009                                          GtkTreeIter       *iter)
3010 {
3011   GSList *list;
3012   GValue value = { 0, };
3013   GList *cell_list;
3014
3015   g_return_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column));
3016
3017   if (tree_model == NULL)
3018     return;
3019
3020   for (cell_list = tree_column->cell_list; cell_list; cell_list = cell_list->next)
3021     {
3022       PsppSheetViewColumnCellInfo *info = (PsppSheetViewColumnCellInfo *) cell_list->data;
3023       GObject *cell = (GObject *) info->cell;
3024
3025       list = info->attributes;
3026
3027       g_object_freeze_notify (cell);
3028
3029       while (list && list->next)
3030         {
3031           gtk_tree_model_get_value (tree_model, iter,
3032                                     GPOINTER_TO_INT (list->next->data),
3033                                     &value);
3034           g_object_set_property (cell, (gchar *) list->data, &value);
3035           g_value_unset (&value);
3036           list = list->next->next;
3037         }
3038
3039       if (info->func)
3040         (* info->func) (tree_column, info->cell, tree_model, iter, info->func_data);
3041       g_object_thaw_notify (G_OBJECT (info->cell));
3042     }
3043
3044 }
3045
3046 /**
3047  * pspp_sheet_view_column_cell_get_size:
3048  * @tree_column: A #PsppSheetViewColumn.
3049  * @cell_area: (allow-none): The area a cell in the column will be allocated, or %NULL
3050  * @x_offset: (allow-none): location to return x offset of a cell relative to @cell_area, or %NULL
3051  * @y_offset: (allow-none): location to return y offset of a cell relative to @cell_area, or %NULL
3052  * @width: (allow-none): location to return width needed to render a cell, or %NULL
3053  * @height: (allow-none): location to return height needed to render a cell, or %NULL
3054  *
3055  * Obtains the width and height needed to render the column.  This is used
3056  * primarily by the #PsppSheetView.
3057  **/
3058 void
3059 pspp_sheet_view_column_cell_get_size (PsppSheetViewColumn  *tree_column,
3060                                     const GdkRectangle *cell_area,
3061                                     gint               *x_offset,
3062                                     gint               *y_offset,
3063                                     gint               *width,
3064                                     gint               *height)
3065 {
3066   GList *list;
3067   gboolean first_cell = TRUE;
3068   gint focus_line_width;
3069
3070   g_return_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column));
3071
3072   if (height)
3073     * height = 0;
3074   if (width)
3075     * width = 0;
3076
3077   gtk_widget_style_get (tree_column->tree_view, "focus-line-width", &focus_line_width, NULL);
3078
3079   for (list = tree_column->cell_list; list; list = list->next)
3080     {
3081       PsppSheetViewColumnCellInfo *info = (PsppSheetViewColumnCellInfo *) list->data;
3082       gboolean visible;
3083       gint new_height = 0;
3084       gint new_width = 0;
3085       g_object_get (info->cell, "visible", &visible, NULL);
3086
3087       if (visible == FALSE)
3088         continue;
3089
3090       if (first_cell == FALSE && width)
3091         *width += tree_column->spacing;
3092
3093       gtk_cell_renderer_get_size (info->cell,
3094                                   tree_column->tree_view,
3095                                   cell_area,
3096                                   x_offset,
3097                                   y_offset,
3098                                   &new_width,
3099                                   &new_height);
3100
3101       if (height)
3102         * height = MAX (*height, new_height + focus_line_width * 2);
3103       info->requested_width = MAX (info->requested_width, new_width + focus_line_width * 2);
3104       if (width)
3105         * width += info->requested_width;
3106       first_cell = FALSE;
3107     }
3108 }
3109
3110 /* rendering, event handling and rendering focus are somewhat complicated, and
3111  * quite a bit of code.  Rather than duplicate them, we put them together to
3112  * keep the code in one place.
3113  *
3114  * To better understand what's going on, check out
3115  * docs/tree-column-sizing.png
3116  */
3117 enum {
3118   CELL_ACTION_RENDER,
3119   CELL_ACTION_FOCUS,
3120   CELL_ACTION_EVENT
3121 };
3122
3123 static gboolean
3124 pspp_sheet_view_column_cell_process_action (PsppSheetViewColumn  *tree_column,
3125                                           GdkWindow          *window,
3126                                           const GdkRectangle *background_area,
3127                                           const GdkRectangle *cell_area,
3128                                           guint               flags,
3129                                           gint                action,
3130                                           const GdkRectangle *expose_area,     /* RENDER */
3131                                           GdkRectangle       *focus_rectangle, /* FOCUS  */
3132                                           GtkCellEditable   **editable_widget, /* EVENT  */
3133                                           GdkEvent           *event,           /* EVENT  */
3134                                           gchar              *path_string)     /* EVENT  */
3135 {
3136   GList *list;
3137   GdkRectangle real_cell_area;
3138   GdkRectangle real_background_area;
3139   GdkRectangle real_expose_area = *cell_area;
3140   gint depth = 0;
3141   gint expand_cell_count = 0;
3142   gint full_requested_width = 0;
3143   gint extra_space;
3144   gint min_x, min_y, max_x, max_y;
3145   gint focus_line_width;
3146   gint special_cells;
3147   gint horizontal_separator;
3148   gboolean cursor_row = FALSE;
3149   gboolean first_cell = TRUE;
3150   gboolean rtl;
3151   /* If we have rtl text, we need to transform our areas */
3152   GdkRectangle rtl_cell_area;
3153   GdkRectangle rtl_background_area;
3154
3155   min_x = G_MAXINT;
3156   min_y = G_MAXINT;
3157   max_x = 0;
3158   max_y = 0;
3159
3160   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_column->tree_view)) == GTK_TEXT_DIR_RTL);
3161   special_cells = _pspp_sheet_view_column_count_special_cells (tree_column);
3162
3163   if (special_cells > 1 && action == CELL_ACTION_FOCUS)
3164     {
3165       PsppSheetViewColumnCellInfo *info = NULL;
3166       gboolean found_has_focus = FALSE;
3167
3168       /* one should have focus */
3169       for (list = tree_column->cell_list; list; list = list->next)
3170         {
3171           info = list->data;
3172           if (info && info->has_focus)
3173             {
3174               found_has_focus = TRUE;
3175               break;
3176             }
3177         }
3178
3179       if (!found_has_focus)
3180         {
3181           /* give the first one focus */
3182           info = pspp_sheet_view_column_cell_first (tree_column)->data;
3183           info->has_focus = TRUE;
3184         }
3185     }
3186
3187   cursor_row = flags & GTK_CELL_RENDERER_FOCUSED;
3188
3189   gtk_widget_style_get (GTK_WIDGET (tree_column->tree_view),
3190                         "focus-line-width", &focus_line_width,
3191                         "horizontal-separator", &horizontal_separator,
3192                         NULL);
3193
3194   real_cell_area = *cell_area;
3195   real_background_area = *background_area;
3196
3197
3198   real_cell_area.x += focus_line_width;
3199   real_cell_area.y += focus_line_width;
3200   real_cell_area.height -= 2 * focus_line_width;
3201
3202   if (rtl)
3203     depth = real_background_area.width - real_cell_area.width;
3204   else
3205     depth = real_cell_area.x - real_background_area.x;
3206
3207   /* Find out how much extra space we have to allocate */
3208   for (list = tree_column->cell_list; list; list = list->next)
3209     {
3210       PsppSheetViewColumnCellInfo *info = (PsppSheetViewColumnCellInfo *)list->data;
3211
3212       if (! gtk_cell_renderer_get_visible (info->cell))
3213         continue;
3214
3215       if (info->expand == TRUE)
3216         expand_cell_count ++;
3217       full_requested_width += info->requested_width;
3218
3219       if (!first_cell)
3220         full_requested_width += tree_column->spacing;
3221
3222       first_cell = FALSE;
3223     }
3224
3225   extra_space = cell_area->width - full_requested_width;
3226   if (extra_space < 0)
3227     extra_space = 0;
3228   else if (extra_space > 0 && expand_cell_count > 0)
3229     extra_space /= expand_cell_count;
3230
3231   /* iterate list for GTK_PACK_START cells */
3232   for (list = tree_column->cell_list; list; list = list->next)
3233     {
3234       PsppSheetViewColumnCellInfo *info = (PsppSheetViewColumnCellInfo *) list->data;
3235
3236       if (info->pack == GTK_PACK_END)
3237         continue;
3238
3239       if (! gtk_cell_renderer_get_visible (info->cell))
3240         continue;
3241
3242       if ((info->has_focus || special_cells == 1) && cursor_row)
3243         flags |= GTK_CELL_RENDERER_FOCUSED;
3244       else
3245         flags &= ~GTK_CELL_RENDERER_FOCUSED;
3246
3247       info->real_width = info->requested_width + (info->expand?extra_space:0);
3248
3249       /* We constrain ourselves to only the width available */
3250       if (real_cell_area.x - focus_line_width + info->real_width > cell_area->x + cell_area->width)
3251         {
3252           info->real_width = cell_area->x + cell_area->width - real_cell_area.x;
3253         }
3254
3255       if (real_cell_area.x > cell_area->x + cell_area->width)
3256         break;
3257
3258       real_cell_area.width = info->real_width;
3259       real_cell_area.width -= 2 * focus_line_width;
3260
3261       if (list->next)
3262         {
3263           real_background_area.width = info->real_width + depth;
3264         }
3265       else
3266         {
3267           /* fill the rest of background for the last cell */
3268           real_background_area.width = background_area->x + background_area->width - real_background_area.x;
3269         }
3270
3271       rtl_cell_area = real_cell_area;
3272       rtl_background_area = real_background_area;
3273
3274       if (rtl)
3275         {
3276           rtl_cell_area.x = cell_area->x + cell_area->width - (real_cell_area.x - cell_area->x) - real_cell_area.width;
3277           rtl_background_area.x = background_area->x + background_area->width - (real_background_area.x - background_area->x) - real_background_area.width;
3278         }
3279
3280       /* RENDER */
3281       if (action == CELL_ACTION_RENDER)
3282         {
3283           gtk_cell_renderer_render (info->cell,
3284                                     window,
3285                                     tree_column->tree_view,
3286                                     &rtl_background_area,
3287                                     &rtl_cell_area,
3288                                     &real_expose_area,
3289                                     flags);
3290         }
3291       /* FOCUS */
3292       else if (action == CELL_ACTION_FOCUS)
3293         {
3294           gint x_offset, y_offset, width, height;
3295
3296           gtk_cell_renderer_get_size (info->cell,
3297                                       tree_column->tree_view,
3298                                       &rtl_cell_area,
3299                                       &x_offset, &y_offset,
3300                                       &width, &height);
3301
3302           if (special_cells > 1)
3303             {
3304               if (info->has_focus)
3305                 {
3306                   min_x = rtl_cell_area.x + x_offset;
3307                   max_x = min_x + width;
3308                   min_y = rtl_cell_area.y + y_offset;
3309                   max_y = min_y + height;
3310                 }
3311             }
3312           else
3313             {
3314               if (min_x > (rtl_cell_area.x + x_offset))
3315                 min_x = rtl_cell_area.x + x_offset;
3316               if (max_x < rtl_cell_area.x + x_offset + width)
3317                 max_x = rtl_cell_area.x + x_offset + width;
3318               if (min_y > (rtl_cell_area.y + y_offset))
3319                 min_y = rtl_cell_area.y + y_offset;
3320               if (max_y < rtl_cell_area.y + y_offset + height)
3321                 max_y = rtl_cell_area.y + y_offset + height;
3322             }
3323         }
3324       /* EVENT */
3325       else if (action == CELL_ACTION_EVENT)
3326         {
3327           gboolean try_event = FALSE;
3328
3329           if (event)
3330             {
3331               if (special_cells == 1)
3332                 {
3333                   /* only 1 activatable cell -> whole column can activate */
3334                   if (cell_area->x <= ((GdkEventButton *)event)->x &&
3335                       cell_area->x + cell_area->width > ((GdkEventButton *)event)->x)
3336                     try_event = TRUE;
3337                 }
3338               else if (rtl_cell_area.x <= ((GdkEventButton *)event)->x &&
3339                   rtl_cell_area.x + rtl_cell_area.width > ((GdkEventButton *)event)->x)
3340                   /* only activate cell if the user clicked on an individual
3341                    * cell
3342                    */
3343                 try_event = TRUE;
3344             }
3345           else if (special_cells > 1 && info->has_focus)
3346             try_event = TRUE;
3347           else if (special_cells == 1)
3348             try_event = TRUE;
3349
3350           if (try_event)
3351             {
3352               gboolean visible, mode;
3353
3354               g_object_get (info->cell,
3355                             "visible", &visible,
3356                             "mode", &mode,
3357                             NULL);
3358               if (visible && mode == GTK_CELL_RENDERER_MODE_ACTIVATABLE)
3359                 {
3360                   if (gtk_cell_renderer_activate (info->cell,
3361                                                   event,
3362                                                   tree_column->tree_view,
3363                                                   path_string,
3364                                                   &rtl_background_area,
3365                                                   &rtl_cell_area,
3366                                                   flags))
3367                     {
3368                       flags &= ~GTK_CELL_RENDERER_FOCUSED;
3369                       return TRUE;
3370                     }
3371                 }
3372               else if (visible && mode == GTK_CELL_RENDERER_MODE_EDITABLE)
3373                 {
3374                   *editable_widget =
3375                     gtk_cell_renderer_start_editing (info->cell,
3376                                                      event,
3377                                                      tree_column->tree_view,
3378                                                      path_string,
3379                                                      &rtl_background_area,
3380                                                      &rtl_cell_area,
3381                                                      flags);
3382
3383                   if (*editable_widget != NULL)
3384                     {
3385                       g_return_val_if_fail (GTK_IS_CELL_EDITABLE (*editable_widget), FALSE);
3386                       info->in_editing_mode = TRUE;
3387                       pspp_sheet_view_column_focus_cell (tree_column, info->cell);
3388
3389                       flags &= ~GTK_CELL_RENDERER_FOCUSED;
3390
3391                       return TRUE;
3392                     }
3393                 }
3394             }
3395         }
3396
3397       flags &= ~GTK_CELL_RENDERER_FOCUSED;
3398
3399       real_cell_area.x += (real_cell_area.width + 2 * focus_line_width + tree_column->spacing);
3400       real_background_area.x += real_background_area.width + tree_column->spacing;
3401
3402       /* Only needed for first cell */
3403       depth = 0;
3404     }
3405
3406   /* iterate list for PACK_END cells */
3407   for (list = g_list_last (tree_column->cell_list); list; list = list->prev)
3408     {
3409       PsppSheetViewColumnCellInfo *info = (PsppSheetViewColumnCellInfo *) list->data;
3410
3411       if (info->pack == GTK_PACK_START)
3412         continue;
3413
3414       if (! gtk_cell_renderer_get_visible (info->cell))
3415         continue;
3416
3417       if ((info->has_focus || special_cells == 1) && cursor_row)
3418         flags |= GTK_CELL_RENDERER_FOCUSED;
3419       else
3420         flags &= ~GTK_CELL_RENDERER_FOCUSED;
3421
3422       info->real_width = info->requested_width + (info->expand?extra_space:0);
3423
3424       /* We constrain ourselves to only the width available */
3425       if (real_cell_area.x - focus_line_width + info->real_width > cell_area->x + cell_area->width)
3426         {
3427           info->real_width = cell_area->x + cell_area->width - real_cell_area.x;
3428         }
3429
3430       if (real_cell_area.x > cell_area->x + cell_area->width)
3431         break;
3432
3433       real_cell_area.width = info->real_width;
3434       real_cell_area.width -= 2 * focus_line_width;
3435       real_background_area.width = info->real_width + depth;
3436
3437       rtl_cell_area = real_cell_area;
3438       rtl_background_area = real_background_area;
3439       if (rtl)
3440         {
3441           rtl_cell_area.x = cell_area->x + cell_area->width - (real_cell_area.x - cell_area->x) - real_cell_area.width;
3442           rtl_background_area.x = background_area->x + background_area->width - (real_background_area.x - background_area->x) - real_background_area.width;
3443         }
3444
3445       /* RENDER */
3446       if (action == CELL_ACTION_RENDER)
3447         {
3448           gtk_cell_renderer_render (info->cell,
3449                                     window,
3450                                     tree_column->tree_view,
3451                                     &rtl_background_area,
3452                                     &rtl_cell_area,
3453                                     &real_expose_area,
3454                                     flags);
3455         }
3456       /* FOCUS */
3457       else if (action == CELL_ACTION_FOCUS)
3458         {
3459           gint x_offset, y_offset, width, height;
3460
3461           gtk_cell_renderer_get_size (info->cell,
3462                                       tree_column->tree_view,
3463                                       &rtl_cell_area,
3464                                       &x_offset, &y_offset,
3465                                       &width, &height);
3466
3467           if (special_cells > 1)
3468             {
3469               if (info->has_focus)
3470                 {
3471                   min_x = rtl_cell_area.x + x_offset;
3472                   max_x = min_x + width;
3473                   min_y = rtl_cell_area.y + y_offset;
3474                   max_y = min_y + height;
3475                 }
3476             }
3477           else
3478             {
3479               if (min_x > (rtl_cell_area.x + x_offset))
3480                 min_x = rtl_cell_area.x + x_offset;
3481               if (max_x < rtl_cell_area.x + x_offset + width)
3482                 max_x = rtl_cell_area.x + x_offset + width;
3483               if (min_y > (rtl_cell_area.y + y_offset))
3484                 min_y = rtl_cell_area.y + y_offset;
3485               if (max_y < rtl_cell_area.y + y_offset + height)
3486                 max_y = rtl_cell_area.y + y_offset + height;
3487             }
3488         }
3489       /* EVENT */
3490       else if (action == CELL_ACTION_EVENT)
3491         {
3492           gboolean try_event = FALSE;
3493
3494           if (event)
3495             {
3496               if (special_cells == 1)
3497                 {
3498                   /* only 1 activatable cell -> whole column can activate */
3499                   if (cell_area->x <= ((GdkEventButton *)event)->x &&
3500                       cell_area->x + cell_area->width > ((GdkEventButton *)event)->x)
3501                     try_event = TRUE;
3502                 }
3503               else if (rtl_cell_area.x <= ((GdkEventButton *)event)->x &&
3504                   rtl_cell_area.x + rtl_cell_area.width > ((GdkEventButton *)event)->x)
3505                 /* only activate cell if the user clicked on an individual
3506                  * cell
3507                  */
3508                 try_event = TRUE;
3509             }
3510           else if (special_cells > 1 && info->has_focus)
3511             try_event = TRUE;
3512           else if (special_cells == 1)
3513             try_event = TRUE;
3514
3515           if (try_event)
3516             {
3517               gboolean visible, mode;
3518
3519               g_object_get (info->cell,
3520                             "visible", &visible,
3521                             "mode", &mode,
3522                             NULL);
3523               if (visible && mode == GTK_CELL_RENDERER_MODE_ACTIVATABLE)
3524                 {
3525                   if (gtk_cell_renderer_activate (info->cell,
3526                                                   event,
3527                                                   tree_column->tree_view,
3528                                                   path_string,
3529                                                   &rtl_background_area,
3530                                                   &rtl_cell_area,
3531                                                   flags))
3532                     {
3533                       flags &= ~GTK_CELL_RENDERER_FOCUSED;
3534                       return TRUE;
3535                     }
3536                 }
3537               else if (visible && mode == GTK_CELL_RENDERER_MODE_EDITABLE)
3538                 {
3539                   *editable_widget =
3540                     gtk_cell_renderer_start_editing (info->cell,
3541                                                      event,
3542                                                      tree_column->tree_view,
3543                                                      path_string,
3544                                                      &rtl_background_area,
3545                                                      &rtl_cell_area,
3546                                                      flags);
3547
3548                   if (*editable_widget != NULL)
3549                     {
3550                       g_return_val_if_fail (GTK_IS_CELL_EDITABLE (*editable_widget), FALSE);
3551                       info->in_editing_mode = TRUE;
3552                       pspp_sheet_view_column_focus_cell (tree_column, info->cell);
3553
3554                       flags &= ~GTK_CELL_RENDERER_FOCUSED;
3555                       return TRUE;
3556                     }
3557                 }
3558             }
3559         }
3560
3561       flags &= ~GTK_CELL_RENDERER_FOCUSED;
3562
3563       real_cell_area.x += (real_cell_area.width + 2 * focus_line_width + tree_column->spacing);
3564       real_background_area.x += (real_background_area.width + tree_column->spacing);
3565
3566       /* Only needed for first cell */
3567       depth = 0;
3568     }
3569
3570   /* fill focus_rectangle when required */
3571   if (action == CELL_ACTION_FOCUS)
3572     {
3573       if (min_x >= max_x || min_y >= max_y)
3574         {
3575           *focus_rectangle = *cell_area;
3576           /* don't change the focus_rectangle, just draw it nicely inside
3577            * the cell area */
3578         }
3579       else
3580         {
3581           focus_rectangle->x = min_x - focus_line_width;
3582           focus_rectangle->y = min_y - focus_line_width;
3583           focus_rectangle->width = (max_x - min_x) + 2 * focus_line_width;
3584           focus_rectangle->height = (max_y - min_y) + 2 * focus_line_width;
3585         }
3586     }
3587
3588   return FALSE;
3589 }
3590
3591 /**
3592  * pspp_sheet_view_column_cell_render:
3593  * @tree_column: A #PsppSheetViewColumn.
3594  * @window: a #GdkDrawable to draw to
3595  * @background_area: entire cell area (including tree expanders and maybe padding on the sides)
3596  * @cell_area: area normally rendered by a cell renderer
3597  * @expose_area: area that actually needs updating
3598  * @flags: flags that affect rendering
3599  *
3600  * Renders the cell contained by #tree_column. This is used primarily by the
3601  * #PsppSheetView.
3602  **/
3603 void
3604 _pspp_sheet_view_column_cell_render (PsppSheetViewColumn  *tree_column,
3605                                    GdkWindow          *window,
3606                                    const GdkRectangle *background_area,
3607                                    const GdkRectangle *cell_area,
3608                                    const GdkRectangle *expose_area,
3609                                    guint               flags)
3610 {
3611   g_return_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column));
3612   g_return_if_fail (background_area != NULL);
3613   g_return_if_fail (cell_area != NULL);
3614   g_return_if_fail (expose_area != NULL);
3615
3616   pspp_sheet_view_column_cell_process_action (tree_column,
3617                                             window,
3618                                             background_area,
3619                                             cell_area,
3620                                             flags,
3621                                             CELL_ACTION_RENDER,
3622                                             expose_area,
3623                                             NULL, NULL, NULL, NULL);
3624 }
3625
3626 gboolean
3627 _pspp_sheet_view_column_cell_event (PsppSheetViewColumn  *tree_column,
3628                                   GtkCellEditable   **editable_widget,
3629                                   GdkEvent           *event,
3630                                   gchar              *path_string,
3631                                   const GdkRectangle *background_area,
3632                                   const GdkRectangle *cell_area,
3633                                   guint               flags)
3634 {
3635   g_return_val_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column), FALSE);
3636
3637   return pspp_sheet_view_column_cell_process_action (tree_column,
3638                                                    NULL,
3639                                                    background_area,
3640                                                    cell_area,
3641                                                    flags,
3642                                                    CELL_ACTION_EVENT,
3643                                                    NULL, NULL,
3644                                                    editable_widget,
3645                                                    event,
3646                                                    path_string);
3647 }
3648
3649 void
3650 _pspp_sheet_view_column_get_focus_area (PsppSheetViewColumn  *tree_column,
3651                                       const GdkRectangle *background_area,
3652                                       const GdkRectangle *cell_area,
3653                                       GdkRectangle       *focus_area)
3654 {
3655   pspp_sheet_view_column_cell_process_action (tree_column,
3656                                             NULL,
3657                                             background_area,
3658                                             cell_area,
3659                                             0,
3660                                             CELL_ACTION_FOCUS,
3661                                             NULL,
3662                                             focus_area,
3663                                             NULL, NULL, NULL);
3664 }
3665
3666
3667 /* cell list manipulation */
3668 static GList *
3669 pspp_sheet_view_column_cell_first (PsppSheetViewColumn *tree_column)
3670 {
3671   GList *list = tree_column->cell_list;
3672
3673   /* first GTK_PACK_START cell we find */
3674   for ( ; list; list = list->next)
3675     {
3676       PsppSheetViewColumnCellInfo *info = list->data;
3677       if (info->pack == GTK_PACK_START)
3678         return list;
3679     }
3680
3681   /* hmm, else the *last* GTK_PACK_END cell */
3682   list = g_list_last (tree_column->cell_list);
3683
3684   for ( ; list; list = list->prev)
3685     {
3686       PsppSheetViewColumnCellInfo *info = list->data;
3687       if (info->pack == GTK_PACK_END)
3688         return list;
3689     }
3690
3691   return NULL;
3692 }
3693
3694 static GList *
3695 pspp_sheet_view_column_cell_last (PsppSheetViewColumn *tree_column)
3696 {
3697   GList *list = tree_column->cell_list;
3698
3699   /* *first* GTK_PACK_END cell we find */
3700   for ( ; list ; list = list->next)
3701     {
3702       PsppSheetViewColumnCellInfo *info = list->data;
3703       if (info->pack == GTK_PACK_END)
3704         return list;
3705     }
3706
3707   /* hmm, else the last GTK_PACK_START cell */
3708   list = g_list_last (tree_column->cell_list);
3709
3710   for ( ; list; list = list->prev)
3711     {
3712       PsppSheetViewColumnCellInfo *info = list->data;
3713       if (info->pack == GTK_PACK_START)
3714         return list;
3715     }
3716
3717   return NULL;
3718 }
3719
3720 static GList *
3721 pspp_sheet_view_column_cell_next (PsppSheetViewColumn *tree_column,
3722                                 GList             *current)
3723 {
3724   GList *list;
3725   PsppSheetViewColumnCellInfo *info = current->data;
3726
3727   if (info->pack == GTK_PACK_START)
3728     {
3729       for (list = current->next; list; list = list->next)
3730         {
3731           PsppSheetViewColumnCellInfo *inf = list->data;
3732           if (inf->pack == GTK_PACK_START)
3733             return list;
3734         }
3735
3736       /* out of GTK_PACK_START cells, get *last* GTK_PACK_END one */
3737       list = g_list_last (tree_column->cell_list);
3738       for (; list; list = list->prev)
3739         {
3740           PsppSheetViewColumnCellInfo *inf = list->data;
3741           if (inf->pack == GTK_PACK_END)
3742             return list;
3743         }
3744     }
3745
3746   for (list = current->prev; list; list = list->prev)
3747     {
3748       PsppSheetViewColumnCellInfo *inf = list->data;
3749       if (inf->pack == GTK_PACK_END)
3750         return list;
3751     }
3752
3753   return NULL;
3754 }
3755
3756 static GList *
3757 pspp_sheet_view_column_cell_prev (PsppSheetViewColumn *tree_column,
3758                                 GList             *current)
3759 {
3760   GList *list;
3761   PsppSheetViewColumnCellInfo *info = current->data;
3762
3763   if (info->pack == GTK_PACK_END)
3764     {
3765       for (list = current->next; list; list = list->next)
3766         {
3767           PsppSheetViewColumnCellInfo *inf = list->data;
3768           if (inf->pack == GTK_PACK_END)
3769             return list;
3770         }
3771
3772       /* out of GTK_PACK_END, get last GTK_PACK_START one */
3773       list = g_list_last (tree_column->cell_list);
3774       for ( ; list; list = list->prev)
3775         {
3776           PsppSheetViewColumnCellInfo *inf = list->data;
3777           if (inf->pack == GTK_PACK_START)
3778             return list;
3779         }
3780     }
3781
3782   for (list = current->prev; list; list = list->prev)
3783     {
3784       PsppSheetViewColumnCellInfo *inf = list->data;
3785       if (inf->pack == GTK_PACK_START)
3786         return list;
3787     }
3788
3789   return NULL;
3790 }
3791
3792 gboolean
3793 _pspp_sheet_view_column_cell_focus (PsppSheetViewColumn *tree_column,
3794                                   gint               direction,
3795                                   gboolean           left,
3796                                   gboolean           right)
3797 {
3798   gint count;
3799   gboolean rtl;
3800
3801   count = _pspp_sheet_view_column_count_special_cells (tree_column);
3802   rtl = gtk_widget_get_direction (GTK_WIDGET (tree_column->tree_view)) == GTK_TEXT_DIR_RTL;
3803
3804   /* if we are the current focus column and have multiple editable cells,
3805    * try to select the next one, else move the focus to the next column
3806    */
3807   if (PSPP_SHEET_VIEW (tree_column->tree_view)->priv->focus_column == tree_column)
3808     {
3809       if (count > 1)
3810         {
3811           GList *next, *prev;
3812           GList *list = tree_column->cell_list;
3813           PsppSheetViewColumnCellInfo *info = NULL;
3814
3815           /* find current focussed cell */
3816           for ( ; list; list = list->next)
3817             {
3818               info = list->data;
3819               if (info->has_focus)
3820                 break;
3821             }
3822
3823           /* not a focussed cell in the focus column? */
3824           if (!list || !info || !info->has_focus)
3825             return FALSE;
3826
3827           if (rtl)
3828             {
3829               prev = pspp_sheet_view_column_cell_next (tree_column, list);
3830               next = pspp_sheet_view_column_cell_prev (tree_column, list);
3831             }
3832           else
3833             {
3834               next = pspp_sheet_view_column_cell_next (tree_column, list);
3835               prev = pspp_sheet_view_column_cell_prev (tree_column, list);
3836             }
3837
3838           info->has_focus = FALSE;
3839           if (direction > 0 && next)
3840             {
3841               info = next->data;
3842               info->has_focus = TRUE;
3843               return TRUE;
3844             }
3845           else if (direction > 0 && !next && !right)
3846             {
3847               /* keep focus on last cell */
3848               if (rtl)
3849                 info = pspp_sheet_view_column_cell_first (tree_column)->data;
3850               else
3851                 info = pspp_sheet_view_column_cell_last (tree_column)->data;
3852
3853               info->has_focus = TRUE;
3854               return TRUE;
3855             }
3856           else if (direction < 0 && prev)
3857             {
3858               info = prev->data;
3859               info->has_focus = TRUE;
3860               return TRUE;
3861             }
3862           else if (direction < 0 && !prev && !left)
3863             {
3864               /* keep focus on first cell */
3865               if (rtl)
3866                 info = pspp_sheet_view_column_cell_last (tree_column)->data;
3867               else
3868                 info = pspp_sheet_view_column_cell_first (tree_column)->data;
3869
3870               info->has_focus = TRUE;
3871               return TRUE;
3872             }
3873         }
3874       return FALSE;
3875     }
3876
3877   /* we get focus, if we have multiple editable cells, give the correct one
3878    * focus
3879    */
3880   if (count > 1)
3881     {
3882       GList *list = tree_column->cell_list;
3883
3884       /* clear focus first */
3885       for ( ; list ; list = list->next)
3886         {
3887           PsppSheetViewColumnCellInfo *info = list->data;
3888           if (info->has_focus)
3889             info->has_focus = FALSE;
3890         }
3891
3892       list = NULL;
3893       if (rtl)
3894         {
3895           if (direction > 0)
3896             list = pspp_sheet_view_column_cell_last (tree_column);
3897           else if (direction < 0)
3898             list = pspp_sheet_view_column_cell_first (tree_column);
3899         }
3900       else
3901         {
3902           if (direction > 0)
3903             list = pspp_sheet_view_column_cell_first (tree_column);
3904           else if (direction < 0)
3905             list = pspp_sheet_view_column_cell_last (tree_column);
3906         }
3907
3908       if (list)
3909         ((PsppSheetViewColumnCellInfo *) list->data)->has_focus = TRUE;
3910     }
3911
3912   return TRUE;
3913 }
3914
3915 void
3916 _pspp_sheet_view_column_cell_draw_focus (PsppSheetViewColumn  *tree_column,
3917                                        GdkWindow          *window,
3918                                        const GdkRectangle *background_area,
3919                                        const GdkRectangle *cell_area,
3920                                        const GdkRectangle *expose_area,
3921                                        guint               flags)
3922 {
3923   gint focus_line_width;
3924   GtkStateType cell_state;
3925
3926   g_return_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column));
3927   gtk_widget_style_get (GTK_WIDGET (tree_column->tree_view),
3928                         "focus-line-width", &focus_line_width, NULL);
3929   if (tree_column->editable_widget)
3930     {
3931       /* This function is only called on the editable row when editing.
3932        */
3933 #if 0
3934       gtk_paint_focus (tree_column->tree_view->style,
3935                        window,
3936                        gtk_widget_get_state (tree_column->tree_view),
3937                        NULL,
3938                        tree_column->tree_view,
3939                        "treeview",
3940                        cell_area->x - focus_line_width,
3941                        cell_area->y - focus_line_width,
3942                        cell_area->width + 2 * focus_line_width,
3943                        cell_area->height + 2 * focus_line_width);
3944 #endif
3945     }
3946   else
3947     {
3948       GdkRectangle focus_rectangle;
3949       pspp_sheet_view_column_cell_process_action (tree_column,
3950                                                 window,
3951                                                 background_area,
3952                                                 cell_area,
3953                                                 flags,
3954                                                 CELL_ACTION_FOCUS,
3955                                                 expose_area,
3956                                                 &focus_rectangle,
3957                                                 NULL, NULL, NULL);
3958
3959       cell_state = flags & GTK_CELL_RENDERER_SELECTED ? GTK_STATE_SELECTED :
3960               (flags & GTK_CELL_RENDERER_PRELIT ? GTK_STATE_PRELIGHT :
3961               (flags & GTK_CELL_RENDERER_INSENSITIVE ? GTK_STATE_INSENSITIVE : GTK_STATE_NORMAL));
3962       gtk_paint_focus (gtk_widget_get_style (GTK_WIDGET (tree_column->tree_view)),
3963                        window,
3964                        cell_state,
3965                        cell_area,
3966                        tree_column->tree_view,
3967                        "treeview",
3968                        focus_rectangle.x,
3969                        focus_rectangle.y,
3970                        focus_rectangle.width,
3971                        focus_rectangle.height);
3972     }
3973 }
3974
3975 /**
3976  * pspp_sheet_view_column_cell_is_visible:
3977  * @tree_column: A #PsppSheetViewColumn
3978  *
3979  * Returns %TRUE if any of the cells packed into the @tree_column are visible.
3980  * For this to be meaningful, you must first initialize the cells with
3981  * pspp_sheet_view_column_cell_set_cell_data()
3982  *
3983  * Return value: %TRUE, if any of the cells packed into the @tree_column are currently visible
3984  **/
3985 gboolean
3986 pspp_sheet_view_column_cell_is_visible (PsppSheetViewColumn *tree_column)
3987 {
3988   GList *list;
3989
3990   g_return_val_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column), FALSE);
3991
3992   for (list = tree_column->cell_list; list; list = list->next)
3993     {
3994       PsppSheetViewColumnCellInfo *info = (PsppSheetViewColumnCellInfo *) list->data;
3995
3996       if (gtk_cell_renderer_get_visible (info->cell))
3997         return TRUE;
3998     }
3999
4000   return FALSE;
4001 }
4002
4003 /**
4004  * pspp_sheet_view_column_focus_cell:
4005  * @tree_column: A #PsppSheetViewColumn
4006  * @cell: A #GtkCellRenderer
4007  *
4008  * Sets the current keyboard focus to be at @cell, if the column contains
4009  * 2 or more editable and activatable cells.
4010  *
4011  * Since: 2.2
4012  **/
4013 void
4014 pspp_sheet_view_column_focus_cell (PsppSheetViewColumn *tree_column,
4015                                  GtkCellRenderer   *cell)
4016 {
4017   GList *list;
4018   gboolean found_cell = FALSE;
4019
4020   g_return_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column));
4021   g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
4022
4023   if (_pspp_sheet_view_column_count_special_cells (tree_column) < 2)
4024     return;
4025
4026   for (list = tree_column->cell_list; list; list = list->next)
4027     {
4028       PsppSheetViewColumnCellInfo *info = list->data;
4029
4030       if (info->cell == cell)
4031         {
4032           info->has_focus = TRUE;
4033           found_cell = TRUE;
4034           break;
4035         }
4036     }
4037
4038   if (found_cell)
4039     {
4040       for (list = tree_column->cell_list; list; list = list->next)
4041         {
4042           PsppSheetViewColumnCellInfo *info = list->data;
4043
4044           if (info->cell != cell)
4045             info->has_focus = FALSE;
4046         }
4047
4048       /* FIXME: redraw? */
4049     }
4050 }
4051
4052 void
4053 _pspp_sheet_view_column_cell_set_dirty (PsppSheetViewColumn *tree_column)
4054 {
4055   GList *list;
4056
4057   for (list = tree_column->cell_list; list; list = list->next)
4058     {
4059       PsppSheetViewColumnCellInfo *info = (PsppSheetViewColumnCellInfo *) list->data;
4060
4061       info->requested_width = 0;
4062     }
4063   tree_column->dirty = TRUE;
4064   tree_column->requested_width = -1;
4065   tree_column->width = 0;
4066
4067   if (tree_column->tree_view &&
4068       gtk_widget_get_realized (tree_column->tree_view))
4069     {
4070       _pspp_sheet_view_install_mark_rows_col_dirty (PSPP_SHEET_VIEW (tree_column->tree_view));
4071       gtk_widget_queue_resize (tree_column->tree_view);
4072     }
4073 }
4074
4075 void
4076 _pspp_sheet_view_column_start_editing (PsppSheetViewColumn *tree_column,
4077                                      GtkCellEditable   *cell_editable)
4078 {
4079   g_return_if_fail (tree_column->editable_widget == NULL);
4080
4081   tree_column->editable_widget = cell_editable;
4082 }
4083
4084 void
4085 _pspp_sheet_view_column_stop_editing (PsppSheetViewColumn *tree_column)
4086 {
4087   GList *list;
4088
4089   g_return_if_fail (tree_column->editable_widget != NULL);
4090
4091   tree_column->editable_widget = NULL;
4092   for (list = tree_column->cell_list; list; list = list->next)
4093     ((PsppSheetViewColumnCellInfo *)list->data)->in_editing_mode = FALSE;
4094 }
4095
4096 void
4097 _pspp_sheet_view_column_get_neighbor_sizes (PsppSheetViewColumn *column,
4098                                           GtkCellRenderer   *cell,
4099                                           gint              *left,
4100                                           gint              *right)
4101 {
4102   GList *list;
4103   PsppSheetViewColumnCellInfo *info;
4104   gint l, r;
4105   gboolean rtl;
4106
4107   l = r = 0;
4108
4109   list = pspp_sheet_view_column_cell_first (column);
4110
4111   while (list)
4112     {
4113       info = (PsppSheetViewColumnCellInfo *)list->data;
4114
4115       list = pspp_sheet_view_column_cell_next (column, list);
4116
4117       if (info->cell == cell)
4118         break;
4119
4120       if (gtk_cell_renderer_get_visible (info->cell))
4121         l += info->real_width + column->spacing;
4122     }
4123
4124   while (list)
4125     {
4126       info = (PsppSheetViewColumnCellInfo *)list->data;
4127
4128       list = pspp_sheet_view_column_cell_next (column, list);
4129
4130       if (gtk_cell_renderer_get_visible (info->cell))
4131         r += info->real_width + column->spacing;
4132     }
4133
4134   rtl = (gtk_widget_get_direction (GTK_WIDGET (column->tree_view)) == GTK_TEXT_DIR_RTL);
4135   if (left)
4136     *left = rtl ? r : l;
4137
4138   if (right)
4139     *right = rtl ? l : r;
4140 }
4141
4142 /**
4143  * pspp_sheet_view_column_cell_get_position:
4144  * @tree_column: a #PsppSheetViewColumn
4145  * @cell_renderer: a #GtkCellRenderer
4146  * @start_pos: return location for the horizontal position of @cell within
4147  *            @tree_column, may be %NULL
4148  * @width: return location for the width of @cell, may be %NULL
4149  *
4150  * Obtains the horizontal position and size of a cell in a column. If the
4151  * cell is not found in the column, @start_pos and @width are not changed and
4152  * %FALSE is returned.
4153  *
4154  * Return value: %TRUE if @cell belongs to @tree_column.
4155  */
4156 gboolean
4157 pspp_sheet_view_column_cell_get_position (PsppSheetViewColumn *tree_column,
4158                                         GtkCellRenderer   *cell_renderer,
4159                                         gint              *start_pos,
4160                                         gint              *width)
4161 {
4162   GList *list;
4163   gint current_x = 0;
4164   gboolean found_cell = FALSE;
4165   PsppSheetViewColumnCellInfo *cellinfo = NULL;
4166
4167   list = pspp_sheet_view_column_cell_first (tree_column);
4168   for (; list; list = pspp_sheet_view_column_cell_next (tree_column, list))
4169     {
4170       cellinfo = list->data;
4171       if (cellinfo->cell == cell_renderer)
4172         {
4173           found_cell = TRUE;
4174           break;
4175         }
4176
4177       if (gtk_cell_renderer_get_visible (cellinfo->cell))
4178         current_x += cellinfo->real_width;
4179     }
4180
4181   if (found_cell)
4182     {
4183       if (start_pos)
4184         *start_pos = current_x;
4185       if (width)
4186         *width = cellinfo->real_width;
4187     }
4188
4189   return found_cell;
4190 }
4191
4192 /**
4193  * pspp_sheet_view_column_queue_resize:
4194  * @tree_column: A #PsppSheetViewColumn
4195  *
4196  * Flags the column, and the cell renderers added to this column, to have
4197  * their sizes renegotiated.
4198  *
4199  * Since: 2.8
4200  **/
4201 void
4202 pspp_sheet_view_column_queue_resize (PsppSheetViewColumn *tree_column)
4203 {
4204   g_return_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column));
4205
4206   if (tree_column->tree_view)
4207     _pspp_sheet_view_column_cell_set_dirty (tree_column);
4208 }
4209
4210 /**
4211  * pspp_sheet_view_column_get_tree_view:
4212  * @tree_column: A #PsppSheetViewColumn
4213  *
4214  * Returns the #PsppSheetView wherein @tree_column has been inserted.  If
4215  * @column is currently not inserted in any tree view, %NULL is
4216  * returned.
4217  *
4218  * Return value: The tree view wherein @column has been inserted if any,
4219  *               %NULL otherwise.
4220  *
4221  * Since: 2.12
4222  */
4223 GtkWidget *
4224 pspp_sheet_view_column_get_tree_view (PsppSheetViewColumn *tree_column)
4225 {
4226   g_return_val_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column), NULL);
4227
4228   return tree_column->tree_view;
4229 }
4230
4231 typedef struct {
4232   GtkCellLayout   *cell_layout;
4233   GtkCellRenderer *renderer;
4234   gchar           *attr_name;
4235 } AttributesSubParserData;
4236
4237 static void
4238 attributes_start_element (GMarkupParseContext *context,
4239                           const gchar         *element_name,
4240                           const gchar        **names,
4241                           const gchar        **values,
4242                           gpointer             user_data,
4243                           GError             **error)
4244 {
4245   AttributesSubParserData *parser_data = (AttributesSubParserData*)user_data;
4246   guint i;
4247
4248   if (strcmp (element_name, "attribute") == 0)
4249     {
4250       for (i = 0; names[i]; i++)
4251         if (strcmp (names[i], "name") == 0)
4252           parser_data->attr_name = g_strdup (values[i]);
4253     }
4254   else if (strcmp (element_name, "attributes") == 0)
4255     return;
4256   else
4257     g_warning ("Unsupported tag for GtkCellLayout: %s\n", element_name);
4258 }
4259
4260 static void
4261 attributes_text_element (GMarkupParseContext *context,
4262                          const gchar         *text,
4263                          gsize                text_len,
4264                          gpointer             user_data,
4265                          GError             **error)
4266 {
4267   AttributesSubParserData *parser_data = (AttributesSubParserData*)user_data;
4268   glong l;
4269   gchar *endptr;
4270   gchar *string;
4271
4272   if (!parser_data->attr_name)
4273     return;
4274
4275   errno = 0;
4276   string = g_strndup (text, text_len);
4277   l = strtol (string, &endptr, 0);
4278   if (errno || endptr == string)
4279     {
4280       g_set_error (error,
4281                    GTK_BUILDER_ERROR,
4282                    GTK_BUILDER_ERROR_INVALID_VALUE,
4283                    "Could not parse integer `%s'",
4284                    string);
4285       g_free (string);
4286       return;
4287     }
4288   g_free (string);
4289
4290   gtk_cell_layout_add_attribute (parser_data->cell_layout,
4291                                  parser_data->renderer,
4292                                  parser_data->attr_name, l);
4293   g_free (parser_data->attr_name);
4294   parser_data->attr_name = NULL;
4295 }
4296
4297 static const GMarkupParser attributes_parser =
4298   {
4299     attributes_start_element,
4300     NULL,
4301     attributes_text_element,
4302   };
4303
4304 static gboolean
4305 _cell_layout_buildable_custom_tag_start (GtkBuildable  *buildable,
4306                                              GtkBuilder    *builder,
4307                                              GObject       *child,
4308                                              const gchar   *tagname,
4309                                              GMarkupParser *parser,
4310                                              gpointer      *data)
4311 {
4312   AttributesSubParserData *parser_data;
4313
4314   if (!child)
4315     return FALSE;
4316
4317   if (strcmp (tagname, "attributes") == 0)
4318     {
4319       parser_data = g_slice_new0 (AttributesSubParserData);
4320       parser_data->cell_layout = GTK_CELL_LAYOUT (buildable);
4321       parser_data->renderer = GTK_CELL_RENDERER (child);
4322       parser_data->attr_name = NULL;
4323
4324       *parser = attributes_parser;
4325       *data = parser_data;
4326       return TRUE;
4327     }
4328
4329   return FALSE;
4330 }
4331
4332 static void
4333 _cell_layout_buildable_custom_tag_end (GtkBuildable *buildable,
4334                                            GtkBuilder   *builder,
4335                                            GObject      *child,
4336                                            const gchar  *tagname,
4337                                            gpointer     *data)
4338 {
4339   AttributesSubParserData *parser_data;
4340
4341   parser_data = (AttributesSubParserData*)data;
4342   g_assert (!parser_data->attr_name);
4343   g_slice_free (AttributesSubParserData, parser_data);
4344 }
4345
4346 static void
4347 _cell_layout_buildable_add_child (GtkBuildable      *buildable,
4348                                       GtkBuilder        *builder,
4349                                       GObject           *child,
4350                                       const gchar       *type)
4351 {
4352   GtkCellLayoutIface *iface;
4353
4354   g_return_if_fail (GTK_IS_CELL_LAYOUT (buildable));
4355   g_return_if_fail (GTK_IS_CELL_RENDERER (child));
4356
4357   iface = GTK_CELL_LAYOUT_GET_IFACE (buildable);
4358   g_return_if_fail (iface->pack_start != NULL);
4359   iface->pack_start (GTK_CELL_LAYOUT (buildable), GTK_CELL_RENDERER (child), FALSE);
4360 }
4361
4362 void
4363 pspp_sheet_view_column_size_request (PsppSheetViewColumn       *tree_column,
4364                                      GtkRequisition            *request)
4365 {
4366   GtkWidget *base = GTK_WIDGET (tree_column->tree_view);
4367   GtkRequisition label_req;
4368   GtkRequisition align_req;
4369   GtkRequisition arrow_req;
4370   GtkRequisition hbox_req;
4371   GtkStyle **button_style;
4372
4373   if (tree_column->button)
4374     {
4375       gtk_widget_size_request (tree_column->button, request);
4376       return;
4377     }
4378
4379   facade_label_get_size_request (0, 0, base, tree_column->title, &label_req);
4380   facade_alignment_get_size_request (0, 0, 0, 0, 0, &label_req, &align_req);
4381   facade_arrow_get_size_request (0, 0, &arrow_req);
4382
4383   facade_hbox_get_base_size_request (0, 2, 2, &hbox_req);
4384   facade_hbox_add_child_size_request (0, &arrow_req, 0, &hbox_req);
4385   facade_hbox_add_child_size_request (0, &align_req, 0, &hbox_req);
4386
4387   button_style = &PSPP_SHEET_VIEW (tree_column->tree_view)->priv->button_style;
4388   if (*button_style == NULL)
4389     {
4390       *button_style = facade_get_style (base, GTK_TYPE_BUTTON, 0);
4391       g_object_ref (*button_style);
4392     }
4393   facade_button_get_size_request (0, base, *button_style, &hbox_req, request);
4394 }
4395
4396 void
4397 pspp_sheet_view_column_size_allocate (PsppSheetViewColumn       *tree_column,
4398                                       GtkAllocation             *allocation)
4399 {
4400   tree_column->allocation = *allocation;
4401   if (tree_column->button)
4402     gtk_widget_size_allocate (tree_column->button, allocation);
4403 }
4404
4405 gboolean
4406 pspp_sheet_view_column_can_focus (PsppSheetViewColumn       *tree_column)
4407 {
4408   return tree_column->reorderable || tree_column->clickable;
4409 }
4410
4411 void
4412 pspp_sheet_view_column_set_need_button (PsppSheetViewColumn       *tree_column,
4413                                         gboolean                   need_button)
4414 {
4415   if (tree_column->need_button != need_button)
4416     {
4417       tree_column->need_button = need_button;
4418       pspp_sheet_view_column_update_button (tree_column);
4419       _pspp_sheet_view_column_realize_button (tree_column);
4420     }
4421 }