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