src/ui/gui/psppire-data-editor.c

   1 /* PSPPIRE - a graphical user interface for PSPP.
   2    Copyright (C) 2008 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 #include <config.h>
  18 #include <gtk/gtksignal.h>
  19 #include <gtk/gtk.h>
  20 #include <gtksheet/gtkextra-sheet.h>
  21 #include "psppire-data-editor.h"
  22 #include "psppire-var-sheet.h"
  23
  24 #include <language/syntax-string-source.h>
  25 #include "psppire-data-store.h"
  26 #include <gtksheet/psppire-axis-hetero.h>
  27 #include <gtksheet/psppire-axis-uniform.h>
  28 #include "helper.h"
  29
  30 #include <gtksheet/gtkxpaned.h>
  31 #include <gettext.h>
  32 #define _(msgid) gettext (msgid)
  33 #define N_(msgid) msgid
  34
  35
  36 static void psppire_data_editor_remove_split (PsppireDataEditor *de);
  37 static void psppire_data_editor_set_split (PsppireDataEditor *de);
  38
  39 enum {
  40   DATA_SELECTION_CHANGED,
  41   DATA_AVAILABLE_CHANGED,
  42   CASES_SELECTED,
  43   VARIABLES_SELECTED,
  44   n_SIGNALS
  45 };
  46
  47
  48 static guint data_editor_signals [n_SIGNALS] = { 0 };
  49
  50
  51 static gboolean data_is_selected (PsppireDataEditor *de);
  52
  53 static void psppire_data_editor_class_init          (PsppireDataEditorClass *klass);
  54 static void psppire_data_editor_init                (PsppireDataEditor      *de);
  55
  56 GType
  57 psppire_data_editor_get_type (void)
  58 {
  59   static GType de_type = 0;
  60
  61   if (!de_type)
  62     {
  63       static const GTypeInfo de_info =
  64       {
  65         sizeof (PsppireDataEditorClass),
  66         NULL, /* base_init */
  67         NULL, /* base_finalize */
  68         (GClassInitFunc) psppire_data_editor_class_init,
  69         NULL, /* class_finalize */
  70         NULL, /* class_data */
  71         sizeof (PsppireDataEditor),
  72         0,
  73         (GInstanceInitFunc) psppire_data_editor_init,
  74       };
  75
  76       de_type = g_type_register_static (GTK_TYPE_NOTEBOOK, "PsppireDataEditor",
  77                                         &de_info, 0);
  78     }
  79
  80   return de_type;
  81 }
  82
  83 static GObjectClass * parent_class = NULL;
  84
  85 static void
  86 psppire_data_editor_dispose (GObject *obj)
  87 {
  88   PsppireDataEditor *de = (PsppireDataEditor *) obj;
  89
  90   if (de->dispose_has_run)
  91     return;
  92
  93   g_object_unref (de->data_store);
  94   g_object_unref (de->var_store);
  95
  96   /* Make sure dispose does not run twice. */
  97   de->dispose_has_run = TRUE;
  98
  99   /* Chain up to the parent class */
 100   G_OBJECT_CLASS (parent_class)->dispose (obj);
 101 }
 102
 103 static void
 104 psppire_data_editor_finalize (GObject *obj)
 105 {
 106    /* Chain up to the parent class */
 107    G_OBJECT_CLASS (parent_class)->finalize (obj);
 108 }
 109
 110
 111
 112 static void popup_variable_column_menu (GtkSheet *sheet, gint column,
 113                                         GdkEventButton *event, gpointer data);
 114
 115 static void popup_variable_row_menu (GtkSheet *sheet, gint row,
 116                                      GdkEventButton *event, gpointer data);
 117
 118
 119 static void popup_cases_menu (GtkSheet *sheet, gint row,
 120                               GdkEventButton *event, gpointer data);
 121
 122
 123
 124
 125
 126 /* Callback which occurs when the data sheet's column title
 127    is double clicked */
 128 static gboolean
 129 on_data_column_clicked (PsppireDataEditor *de, gint col, gpointer data)
 130 {
 131   GtkSheetRange visible_range;
 132   gint current_row, current_column;
 133
 134   gtk_notebook_set_current_page (GTK_NOTEBOOK (de),
 135                                  PSPPIRE_DATA_EDITOR_VARIABLE_VIEW);
 136
 137   gtk_sheet_get_active_cell (GTK_SHEET (de->var_sheet),
 138                              &current_row, &current_column);
 139
 140   gtk_sheet_set_active_cell (GTK_SHEET (de->var_sheet), col, current_column);
 141
 142
 143   gtk_sheet_get_visible_range (GTK_SHEET (de->var_sheet), &visible_range);
 144
 145   if ( col < visible_range.row0 || col > visible_range.rowi)
 146     gtk_sheet_moveto (GTK_SHEET (de->var_sheet), col, current_column, 0.5, 0.5);
 147
 148
 149   return FALSE;
 150 }
 151
 152
 153 /* Callback which occurs when the var sheet's row title
 154    button is double clicked */
 155 static gboolean
 156 on_var_row_clicked (PsppireDataEditor *de, gint row, gpointer data)
 157 {
 158   GtkSheetRange visible_range;
 159
 160   gint current_row, current_column;
 161
 162   gtk_notebook_set_current_page (GTK_NOTEBOOK(de), PSPPIRE_DATA_EDITOR_DATA_VIEW);
 163
 164   gtk_sheet_get_active_cell (GTK_SHEET (de->data_sheet[0]),
 165                              &current_row, &current_column);
 166
 167   gtk_sheet_set_active_cell (GTK_SHEET (de->data_sheet[0]), current_row, row);
 168
 169   gtk_sheet_get_visible_range (GTK_SHEET (de->data_sheet[0]), &visible_range);
 170
 171   if ( row < visible_range.col0 || row > visible_range.coli)
 172     gtk_sheet_moveto (GTK_SHEET (de->data_sheet[0]), -1, row, 0.5, 0.5);
 173
 174   return FALSE;
 175 }
 176
 177
 178 /* Moves the focus to a new cell.
 179    Returns TRUE iff the move should be disallowed */
 180 static gboolean
 181 traverse_cell_callback (GtkSheet *sheet,
 182                         GtkSheetCell *existing_cell,
 183                         GtkSheetCell *new_cell,
 184                         gpointer data)
 185 {
 186   PsppireDataEditor *de = PSPPIRE_DATA_EDITOR (data);
 187   const PsppireDict *dict = de->data_store->dict;
 188
 189   if ( new_cell->col >= psppire_dict_get_var_cnt (dict))
 190     return TRUE;
 191
 192   return FALSE;
 193 }
 194
 195
 196 enum
 197   {
 198     PROP_0,
 199     PROP_DATA_STORE,
 200     PROP_VAR_STORE,
 201     PROP_VS_ROW_MENU,
 202     PROP_DS_COLUMN_MENU,
 203     PROP_DS_ROW_MENU,
 204     PROP_VALUE_LABELS,
 205     PROP_CURRENT_CASE,
 206     PROP_CURRENT_VAR,
 207     PROP_DATA_SELECTED,
 208     PROP_SPLIT_WINDOW
 209   };
 210
 211
 212 #define DEFAULT_ROW_HEIGHT 25
 213
 214 static void
 215 new_data_callback (PsppireDataStore *ds, gpointer data)
 216 {
 217   PsppireDataEditor *de = PSPPIRE_DATA_EDITOR (data);
 218   gint i;
 219   for (i = 0 ; i < 4 ; ++i)
 220     {
 221       PsppireAxisUniform *vaxis;
 222       casenumber n_cases =  psppire_data_store_get_case_count (ds);
 223
 224       g_object_get (de->data_sheet[i], "vertical-axis", &vaxis, NULL);
 225
 226       psppire_axis_uniform_set_count (vaxis, n_cases);
 227     }
 228 }
 229
 230 /* Return the width (in pixels) of an upper case M when rendered in the
 231    current font of W
 232 */
 233 static gint
 234 width_of_m (GtkWidget *w)
 235 {
 236   PangoRectangle rect;
 237   PangoLayout *layout = gtk_widget_create_pango_layout (w, "M");
 238
 239   pango_layout_get_pixel_extents (layout, NULL, &rect);
 240
 241   g_object_unref (layout);
 242
 243   return rect.width;
 244 }
 245
 246 static void
 247 new_variables_callback (PsppireDict *dict, gpointer data)
 248 {
 249   gint v, i;
 250   PsppireDataEditor *de = PSPPIRE_DATA_EDITOR (data);
 251   gint m_width = width_of_m (GTK_WIDGET (de));
 252
 253   PsppireAxisHetero *vaxis;
 254   g_object_get (de->var_sheet, "vertical-axis", &vaxis, NULL);
 255
 256   psppire_axis_hetero_clear (vaxis);
 257
 258   for (v = 0 ; v < psppire_dict_get_var_cnt (dict); ++v)
 259     psppire_axis_hetero_append (vaxis, DEFAULT_ROW_HEIGHT);
 260
 261   for (i = 0 ; i < 4 ; ++i)
 262     {
 263       PsppireAxisHetero *haxis;
 264       g_object_get (de->data_sheet[i], "horizontal-axis", &haxis, NULL);
 265
 266       psppire_axis_hetero_clear (haxis);
 267
 268       for (v = 0 ; v < psppire_dict_get_var_cnt (dict); ++v)
 269         {
 270           const struct variable *var = psppire_dict_get_variable (dict, v);
 271
 272           psppire_axis_hetero_append (haxis, m_width * var_get_display_width (var));
 273         }
 274     }
 275 }
 276
 277 static void
 278 insert_variable_callback (PsppireDict *dict, gint x, gpointer data)
 279 {
 280   gint i;
 281
 282   PsppireDataEditor *de = PSPPIRE_DATA_EDITOR (data);
 283
 284   gint m_width  = width_of_m (GTK_WIDGET (de));
 285
 286   PsppireAxisHetero *var_vaxis;
 287   g_object_get (de->var_sheet, "vertical-axis", &var_vaxis, NULL);
 288
 289   psppire_axis_hetero_insert (var_vaxis, DEFAULT_ROW_HEIGHT, x);
 290
 291   for (i = 0 ; i < 4 ; ++i)
 292     {
 293       const struct variable *var = psppire_dict_get_variable (dict, x);
 294       PsppireAxisHetero *haxis;
 295       g_object_get (de->data_sheet[i], "horizontal-axis", &haxis, NULL);
 296
 297       psppire_axis_hetero_insert (haxis, m_width * var_get_display_width (var), x);
 298     }
 299 }
 300
 301
 302 static void
 303 delete_variable_callback (PsppireDict *dict, gint posn,
 304                           gint x UNUSED, gint y UNUSED, gpointer data)
 305 {
 306   gint i;
 307   PsppireDataEditor *de = PSPPIRE_DATA_EDITOR (data);
 308
 309   PsppireAxisHetero *var_vaxis;
 310   g_object_get (de->var_sheet, "vertical-axis", &var_vaxis, NULL);
 311
 312   psppire_axis_hetero_remove (var_vaxis, posn);
 313
 314   for (i = 0 ; i < 4 ; ++i)
 315     {
 316       PsppireAxisHetero *haxis;
 317       g_object_get (de->data_sheet[i], "horizontal-axis", &haxis, NULL);
 318
 319       psppire_axis_hetero_remove (haxis, posn);
 320     }
 321 }
 322
 323
 324 static void
 325 rewidth_variable_callback (PsppireDict *dict, gint posn, gpointer data)
 326 {
 327   gint i;
 328   PsppireDataEditor *de = PSPPIRE_DATA_EDITOR (data);
 329   gint m_width = width_of_m (GTK_WIDGET (de));
 330
 331   for (i = 0 ; i < 4 ; ++i)
 332     {
 333       const struct variable *var = psppire_dict_get_variable (dict, posn);
 334       PsppireAxisHetero *haxis;
 335       g_object_get (de->data_sheet[i], "horizontal-axis", &haxis, NULL);
 336
 337       psppire_axis_hetero_resize_unit (haxis,
 338                                        m_width *
 339                                        var_get_display_width (var), posn);
 340     }
 341 }
 342
 343
 344 static void
 345 psppire_data_editor_set_property (GObject         *object,
 346                                   guint            prop_id,
 347                                   const GValue    *value,
 348                                   GParamSpec      *pspec)
 349 {
 350   int i;
 351   PsppireDataEditor *de = PSPPIRE_DATA_EDITOR (object);
 352
 353   switch (prop_id)
 354     {
 355     case PROP_SPLIT_WINDOW:
 356       psppire_data_editor_split_window (de, g_value_get_boolean (value));
 357       break;
 358     case PROP_DATA_STORE:
 359       if ( de->data_store) g_object_unref (de->data_store);
 360       de->data_store = g_value_get_pointer (value);
 361       g_object_ref (de->data_store);
 362
 363       for (i = 0 ; i < 4 ; ++i )
 364         g_object_set (de->data_sheet[i],
 365                       "model", de->data_store,
 366                       NULL);
 367
 368       g_signal_connect (de->data_store->dict, "backend-changed",   G_CALLBACK (new_variables_callback), de);
 369       g_signal_connect (de->data_store->dict, "variable-inserted", G_CALLBACK (insert_variable_callback), de);
 370       g_signal_connect (de->data_store->dict, "variable-deleted",  G_CALLBACK (delete_variable_callback), de);
 371       g_signal_connect (de->data_store->dict, "variable-display-width-changed",  G_CALLBACK (rewidth_variable_callback), de);
 372
 373       g_signal_connect (de->data_store, "backend-changed", G_CALLBACK (new_data_callback), de);
 374       break;
 375     case PROP_VAR_STORE:
 376       if ( de->var_store) g_object_unref (de->var_store);
 377       de->var_store = g_value_get_pointer (value);
 378       g_object_ref (de->var_store);
 379
 380       g_object_set (de->var_sheet,
 381                     "model", de->var_store,
 382                     NULL);
 383       break;
 384     case PROP_VS_ROW_MENU:
 385       {
 386         GObject *menu = g_value_get_object (value);
 387
 388         g_signal_connect (de->var_sheet, "button-event-row",
 389                           G_CALLBACK (popup_variable_row_menu), menu);
 390       }
 391       break;
 392     case PROP_DS_COLUMN_MENU:
 393       {
 394         GObject *menu = g_value_get_object (value);
 395
 396         g_signal_connect (de->data_sheet[0], "button-event-column",
 397                           G_CALLBACK (popup_variable_column_menu), menu);
 398       }
 399       break;
 400     case PROP_DS_ROW_MENU:
 401       {
 402         GObject *menu = g_value_get_object (value);
 403
 404         g_signal_connect (de->data_sheet[0], "button-event-row",
 405                           G_CALLBACK (popup_cases_menu), menu);
 406       }
 407       break;
 408     case PROP_CURRENT_VAR:
 409       {
 410         gint row, col;
 411         gint var = g_value_get_long (value);
 412         switch (gtk_notebook_get_current_page (GTK_NOTEBOOK (object)))
 413           {
 414           case PSPPIRE_DATA_EDITOR_DATA_VIEW:
 415             gtk_sheet_get_active_cell (GTK_SHEET (de->data_sheet[0]), &row, &col);
 416             gtk_sheet_set_active_cell (GTK_SHEET (de->data_sheet[0]), row, var);
 417             gtk_sheet_moveto (GTK_SHEET (de->data_sheet[0]), -1, var, 0.5, 0.5);
 418             break;
 419           case PSPPIRE_DATA_EDITOR_VARIABLE_VIEW:
 420             gtk_sheet_get_active_cell (GTK_SHEET (de->var_sheet), &row, &col);
 421             gtk_sheet_set_active_cell (GTK_SHEET (de->var_sheet), var, col);
 422             gtk_sheet_moveto (GTK_SHEET (de->var_sheet), var, -1,  0.5, 0.5);
 423             break;
 424           default:
 425             g_assert_not_reached ();
 426             break;
 427           };
 428       }
 429       break;
 430     case PROP_CURRENT_CASE:
 431       {
 432         gint row, col;
 433         gint case_num = g_value_get_long (value);
 434         gtk_sheet_get_active_cell (GTK_SHEET (de->data_sheet[0]), &row, &col);
 435         gtk_sheet_set_active_cell (GTK_SHEET (de->data_sheet[0]), case_num, col);
 436         gtk_sheet_moveto (GTK_SHEET (de->data_sheet[0]), case_num, -1, 0.5, 0.5);
 437       }
 438       break;
 439     case PROP_VALUE_LABELS:
 440       {
 441         psppire_data_store_show_labels (de->data_store,
 442                                         g_value_get_boolean (value));
 443       }
 444       break;
 445     default:
 446       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 447       break;
 448     };
 449 }
 450
 451 static void
 452 psppire_data_editor_get_property (GObject         *object,
 453                                   guint            prop_id,
 454                                   GValue          *value,
 455                                   GParamSpec      *pspec)
 456 {
 457   PsppireDataEditor *de = PSPPIRE_DATA_EDITOR (object);
 458
 459   switch (prop_id)
 460     {
 461     case PROP_SPLIT_WINDOW:
 462       g_value_set_boolean (value, de->split);
 463       break;
 464     case PROP_DATA_STORE:
 465       g_value_set_pointer (value, de->data_store);
 466       break;
 467     case PROP_VAR_STORE:
 468       g_value_set_pointer (value, de->var_store);
 469       break;
 470     case PROP_CURRENT_CASE:
 471       {
 472         gint row, column;
 473         gtk_sheet_get_active_cell (GTK_SHEET (de->data_sheet[0]), &row, &column);
 474         g_value_set_long (value, row);
 475       }
 476       break;
 477     case PROP_CURRENT_VAR:
 478       {
 479         gint row, column;
 480         gtk_sheet_get_active_cell (GTK_SHEET (de->data_sheet[0]), &row, &column);
 481         g_value_set_long (value, column);
 482       }
 483       break;
 484     case PROP_DATA_SELECTED:
 485       g_value_set_boolean (value, data_is_selected (de));
 486       break;
 487     default:
 488       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 489       break;
 490     };
 491 }
 492
 493
 494 static void
 495 psppire_data_editor_class_init (PsppireDataEditorClass *klass)
 496 {
 497   GParamSpec *data_store_spec ;
 498   GParamSpec *var_store_spec ;
 499   GParamSpec *column_menu_spec;
 500   GParamSpec *ds_row_menu_spec;
 501   GParamSpec *vs_row_menu_spec;
 502   GParamSpec *value_labels_spec;
 503   GParamSpec *current_case_spec;
 504   GParamSpec *current_var_spec;
 505   GParamSpec *data_selected_spec;
 506   GParamSpec *split_window_spec;
 507   GObjectClass *object_class = G_OBJECT_CLASS (klass);
 508
 509   parent_class = g_type_class_peek_parent (klass);
 510
 511   object_class->dispose = psppire_data_editor_dispose;
 512   object_class->finalize = psppire_data_editor_finalize;
 513
 514   object_class->set_property = psppire_data_editor_set_property;
 515   object_class->get_property = psppire_data_editor_get_property;
 516
 517   data_store_spec =
 518     g_param_spec_pointer ("data-store",
 519                           "Data Store",
 520                           "A pointer to the data store associated with this editor",
 521                           G_PARAM_CONSTRUCT_ONLY | G_PARAM_WRITABLE | G_PARAM_READABLE );
 522
 523   g_object_class_install_property (object_class,
 524                                    PROP_DATA_STORE,
 525                                    data_store_spec);
 526
 527   var_store_spec =
 528     g_param_spec_pointer ("var-store",
 529                           "Variable Store",
 530                           "A pointer to the variable store associated with this editor",
 531                           G_PARAM_CONSTRUCT_ONLY | G_PARAM_WRITABLE | G_PARAM_READABLE );
 532
 533   g_object_class_install_property (object_class,
 534                                    PROP_VAR_STORE,
 535                                    var_store_spec);
 536
 537   column_menu_spec =
 538     g_param_spec_object ("datasheet-column-menu",
 539                          "Data Sheet Column Menu",
 540                          "A menu to be displayed when button 3 is pressed in thedata sheet's column title buttons",
 541                          GTK_TYPE_MENU,
 542                          G_PARAM_WRITABLE);
 543
 544   g_object_class_install_property (object_class,
 545                                    PROP_DS_COLUMN_MENU,
 546                                    column_menu_spec);
 547
 548
 549   ds_row_menu_spec =
 550     g_param_spec_object ("datasheet-row-menu",
 551                          "Data Sheet Row Menu",
 552                          "A menu to be displayed when button 3 is pressed in the data sheet's row title buttons",
 553                          GTK_TYPE_MENU,
 554                          G_PARAM_WRITABLE);
 555
 556   g_object_class_install_property (object_class,
 557                                    PROP_DS_ROW_MENU,
 558                                    ds_row_menu_spec);
 559
 560
 561   vs_row_menu_spec =
 562     g_param_spec_object ("varsheet-row-menu",
 563                          "Variable Sheet Row Menu",
 564                          "A menu to be displayed when button 3 is pressed in the variable sheet's row title buttons",
 565                          GTK_TYPE_MENU,
 566                          G_PARAM_WRITABLE);
 567
 568   g_object_class_install_property (object_class,
 569                                    PROP_VS_ROW_MENU,
 570                                    vs_row_menu_spec);
 571
 572
 573   value_labels_spec =
 574     g_param_spec_boolean ("value-labels",
 575                          "Value Labels",
 576                          "Whether or not the data sheet should display labels instead of values",
 577                           FALSE,
 578                          G_PARAM_WRITABLE | G_PARAM_READABLE);
 579
 580   g_object_class_install_property (object_class,
 581                                    PROP_VALUE_LABELS,
 582                                    value_labels_spec);
 583
 584
 585   current_case_spec =
 586     g_param_spec_long ("current-case",
 587                        "Current Case",
 588                        "Zero based number of the selected case",
 589                        0, CASENUMBER_MAX,
 590                        0,
 591                        G_PARAM_WRITABLE | G_PARAM_READABLE);
 592
 593   g_object_class_install_property (object_class,
 594                                    PROP_CURRENT_CASE,
 595                                    current_case_spec);
 596
 597
 598   current_var_spec =
 599     g_param_spec_long ("current-variable",
 600                        "Current Variable",
 601                        "Zero based number of the selected variable",
 602                        0, G_MAXINT,
 603                        0,
 604                        G_PARAM_WRITABLE | G_PARAM_READABLE);
 605
 606   g_object_class_install_property (object_class,
 607                                    PROP_CURRENT_VAR,
 608                                    current_var_spec);
 609
 610
 611   data_selected_spec =
 612     g_param_spec_boolean ("data-selected",
 613                           "Data Selected",
 614                           "True iff the data view is active and  one or more cells of data have been selected.",
 615                           FALSE,
 616                           G_PARAM_READABLE);
 617
 618   g_object_class_install_property (object_class,
 619                                    PROP_DATA_SELECTED,
 620                                    data_selected_spec);
 621
 622
 623
 624   split_window_spec =
 625     g_param_spec_boolean ("split",
 626                           "Split Window",
 627                           "True iff the data sheet is split",
 628                           FALSE,
 629                           G_PARAM_READABLE | G_PARAM_WRITABLE);
 630
 631   g_object_class_install_property (object_class,
 632                                    PROP_SPLIT_WINDOW,
 633                                    split_window_spec);
 634
 635   data_editor_signals [DATA_SELECTION_CHANGED] =
 636     g_signal_new ("data-selection-changed",
 637                   G_TYPE_FROM_CLASS (klass),
 638                   G_SIGNAL_RUN_FIRST,
 639                   0,
 640                   NULL, NULL,
 641                   g_cclosure_marshal_VOID__BOOLEAN,
 642                   G_TYPE_NONE,
 643                   1,
 644                   G_TYPE_BOOLEAN);
 645
 646   data_editor_signals [CASES_SELECTED] =
 647     g_signal_new ("cases-selected",
 648                   G_TYPE_FROM_CLASS (klass),
 649                   G_SIGNAL_RUN_FIRST,
 650                   0,
 651                   NULL, NULL,
 652                   g_cclosure_marshal_VOID__INT,
 653                   G_TYPE_NONE,
 654                   1,
 655                   G_TYPE_INT);
 656
 657
 658   data_editor_signals [VARIABLES_SELECTED] =
 659     g_signal_new ("variables-selected",
 660                   G_TYPE_FROM_CLASS (klass),
 661                   G_SIGNAL_RUN_FIRST,
 662                   0,
 663                   NULL, NULL,
 664                   g_cclosure_marshal_VOID__INT,
 665                   G_TYPE_NONE,
 666                   1,
 667                   G_TYPE_INT);
 668
 669
 670   data_editor_signals [DATA_AVAILABLE_CHANGED] =
 671     g_signal_new ("data-available-changed",
 672                   G_TYPE_FROM_CLASS (klass),
 673                   G_SIGNAL_RUN_FIRST,
 674                   0,
 675                   NULL, NULL,
 676                   g_cclosure_marshal_VOID__BOOLEAN,
 677                   G_TYPE_NONE,
 678                   1,
 679                   G_TYPE_BOOLEAN);
 680 }
 681
 682 /* Update the data_ref_entry with the reference of the active cell */
 683 static gint
 684 update_data_ref_entry (const GtkSheet *sheet,
 685                        gint row, gint col,
 686                        gint old_row, gint old_col,
 687                        gpointer data)
 688 {
 689   PsppireDataEditor *de = data;
 690
 691   PsppireDataStore *data_store =
 692     PSPPIRE_DATA_STORE (gtk_sheet_get_model (sheet));
 693
 694   if (data_store)
 695     {
 696       const struct variable *var =
 697         psppire_dict_get_variable (data_store->dict, col);
 698
 699       if ( var )
 700         {
 701           gchar *text = g_strdup_printf ("%d: %s", row + FIRST_CASE_NUMBER,
 702                                          var_get_name (var));
 703
 704           gchar *s = pspp_locale_to_utf8 (text, -1, 0);
 705
 706           g_free (text);
 707
 708           gtk_entry_set_text (GTK_ENTRY (de->cell_ref_entry), s);
 709
 710           g_free (s);
 711         }
 712       else
 713         goto blank_entry;
 714
 715       if ( var )
 716         {
 717           gchar *text =
 718             psppire_data_store_get_string (data_store, row,
 719                                            var_get_dict_index(var));
 720
 721           if ( ! text )
 722             goto blank_entry;
 723
 724           g_strchug (text);
 725
 726           gtk_entry_set_text (GTK_ENTRY (de->datum_entry), text);
 727
 728           g_free (text);
 729         }
 730       else
 731         goto blank_entry;
 732
 733     }
 734
 735   return FALSE;
 736
 737  blank_entry:
 738   gtk_entry_set_text (GTK_ENTRY (de->datum_entry), "");
 739
 740   return FALSE;
 741 }
 742
 743
 744 static void
 745 datum_entry_activate (GtkEntry *entry, gpointer data)
 746 {
 747   gint row, column;
 748   PsppireDataEditor *de = data;
 749
 750   const gchar *text = gtk_entry_get_text (entry);
 751
 752   gtk_sheet_get_active_cell (GTK_SHEET (de->data_sheet[0]), &row, &column);
 753
 754   if ( row == -1 || column == -1)
 755     return;
 756
 757   psppire_data_store_set_string (de->data_store, text, row, column);
 758 }
 759
 760 static void on_activate (PsppireDataEditor *de);
 761 static gboolean on_switch_page (PsppireDataEditor *de, GtkNotebookPage *p, gint pagenum, gpointer data);
 762 static void on_select_range (PsppireDataEditor *de);
 763
 764 static void on_select_row (GtkSheet *, gint, PsppireDataEditor *);
 765 static void on_select_variable (GtkSheet *, gint, PsppireDataEditor *);
 766
 767
 768 static void on_owner_change (GtkClipboard *,
 769                              GdkEventOwnerChange *, gpointer);
 770
 771 static void
 772 on_map (GtkWidget *w)
 773 {
 774   GtkClipboard *clip = gtk_widget_get_clipboard (w, GDK_SELECTION_CLIPBOARD);
 775
 776   g_signal_connect (clip, "owner-change", G_CALLBACK (on_owner_change), w);
 777 }
 778
 779
 780 static void
 781 init_sheet (PsppireDataEditor *de, int i,
 782             GtkAdjustment *hadj, GtkAdjustment *vadj)
 783 {
 784   PsppireAxisHetero *haxis = psppire_axis_hetero_new ();
 785   PsppireAxisUniform *vaxis = psppire_axis_uniform_new ();
 786   de->sheet_bin[i] = gtk_scrolled_window_new (hadj, vadj);
 787
 788   de->data_sheet[i] = gtk_sheet_new (NULL);
 789
 790   g_object_set (de->sheet_bin[i],
 791                 "border-width", 3,
 792                 "shadow-type",  GTK_SHADOW_ETCHED_IN,
 793                 NULL);
 794
 795   g_object_set (haxis, "default-size", 75, NULL);
 796   g_object_set (vaxis, "default-size", 25, NULL);
 797
 798   g_object_set (de->data_sheet[i],
 799                 "horizontal-axis", haxis,
 800                 "vertical-axis", vaxis,
 801                 NULL);
 802
 803   gtk_container_add (GTK_CONTAINER (de->sheet_bin[i]), de->data_sheet[i]);
 804
 805   g_signal_connect (de->data_sheet[i], "traverse",
 806                     G_CALLBACK (traverse_cell_callback), de);
 807
 808   gtk_widget_show (de->sheet_bin[i]);
 809 }
 810
 811
 812 static void
 813 init_data_sheet (PsppireDataEditor *de)
 814 {
 815   GtkAdjustment *va0, *ha0;
 816   GtkAdjustment *va1, *ha1;
 817   GtkWidget *sheet ;
 818
 819   de->split = TRUE;
 820   de->paned = gtk_xpaned_new ();
 821
 822   init_sheet (de, 0, NULL, NULL);
 823   gtk_widget_show (de->sheet_bin[0]);
 824   va0 = gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (de->sheet_bin[0]));
 825   ha0 = gtk_scrolled_window_get_hadjustment (GTK_SCROLLED_WINDOW (de->sheet_bin[0]));
 826
 827   g_object_set (de->sheet_bin[0], "vscrollbar-policy", GTK_POLICY_NEVER, NULL);
 828   g_object_set (de->sheet_bin[0], "hscrollbar-policy", GTK_POLICY_NEVER, NULL);
 829
 830   init_sheet (de, 1, NULL, va0);
 831   gtk_widget_show (de->sheet_bin[1]);
 832   sheet = gtk_bin_get_child (GTK_BIN (de->sheet_bin[1]));
 833   gtk_sheet_hide_row_titles (GTK_SHEET (sheet));
 834   ha1 = gtk_scrolled_window_get_hadjustment (GTK_SCROLLED_WINDOW (de->sheet_bin[1]));
 835   g_object_set (de->sheet_bin[1], "vscrollbar-policy", GTK_POLICY_ALWAYS, NULL);
 836   g_object_set (de->sheet_bin[1], "hscrollbar-policy", GTK_POLICY_NEVER, NULL);
 837
 838   init_sheet (de, 2, ha0, NULL);
 839   gtk_widget_show (de->sheet_bin[2]);
 840   sheet = gtk_bin_get_child (GTK_BIN (de->sheet_bin[2]));
 841   gtk_sheet_hide_column_titles (GTK_SHEET (sheet));
 842   g_object_set (de->sheet_bin[2], "vscrollbar-policy", GTK_POLICY_NEVER, NULL);
 843   g_object_set (de->sheet_bin[2], "hscrollbar-policy", GTK_POLICY_ALWAYS, NULL);
 844   va1 = gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (de->sheet_bin[2]));
 845
 846   init_sheet (de, 3, ha1, va1);
 847   gtk_widget_show (de->sheet_bin[3]);
 848   sheet = gtk_bin_get_child (GTK_BIN (de->sheet_bin[3]));
 849   gtk_sheet_hide_column_titles (GTK_SHEET (sheet));
 850   gtk_sheet_hide_row_titles (GTK_SHEET (sheet));
 851   g_object_set (de->sheet_bin[3], "vscrollbar-policy", GTK_POLICY_ALWAYS, NULL);
 852   g_object_set (de->sheet_bin[3], "hscrollbar-policy", GTK_POLICY_ALWAYS, NULL);
 853
 854   gtk_xpaned_pack_top_left (GTK_XPANED (de->paned), de->sheet_bin[0], TRUE, TRUE);
 855   gtk_xpaned_pack_top_right (GTK_XPANED (de->paned), de->sheet_bin[1], TRUE, TRUE);
 856   gtk_xpaned_pack_bottom_left (GTK_XPANED (de->paned), de->sheet_bin[2], TRUE, TRUE);
 857   gtk_xpaned_pack_bottom_right (GTK_XPANED (de->paned), de->sheet_bin[3], TRUE, TRUE);
 858
 859   gtk_xpaned_set_position_y (GTK_XPANED (de->paned), 150);
 860   gtk_xpaned_set_position_x (GTK_XPANED (de->paned), 350);
 861 }
 862
 863
 864 static void
 865 psppire_data_editor_init (PsppireDataEditor *de)
 866 {
 867   GtkWidget *hbox = gtk_hbox_new (FALSE, 0);
 868   GtkWidget *sw_vs = gtk_scrolled_window_new (NULL, NULL);
 869
 870   init_data_sheet (de);
 871
 872   de->data_vbox = gtk_vbox_new (FALSE, 0);
 873   de->var_sheet = psppire_var_sheet_new ();
 874
 875   g_object_set (de, "tab-pos", GTK_POS_BOTTOM, NULL);
 876
 877   de->datum_entry = gtk_entry_new ();
 878   de->cell_ref_entry = gtk_entry_new ();
 879
 880   g_object_set (de->cell_ref_entry,
 881                 "sensitive", FALSE,
 882                 "editable",  FALSE,
 883                 "width_chars", 25,
 884                 NULL);
 885
 886   gtk_box_pack_start (GTK_BOX (hbox), de->cell_ref_entry, FALSE, FALSE, 0);
 887   gtk_box_pack_start (GTK_BOX (hbox), de->datum_entry, TRUE, TRUE, 0);
 888
 889
 890   gtk_container_add (GTK_CONTAINER (sw_vs), de->var_sheet);
 891   gtk_widget_show_all (sw_vs);
 892
 893
 894   gtk_box_pack_start (GTK_BOX (de->data_vbox), hbox, FALSE, FALSE, 0);
 895   gtk_box_pack_start (GTK_BOX (de->data_vbox), de->paned, TRUE, TRUE, 0);
 896
 897
 898   psppire_data_editor_remove_split (de);
 899
 900   gtk_widget_show_all (de->data_vbox);
 901
 902   gtk_notebook_append_page (GTK_NOTEBOOK (de), de->data_vbox,
 903                             gtk_label_new_with_mnemonic (_("Data View")));
 904
 905   gtk_notebook_append_page (GTK_NOTEBOOK (de), sw_vs,
 906                             gtk_label_new_with_mnemonic (_("Variable View")));
 907
 908   g_signal_connect (de->data_sheet[0], "activate",
 909                     G_CALLBACK (update_data_ref_entry),
 910                     de);
 911
 912   g_signal_connect (de->datum_entry, "activate",
 913                     G_CALLBACK (datum_entry_activate),
 914                     de);
 915
 916
 917   g_signal_connect_swapped (de->data_sheet[0],
 918                     "double-click-column",
 919                     G_CALLBACK (on_data_column_clicked),
 920                     de);
 921
 922   g_signal_connect_swapped (de->var_sheet,
 923                     "double-click-row",
 924                     G_CALLBACK (on_var_row_clicked),
 925                     de);
 926
 927   g_signal_connect_swapped (de->data_sheet[0], "activate",
 928                             G_CALLBACK (on_activate),
 929                             de);
 930
 931   g_signal_connect_swapped (de->data_sheet[0], "select-range",
 932                             G_CALLBACK (on_select_range),
 933                             de);
 934
 935   g_signal_connect (de->data_sheet[0], "select-row",
 936                     G_CALLBACK (on_select_row), de);
 937
 938   g_signal_connect (de->data_sheet[0], "select-column",
 939                     G_CALLBACK (on_select_variable), de);
 940
 941
 942   g_signal_connect (de->var_sheet, "select-row",
 943                     G_CALLBACK (on_select_variable), de);
 944
 945
 946   g_signal_connect_after (de, "switch-page",
 947                     G_CALLBACK (on_switch_page),
 948                     NULL);
 949
 950
 951   g_signal_connect (de, "map", G_CALLBACK (on_map), NULL);
 952
 953
 954
 955   //     gtk_sheet_hide_column_titles (de->var_sheet);
 956   //  gtk_sheet_hide_row_titles (de->data_sheet);
 957
 958
 959   de->dispose_has_run = FALSE;
 960 }
 961
 962
 963 GtkWidget*
 964 psppire_data_editor_new (PsppireVarStore *var_store,
 965                          PsppireDataStore *data_store)
 966 {
 967   return  g_object_new (PSPPIRE_DATA_EDITOR_TYPE,
 968                                      "var-store",  var_store,
 969                                      "data-store",  data_store,
 970                                      NULL);
 971 }
 972
 973
 974 static void
 975 psppire_data_editor_remove_split (PsppireDataEditor *de)
 976 {
 977   if ( !de->split ) return;
 978   de->split = FALSE;
 979
 980   g_object_ref (de->sheet_bin[0]);
 981   gtk_container_remove (GTK_CONTAINER (de->paned), de->sheet_bin[0]);
 982
 983   g_object_ref (de->paned);
 984   gtk_container_remove (GTK_CONTAINER (de->data_vbox), de->paned);
 985
 986   gtk_box_pack_start (GTK_BOX (de->data_vbox), de->sheet_bin[0],
 987                       TRUE, TRUE, 0);
 988
 989   g_object_unref (de->sheet_bin[0]);
 990
 991   g_object_set (de->sheet_bin[0], "vscrollbar-policy",
 992                 GTK_POLICY_ALWAYS, NULL);
 993
 994   g_object_set (de->sheet_bin[0], "hscrollbar-policy",
 995                 GTK_POLICY_ALWAYS, NULL);
 996 }
 997
 998
 999 static void
