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