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