1000 psppire_data_editor_set_split (PsppireDataEditor *de)
1001 {
1002   if ( de->split ) return;
1003   de->split = TRUE;
1004
1005   g_object_ref (de->sheet_bin[0]);
1006   gtk_container_remove (GTK_CONTAINER (de->data_vbox), de->sheet_bin[0]);
1007
1008   gtk_xpaned_pack_top_left (GTK_XPANED (de->paned), de->sheet_bin [0],
1009                             TRUE, TRUE);
1010
1011   gtk_box_pack_start (GTK_BOX (de->data_vbox), de->paned,
1012                       TRUE, TRUE, 0);
1013
1014   g_object_unref (de->paned);
1015
1016   g_object_set (de->sheet_bin[0], "vscrollbar-policy",
1017                 GTK_POLICY_NEVER, NULL);
1018
1019   g_object_set (de->sheet_bin[0], "hscrollbar-policy",
1020                 GTK_POLICY_NEVER, NULL);
1021 }
1022
1023 void
1024 psppire_data_editor_split_window (PsppireDataEditor *de, gboolean split)
1025 {
1026   if (split )
1027     psppire_data_editor_set_split (de);
1028   else
1029     psppire_data_editor_remove_split (de);
1030
1031   gtk_widget_show_all (de->data_vbox);
1032 }
1033
1034 static void data_sheet_set_clip (GtkSheet *sheet);
1035 static void data_sheet_contents_received_callback (GtkClipboard *clipboard,
1036                                                    GtkSelectionData *sd,
1037                                                    gpointer data);
1038
1039
1040 void
1041 psppire_data_editor_clip_copy (PsppireDataEditor *de)
1042 {
1043   data_sheet_set_clip (GTK_SHEET (de->data_sheet[0]));
1044 }
1045
1046 void
1047 psppire_data_editor_clip_paste (PsppireDataEditor *de)
1048 {
1049   GdkDisplay *display = gtk_widget_get_display ( GTK_WIDGET (de));
1050   GtkClipboard *clipboard =
1051     gtk_clipboard_get_for_display (display, GDK_SELECTION_CLIPBOARD);
1052
1053   gtk_clipboard_request_contents (clipboard,
1054                                   gdk_atom_intern ("UTF8_STRING", TRUE),
1055                                   data_sheet_contents_received_callback,
1056                                   de);
1057 }
1058
1059
1060
1061 void
1062 psppire_data_editor_clip_cut (PsppireDataEditor *de)
1063 {
1064   gint max_rows, max_columns;
1065   gint r;
1066   GtkSheetRange range;
1067   PsppireDataStore *ds = de->data_store;
1068
1069   data_sheet_set_clip (GTK_SHEET (de->data_sheet[0]));
1070
1071   /* Now blank all the cells */
1072   gtk_sheet_get_selected_range (GTK_SHEET (de->data_sheet[0]), &range);
1073
1074    /* If nothing selected, then use active cell */
1075   if ( range.row0 < 0 || range.col0 < 0 )
1076     {
1077       gint row, col;
1078       gtk_sheet_get_active_cell (GTK_SHEET (de->data_sheet[0]), &row, &col);
1079
1080       range.row0 = range.rowi = row;
1081       range.col0 = range.coli = col;
1082     }
1083
1084   /* The sheet range can include cells that do not include data.
1085      Exclude them from the range. */
1086   max_rows = psppire_data_store_get_case_count (ds);
1087   if (range.rowi >= max_rows)
1088     {
1089       if (max_rows == 0)
1090         return;
1091       range.rowi = max_rows - 1;
1092     }
1093
1094   max_columns = dict_get_var_cnt (ds->dict->dict);
1095   if (range.coli >= max_columns)
1096     {
1097       if (max_columns == 0)
1098         return;
1099       range.coli = max_columns - 1;
1100     }
1101
1102   g_return_if_fail (range.rowi >= range.row0);
1103   g_return_if_fail (range.row0 >= 0);
1104   g_return_if_fail (range.coli >= range.col0);
1105   g_return_if_fail (range.col0 >= 0);
1106
1107
1108   for (r = range.row0; r <= range.rowi ; ++r )
1109     {
1110       gint c;
1111
1112       for (c = range.col0 ; c <= range.coli; ++c)
1113         {
1114           psppire_data_store_set_string (ds, "", r, c);
1115         }
1116     }
1117
1118   /* and remove the selection */
1119   gtk_sheet_unselect_range (GTK_SHEET (de->data_sheet[0]));
1120 }
1121
1122
1123 \f
1124
1125 /* Popup menu related stuff */
1126
1127 static void
1128 popup_variable_column_menu (GtkSheet *sheet, gint column,
1129                      GdkEventButton *event, gpointer data)
1130 {
1131   GtkMenu *menu = GTK_MENU (data);
1132
1133   PsppireDataStore *data_store =
1134     PSPPIRE_DATA_STORE (gtk_sheet_get_model (sheet));
1135
1136   const struct variable *v =
1137     psppire_dict_get_variable (data_store->dict, column);
1138
1139   if ( v && event->button == 3)
1140     {
1141       gtk_sheet_select_column (sheet, column);
1142
1143       gtk_menu_popup (menu,
1144                       NULL, NULL, NULL, NULL,
1145                       event->button, event->time);
1146     }
1147 }
1148
1149
1150 static void
1151 popup_variable_row_menu (GtkSheet *sheet, gint row,
1152                      GdkEventButton *event, gpointer data)
1153 {
1154   GtkMenu *menu = GTK_MENU (data);
1155
1156   PsppireVarStore *var_store =
1157     PSPPIRE_VAR_STORE (gtk_sheet_get_model (sheet));
1158
1159   const struct variable *v =
1160     psppire_dict_get_variable (var_store->dict, row);
1161
1162   if ( v && event->button == 3)
1163     {
1164       gtk_sheet_select_row (sheet, row);
1165
1166       gtk_menu_popup (menu,
1167                       NULL, NULL, NULL, NULL,
1168                       event->button, event->time);
1169     }
1170 }
1171
1172
1173 static void
1174 popup_cases_menu (GtkSheet *sheet, gint row,
1175                   GdkEventButton *event, gpointer data)
1176 {
1177   GtkMenu *menu = GTK_MENU (data);
1178
1179   PsppireDataStore *data_store =
1180     PSPPIRE_DATA_STORE (gtk_sheet_get_model (sheet));
1181
1182   if ( row <= psppire_data_store_get_case_count (data_store) &&
1183        event->button == 3)
1184     {
1185       gtk_sheet_select_row (sheet, row);
1186
1187       gtk_menu_popup (menu,
1188                       NULL, NULL, NULL, NULL,
1189                       event->button, event->time);
1190     }
1191 }
1192
1193 \f
1194
1195 /* Sorting */
1196
1197 static void
1198 do_sort (PsppireDataStore *ds, int var, gboolean descend)
1199 {
1200   GString *string = g_string_new ("SORT CASES BY ");
1201
1202   const struct variable *v =
1203     psppire_dict_get_variable (ds->dict, var);
1204
1205   g_string_append_printf (string, "%s", var_get_name (v));
1206
1207   if ( descend )
1208     g_string_append (string, " (D)");
1209
1210   g_string_append (string, ".");
1211
1212   execute_syntax (create_syntax_string_source (string->str));
1213
1214   g_string_free (string, TRUE);
1215 }
1216
1217
1218 /* Sort the data by the the variable which the editor has currently
1219    selected */
1220 void
1221 psppire_data_editor_sort_ascending  (PsppireDataEditor *de)
1222 {
1223   GtkSheetRange range;
1224   gtk_sheet_get_selected_range (GTK_SHEET(de->data_sheet[0]), &range);
1225
1226   do_sort (de->data_store,  range.col0, FALSE);
1227 }
1228
1229
1230 /* Sort the data by the the variable which the editor has currently
1231    selected */
1232 void
1233 psppire_data_editor_sort_descending (PsppireDataEditor *de)
1234 {
1235   GtkSheetRange range;
1236   gtk_sheet_get_selected_range (GTK_SHEET(de->data_sheet[0]), &range);
1237
1238   do_sort (de->data_store,  range.col0, TRUE);
1239 }
1240
1241
1242 \f
1243
1244
1245 /* Insert a new variable  before the currently selected position */
1246 void
1247 psppire_data_editor_insert_variable (PsppireDataEditor *de)
1248 {
1249   glong posn = 0;
1250
1251   switch (gtk_notebook_get_current_page (GTK_NOTEBOOK (de)))
1252     {
1253     case PSPPIRE_DATA_EDITOR_DATA_VIEW:
1254       if ( de->data_sheet[0]->state == GTK_SHEET_COLUMN_SELECTED )
1255         posn = GTK_SHEET (de->data_sheet[0])->range.col0;
1256       else
1257         posn = GTK_SHEET (de->data_sheet[0])->active_cell.col;
1258       break;
1259     case PSPPIRE_DATA_EDITOR_VARIABLE_VIEW:
1260       if ( de->var_sheet->state == GTK_SHEET_ROW_SELECTED )
1261         posn = GTK_SHEET (de->var_sheet)->range.row0;
1262       else
1263         posn = GTK_SHEET (de->var_sheet)->active_cell.row;
1264       break;
1265     default:
1266       g_assert_not_reached ();
1267       break;
1268     };
1269
1270   psppire_dict_insert_variable (de->data_store->dict, posn, NULL);
1271 }
1272
1273 /* Insert a new case before the currently selected position */
1274 void
1275 psppire_data_editor_insert_case (PsppireDataEditor *de)
1276 {
1277   glong posn = -1;
1278
1279   if ( de->data_sheet[0]->state == GTK_SHEET_ROW_SELECTED )
1280     posn = GTK_SHEET (de->data_sheet[0])->range.row0;
1281   else
1282     posn = GTK_SHEET (de->data_sheet[0])->active_cell.row;
1283
1284   if ( posn == -1 ) posn = 0;
1285
1286   psppire_data_store_insert_new_case (de->data_store, posn);
1287 }
1288
1289 /* Delete the cases currently selected in the data sheet */
1290 void
1291 psppire_data_editor_delete_cases    (PsppireDataEditor *de)
1292 {
1293   gint first = GTK_SHEET (de->data_sheet[0])->range.row0;
1294   gint n = GTK_SHEET (de->data_sheet[0])->range.rowi - first + 1;
1295
1296   psppire_data_store_delete_cases (de->data_store, first, n);
1297
1298   gtk_sheet_unselect_range (GTK_SHEET (de->data_sheet[0]));
1299 }
1300
1301 /* Delete the variables currently selected in the
1302    datasheet or variable sheet */
1303 void
1304 psppire_data_editor_delete_variables (PsppireDataEditor *de)
1305 {
1306   gint first, n;
1307
1308   switch (gtk_notebook_get_current_page (GTK_NOTEBOOK (de)))
1309     {
1310     case PSPPIRE_DATA_EDITOR_DATA_VIEW:
1311       first = GTK_SHEET (de->data_sheet[0])->range.col0;
1312       n = GTK_SHEET (de->data_sheet[0])->range.coli - first + 1;
1313       break;
1314     case PSPPIRE_DATA_EDITOR_VARIABLE_VIEW:
1315       first = GTK_SHEET (de->var_sheet)->range.row0;
1316       n = GTK_SHEET (de->var_sheet)->range.rowi - first + 1;
1317       break;
1318     default:
1319       g_assert_not_reached ();
1320       break;
1321     }
1322
1323   psppire_dict_delete_variables (de->var_store->dict, first, n);
1324
1325   gtk_sheet_unselect_range (GTK_SHEET (de->data_sheet[0]));
1326   gtk_sheet_unselect_range (GTK_SHEET (de->var_sheet));
1327 }
1328
1329
1330 void
1331 psppire_data_editor_show_grid (PsppireDataEditor *de, gboolean grid_visible)
1332 {
1333   gtk_sheet_show_grid (GTK_SHEET (de->var_sheet), grid_visible);
1334   gtk_sheet_show_grid (GTK_SHEET (de->data_sheet[0]), grid_visible);
1335 }
1336
1337
1338 static void
1339 set_font (GtkWidget *w, gpointer data)
1340 {
1341   PangoFontDescription *font_desc = data;
1342   GtkRcStyle *style = gtk_widget_get_modifier_style (w);
1343
1344   pango_font_description_free (style->font_desc);
1345   style->font_desc = pango_font_description_copy (font_desc);
1346
1347   gtk_widget_modify_style (w, style);
1348
1349   if ( GTK_IS_CONTAINER (w))
1350     gtk_container_foreach (GTK_CONTAINER (w), set_font, font_desc);
1351 }
1352
1353 void
1354 psppire_data_editor_set_font (PsppireDataEditor *de, PangoFontDescription *font_desc)
1355 {
1356   set_font (GTK_WIDGET (de), font_desc);
1357   gtk_container_foreach (GTK_CONTAINER (de), set_font, font_desc);
1358 }
1359
1360
1361 \f
1362
1363
1364 static void
1365 emit_selected_signal (PsppireDataEditor *de)
1366 {
1367   gboolean data_selected = data_is_selected (de);
1368
1369   g_signal_emit (de, data_editor_signals[DATA_SELECTION_CHANGED], 0, data_selected);
1370 }
1371
1372
1373 static void
1374 on_activate (PsppireDataEditor *de)
1375 {
1376   gint row, col;
1377   gtk_sheet_get_active_cell (GTK_SHEET (de->data_sheet[0]), &row, &col);
1378
1379
1380   if ( row < psppire_data_store_get_case_count (de->data_store)
1381        &&
1382        col < psppire_var_store_get_var_cnt (de->var_store))
1383     {
1384       emit_selected_signal (de);
1385       return ;
1386     }
1387
1388   emit_selected_signal (de);
1389 }
1390
1391
1392 static void
1393 on_select_range (PsppireDataEditor *de)
1394 {
1395   GtkSheetRange range;
1396
1397   gtk_sheet_get_selected_range (GTK_SHEET (de->data_sheet[0]), &range);
1398
1399   if ( range.rowi < psppire_data_store_get_case_count (de->data_store)
1400        &&
1401        range.coli < psppire_var_store_get_var_cnt (de->var_store))
1402     {
1403       emit_selected_signal (de);
1404       return;
1405     }
1406
1407   emit_selected_signal (de);
1408 }
1409
1410
1411 static gboolean
1412 on_switch_page (PsppireDataEditor *de, GtkNotebookPage *p,
1413                 gint pagenum, gpointer data)
1414 {
1415   if ( pagenum != PSPPIRE_DATA_EDITOR_DATA_VIEW )
1416     {
1417       emit_selected_signal (de);
1418       return TRUE;
1419     }
1420
1421   on_select_range (de);
1422
1423   return TRUE;
1424 }
1425
1426
1427
1428 static gboolean
1429 data_is_selected (PsppireDataEditor *de)
1430 {
1431   GtkSheetRange range;
1432   gint row, col;
1433
1434   if ( gtk_notebook_get_current_page (GTK_NOTEBOOK (de)) != PSPPIRE_DATA_EDITOR_DATA_VIEW)
1435     return FALSE;
1436
1437   gtk_sheet_get_active_cell (GTK_SHEET (de->data_sheet[0]), &row, &col);
1438
1439   if ( row >= psppire_data_store_get_case_count (de->data_store)
1440        ||
1441        col >= psppire_var_store_get_var_cnt (de->var_store))
1442     {
1443       return FALSE;
1444     }
1445
1446   gtk_sheet_get_selected_range (GTK_SHEET (de->data_sheet[0]), &range);
1447
1448   if ( range.rowi >= psppire_data_store_get_case_count (de->data_store)
1449        ||
1450        range.coli >= psppire_var_store_get_var_cnt (de->var_store))
1451     {
1452       return FALSE;
1453     }
1454
1455   return TRUE;
1456 }
1457
1458
1459 static void
1460 on_select_row (GtkSheet *sheet, gint row, PsppireDataEditor *de)
1461 {
1462   g_signal_emit (de, data_editor_signals[CASES_SELECTED], 0, row);
1463 }
1464
1465
1466 static void
1467 on_select_variable (GtkSheet *sheet, gint var, PsppireDataEditor *de)
1468 {
1469   g_signal_emit (de, data_editor_signals[VARIABLES_SELECTED], 0, var);
1470 }
1471
1472
1473 \f
1474
1475 /* Clipboard stuff */
1476
1477
1478 #include <data/casereader.h>
1479 #include <data/case-map.h>
1480 #include <data/casewriter.h>
1481
1482 #include <data/data-out.h>
1483 #include "xalloc.h"
1484
1485 /* A casereader and dictionary holding the data currently in the clip */
1486 static struct casereader *clip_datasheet = NULL;
1487 static struct dictionary *clip_dict = NULL;
1488
1489
1490 static void data_sheet_update_clipboard (GtkSheet *);
1491
1492 /* Set the clip according to the currently
1493    selected range in the data sheet */
1494 static void
1495 data_sheet_set_clip (GtkSheet *sheet)
1496 {
1497   int i;
1498   struct casewriter *writer ;
1499   GtkSheetRange range;
1500   PsppireDataStore *ds;
1501   struct case_map *map = NULL;
1502   casenumber max_rows;
1503   size_t max_columns;
1504
1505   ds = PSPPIRE_DATA_STORE (gtk_sheet_get_model (sheet));
1506
1507   gtk_sheet_get_selected_range (sheet, &range);
1508
1509    /* If nothing selected, then use active cell */
1510   if ( range.row0 < 0 || range.col0 < 0 )
1511     {
1512       gint row, col;
1513       gtk_sheet_get_active_cell (sheet, &row, &col);
1514
1515       range.row0 = range.rowi = row;
1516       range.col0 = range.coli = col;
1517     }
1518
1519   /* The sheet range can include cells that do not include data.
1520      Exclude them from the range. */
1521   max_rows = psppire_data_store_get_case_count (ds);
1522   if (range.rowi >= max_rows)
1523     {
1524       if (max_rows == 0)
1525         return;
1526       range.rowi = max_rows - 1;
1527     }
1528   max_columns = dict_get_var_cnt (ds->dict->dict);
1529   if (range.coli >= max_columns)
1530     {
1531       if (max_columns == 0)
1532         return;
1533       range.coli = max_columns - 1;
1534     }
1535
1536   g_return_if_fail (range.rowi >= range.row0);
1537   g_return_if_fail (range.row0 >= 0);
1538   g_return_if_fail (range.coli >= range.col0);
1539   g_return_if_fail (range.col0 >= 0);
1540
1541   /* Destroy any existing clip */
1542   if ( clip_datasheet )
1543     {
1544       casereader_destroy (clip_datasheet);
1545       clip_datasheet = NULL;
1546     }
1547
1548   if ( clip_dict )
1549     {
1550       dict_destroy (clip_dict);
1551       clip_dict = NULL;
1552     }
1553
1554   /* Construct clip dictionary. */
1555   clip_dict = dict_create ();
1556   for (i = range.col0; i <= range.coli; i++)
1557     {
1558       const struct variable *old = dict_get_var (ds->dict->dict, i);
1559       dict_clone_var_assert (clip_dict, old, var_get_name (old));
1560     }
1561
1562   /* Construct clip data. */
1563   map = case_map_by_name (ds->dict->dict, clip_dict);
1564   writer = autopaging_writer_create (dict_get_next_value_idx (clip_dict));
1565   for (i = range.row0; i <= range.rowi ; ++i )
1566     {
1567       struct ccase old;
1568
1569       if (psppire_data_store_get_case (ds, i, &old))
1570         {
1571           struct ccase new;
1572
1573           case_map_execute (map, &old, &new);
1574           case_destroy (&old);
1575           casewriter_write (writer, &new);
1576         }
1577       else
1578         casewriter_force_error (writer);
1579     }
1580   case_map_destroy (map);
1581
1582   clip_datasheet = casewriter_make_reader (writer);
1583
1584   data_sheet_update_clipboard (sheet);
1585 }
1586
1587 enum {
1588   SELECT_FMT_NULL,
1589   SELECT_FMT_TEXT,
1590   SELECT_FMT_HTML
1591 };
1592
1593
1594 /* Perform data_out for case CC, variable V, appending to STRING */
1595 static void
1596 data_out_g_string (GString *string, const struct variable *v,
1597                    const struct ccase *cc)
1598 {
1599   char *buf ;
1600
1601   const struct fmt_spec *fs = var_get_print_format (v);
1602   const union value *val = case_data (cc, v);
1603   buf = xzalloc (fs->w);
1604
1605   data_out (val, fs, buf);
1606
1607   g_string_append_len (string, buf, fs->w);
1608
1609   g_free (buf);
1610 }
1611
1612 static GString *
1613 clip_to_text (void)
1614 {
1615   casenumber r;
1616   GString *string;
1617
1618   const size_t val_cnt = casereader_get_value_cnt (clip_datasheet);
1619   const casenumber case_cnt = casereader_get_case_cnt (clip_datasheet);
1620   const size_t var_cnt = dict_get_var_cnt (clip_dict);
1621
1622   string = g_string_sized_new (10 * val_cnt * case_cnt);
1623
1624   for (r = 0 ; r < case_cnt ; ++r )
1625     {
1626       int c;
1627       struct ccase cc;
1628       if ( !  casereader_peek (clip_datasheet, r, &cc))
1629         {
1630           g_warning ("Clipboard seems to have inexplicably shrunk");
1631           break;
1632         }
1633
1634       for (c = 0 ; c < var_cnt ; ++c)
1635         {
1636           const struct variable *v = dict_get_var (clip_dict, c);
1637           data_out_g_string (string, v, &cc);
1638           if ( c < val_cnt - 1 )
1639             g_string_append (string, "\t");
1640         }
1641
1642       if ( r < case_cnt)
1643         g_string_append (string, "\n");
1644
1645       case_destroy (&cc);
1646     }
1647
1648   return string;
1649 }
1650
1651
1652 static GString *
1653 clip_to_html (void)
1654 {
1655   casenumber r;
1656   GString *string;
1657
1658   const size_t val_cnt = casereader_get_value_cnt (clip_datasheet);
1659   const casenumber case_cnt = casereader_get_case_cnt (clip_datasheet);
1660   const size_t var_cnt = dict_get_var_cnt (clip_dict);
1661
1662
1663   /* Guestimate the size needed */
1664   string = g_string_sized_new (20 * val_cnt * case_cnt);
1665
1666   g_string_append (string, "<table>\n");
1667   for (r = 0 ; r < case_cnt ; ++r )
1668     {
1669       int c;
1670       struct ccase cc;
1671       if ( !  casereader_peek (clip_datasheet, r, &cc))
1672         {
1673           g_warning ("Clipboard seems to have inexplicably shrunk");
1674           break;
1675         }
1676       g_string_append (string, "<tr>\n");
1677
1678       for (c = 0 ; c < var_cnt ; ++c)
1679         {
1680           const struct variable *v = dict_get_var (clip_dict, c);
1681           g_string_append (string, "<td>");
1682           data_out_g_string (string, v, &cc);
1683           g_string_append (string, "</td>\n");
1684         }
1685
1686       g_string_append (string, "</tr>\n");
1687
1688       case_destroy (&cc);
1689     }
1690   g_string_append (string, "</table>\n");
1691
1692   return string;
1693 }
1694
1695
1696
1697 static void
1698 clipboard_get_cb (GtkClipboard     *clipboard,
1699                   GtkSelectionData *selection_data,
1700                   guint             info,
1701                   gpointer          data)
1702 {
1703   GString *string = NULL;
1704
1705   switch (info)
1706     {
1707     case SELECT_FMT_TEXT:
1708       string = clip_to_text ();
1709       break;
1710     case SELECT_FMT_HTML:
1711       string = clip_to_html ();
1712       break;
1713     default:
1714       g_assert_not_reached ();
1715     }
1716
1717   gtk_selection_data_set (selection_data, selection_data->target,
1718                           8,
1719                           (const guchar *) string->str, string->len);
1720
1721   g_string_free (string, TRUE);
1722 }
1723
1724 static void
1725 clipboard_clear_cb (GtkClipboard *clipboard,
1726                     gpointer data)
1727 {
1728   dict_destroy (clip_dict);
1729   clip_dict = NULL;
1730
1731   casereader_destroy (clip_datasheet);
1732   clip_datasheet = NULL;
1733 }
1734
1735
1736 static const GtkTargetEntry targets[] = {
1737   { "UTF8_STRING",   0, SELECT_FMT_TEXT },
1738   { "STRING",        0, SELECT_FMT_TEXT },
1739   { "TEXT",          0, SELECT_FMT_TEXT },
1740   { "COMPOUND_TEXT", 0, SELECT_FMT_TEXT },
1741   { "text/plain;charset=utf-8", 0, SELECT_FMT_TEXT },
1742   { "text/plain",    0, SELECT_FMT_TEXT },
1743   { "text/html",     0, SELECT_FMT_HTML }
1744 };
1745
1746
1747
1748 static void
1749 data_sheet_update_clipboard (GtkSheet *sheet)
1750 {
1751   GtkClipboard *clipboard =
1752     gtk_widget_get_clipboard (GTK_WIDGET (sheet),
1753                               GDK_SELECTION_CLIPBOARD);
1754
1755   if (!gtk_clipboard_set_with_owner (clipboard, targets,
1756                                      G_N_ELEMENTS (targets),
1757                                      clipboard_get_cb, clipboard_clear_cb,
1758                                      G_OBJECT (sheet)))
1759     clipboard_clear_cb (clipboard, sheet);
1760 }
1761
1762
1763
1764 /* A callback for when the clipboard contents have been received */
1765 static void
1766 data_sheet_contents_received_callback (GtkClipboard *clipboard,
1767                                       GtkSelectionData *sd,
1768                                       gpointer data)
1769 {
1770   gint count = 0;
1771   gint row, column;
1772   gint next_row, next_column;
1773   gint first_column;
1774   char *c;
1775   PsppireDataEditor *data_editor = data;
1776
1777   if ( sd->length < 0 )
1778     return;
1779
1780   if ( sd->type != gdk_atom_intern ("UTF8_STRING", FALSE))
1781     return;
1782
1783   c = (char *) sd->data;
1784
1785   /* Paste text to selected position */
1786   gtk_sheet_get_active_cell (GTK_SHEET (data_editor->data_sheet[0]),
1787                              &row, &column);
1788
1789   g_return_if_fail (row >= 0);
1790   g_return_if_fail (column >= 0);
1791
1792   first_column = column;
1793   next_row = row;
1794   next_column = column;
1795   while (count < sd->length)
1796     {
1797       char *s = c;
1798
1799       row = next_row;
1800       column = next_column;
1801       while (*c != '\t' && *c != '\n' && count < sd->length)
1802         {
1803           c++;
1804           count++;
1805         }
1806       if ( *c == '\t')
1807         {
1808           next_row = row ;
1809           next_column = column + 1;
1810         }
1811       else if ( *c == '\n')
1812         {
1813           next_row = row + 1;
1814           next_column = first_column;
1815         }
1816       *c++ = '\0';
1817       count++;
1818
1819
1820       /* Append some new cases if pasting beyond the last row */
1821       if ( row >= psppire_data_store_get_case_count (data_editor->data_store))
1822         psppire_data_store_insert_new_case (data_editor->data_store, row);
1823
1824       psppire_data_store_set_string (data_editor->data_store, s, row, column);
1825     }
1826 }
1827
1828
1829 static void
1830 on_owner_change (GtkClipboard *clip, GdkEventOwnerChange *event, gpointer data)
1831 {
1832   gint i;
1833   gboolean compatible_target = FALSE;
1834   PsppireDataEditor *de = PSPPIRE_DATA_EDITOR (data);
1835
1836   for (i = 0 ; i < sizeof (targets) / sizeof(targets[0]) ; ++i )
1837     {
1838       GdkAtom atom = gdk_atom_intern (targets[i].target, TRUE);
1839       if ( gtk_clipboard_wait_is_target_available (clip, atom))
1840         {
1841           compatible_target = TRUE;
1842           break;
1843         }
1844     }
1845
1846   g_signal_emit (de, data_editor_signals[DATA_AVAILABLE_CHANGED], 0,
1847                  compatible_target);
1848 }
1849
1850