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