src/ui/gui/data-editor.c

   1 /* PSPPIRE - a graphical user interface for PSPP.
   2    Copyright (C) 2006, 2007  Free Software Foundation
   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 <stdlib.h>
  19 #include <gettext.h>
  20
  21 #include <glade/glade.h>
  22 #include <gtk/gtk.h>
  23
  24 #include "window-manager.h"
  25 #include <gtksheet/gtksheet.h>
  26
  27 #include "helper.h"
  28 #include "about.h"
  29 #include <data/procedure.h>
  30 #include "psppire-dialog.h"
  31 #include "psppire-selector.h"
  32 #include "weight-cases-dialog.h"
  33 #include "split-file-dialog.h"
  34 #include "transpose-dialog.h"
  35 #include "sort-cases-dialog.h"
  36 #include "select-cases-dialog.h"
  37 #include "compute-dialog.h"
  38 #include "goto-case-dialog.h"
  39 #include "find-dialog.h"
  40 #include "comments-dialog.h"
  41 #include "variable-info-dialog.h"
  42 #include "dict-display.h"
  43 #include "clipboard.h"
  44
  45 #define _(msgid) gettext (msgid)
  46 #define N_(msgid) msgid
  47
  48 #include "data-editor.h"
  49 #include "syntax-editor.h"
  50 #include <language/syntax-string-source.h>
  51 #include <language/command.h>
  52 #include <libpspp/syntax-gen.h>
  53 #include "window-manager.h"
  54
  55 #include "psppire-data-store.h"
  56 #include "psppire-var-store.h"
  57
  58 static void on_edit_copy (GtkMenuItem *, gpointer);
  59 static void on_edit_cut (GtkMenuItem *, gpointer);
  60 static void on_edit_paste (GtkAction *a, gpointer data);
  61
  62
  63 static void create_data_sheet_variable_popup_menu (struct data_editor *);
  64 static void create_data_sheet_cases_popup_menu (struct data_editor *);
  65
  66 static void popup_variable_menu (GtkSheet *, gint,
  67                                  GdkEventButton *, gpointer data);
  68
  69 static void popup_cases_menu (GtkSheet *, gint,
  70                                  GdkEventButton *, gpointer data);
  71
  72 /* Update the data_ref_entry with the reference of the active cell */
  73 static gint update_data_ref_entry (const GtkSheet *sheet,
  74                                    gint row, gint col, gpointer data);
  75
  76 static void register_data_editor_actions (struct data_editor *de);
  77
  78 static void insert_variable (GtkAction *, gpointer data);
  79 static void insert_case (GtkAction *a, gpointer data);
  80 static void delete_cases (GtkAction *a, gpointer data);
  81 static void delete_variables (GtkAction *a, gpointer data);
  82
  83 static void toggle_value_labels (GtkToggleAction *a, gpointer data);
  84
  85 /* Switch between the VAR SHEET and the DATA SHEET */
  86
  87 static gboolean click2column (GtkWidget *w, gint col, gpointer data);
  88 static gboolean click2row (GtkWidget *w, gint row, gpointer data);
  89
  90
  91 /* Callback for when the dictionary changes properties*/
  92 static void on_weight_change (GObject *, gint, gpointer);
  93 static void on_filter_change (GObject *, gint, gpointer);
  94 static void on_split_change (PsppireDict *, gpointer);
  95
  96 static void on_switch_sheet (GtkNotebook *notebook,
  97                             GtkNotebookPage *page,
  98                             guint page_num,
  99                             gpointer user_data);
 100
 101 static void status_bar_activate (GtkCheckMenuItem *, gpointer);
 102
 103 static void grid_lines_activate (GtkCheckMenuItem *, gpointer);
 104
 105 static void data_sheet_activate (GtkCheckMenuItem *, gpointer);
 106
 107 static void variable_sheet_activate (GtkCheckMenuItem *, gpointer );
 108
 109 static void fonts_activate (GtkMenuItem *, gpointer);
 110
 111 static void file_quit (GtkCheckMenuItem *, gpointer );
 112
 113 static void
 114 enable_delete_cases (GtkWidget *w, gint var, gpointer data)
 115 {
 116   struct data_editor *de = data;
 117
 118   gtk_action_set_visible (de->delete_cases, var != -1);
 119 }
 120
 121
 122 static void
 123 enable_delete_variables (GtkWidget *w, gint var, gpointer data)
 124 {
 125   struct data_editor *de = data;
 126
 127   gtk_action_set_visible (de->delete_variables, var != -1);
 128 }
 129
 130
 131
 132 /* Run the EXECUTE command. */
 133 static void
 134 execute (GtkMenuItem *mi, gpointer data)
 135 {
 136   struct getl_interface *sss = create_syntax_string_source ("EXECUTE.");
 137
 138   execute_syntax (sss);
 139 }
 140
 141 static void
 142 transformation_change_callback (bool transformations_pending,
 143                                 gpointer data)
 144 {
 145   struct data_editor *de = data;
 146   GtkWidget *menuitem =
 147     get_widget_assert (de->xml, "transform_run-pending");
 148   GtkWidget *status_label  =
 149     get_widget_assert (de->xml, "case-counter-area");
 150
 151   gtk_widget_set_sensitive (menuitem, transformations_pending);
 152
 153
 154   if ( transformations_pending)
 155     gtk_label_set_text (GTK_LABEL (status_label),
 156                         _("Transformations Pending"));
 157   else
 158     gtk_label_set_text (GTK_LABEL (status_label), "");
 159 }
 160
 161
 162 static void open_data_file (const gchar *, struct data_editor *);
 163
 164
 165 /* Puts FILE_NAME into the recent list.
 166    If it's already in the list, it moves it to the top
 167 */
 168 static void
 169 add_most_recent (const char *file_name)
 170 {
 171 #if RECENT_LISTS_AVAILABLE
 172
 173   GtkRecentManager *manager = gtk_recent_manager_get_default();
 174   gchar *uri = g_filename_to_uri (file_name, NULL, NULL);
 175
 176   gtk_recent_manager_remove_item (manager, uri, NULL);
 177
 178   if ( ! gtk_recent_manager_add_item (manager, uri))
 179     g_warning ("Could not add item %s to recent list\n",uri);
 180
 181   g_free (uri);
 182 #endif
 183 }
 184
 185
 186
 187 #if RECENT_LISTS_AVAILABLE
 188
 189 static void
 190 on_recent_data_select (GtkMenuShell *menushell,   gpointer user_data)
 191 {
 192   gchar *file;
 193   struct data_editor *de = user_data;
 194
 195   gchar *uri =
 196     gtk_recent_chooser_get_current_uri (GTK_RECENT_CHOOSER (menushell));
 197
 198   file = g_filename_from_uri (uri, NULL, NULL);
 199
 200   g_free (uri);
 201
 202   open_data_file (file, de);
 203
 204   g_free (file);
 205 }
 206
 207 static void
 208 on_recent_files_select (GtkMenuShell *menushell,   gpointer user_data)
 209 {
 210   gchar *file;
 211
 212   struct syntax_editor *se ;
 213
 214   gchar *uri =
 215     gtk_recent_chooser_get_current_uri (GTK_RECENT_CHOOSER (menushell));
 216
 217   file = g_filename_from_uri (uri, NULL, NULL);
 218
 219   g_free (uri);
 220
 221   se = (struct syntax_editor *)
 222     window_create (WINDOW_SYNTAX, file);
 223
 224   load_editor_from_file (se, file, NULL);
 225
 226   g_free (file);
 227 }
 228
 229 #endif
 230
 231 static void
 232 datum_entry_activate (GtkEntry *entry, gpointer data)
 233 {
 234   gint row, column;
 235   GtkSheet *data_sheet = GTK_SHEET (data);
 236   PsppireDataStore *store = PSPPIRE_DATA_STORE (gtk_sheet_get_model (data_sheet));
 237
 238   const char *text = gtk_entry_get_text (entry);
 239
 240   gtk_sheet_get_active_cell (data_sheet, &row, &column);
 241
 242   if ( row == -1 || column == -1)
 243     return;
 244
 245   psppire_data_store_set_string (store, text, row, column);
 246 }
 247
 248
 249 /* Update the Edit->Paste menuitem
 250    If PAGE is not -1 , then it should be set to the current page of
 251    the data editors notebook widget.
 252    If -1, then it'll be queried.
 253 */
 254 static void
 255 update_paste_menuitem (struct data_editor *de, gint page)
 256 {
 257   GtkWidget * edit_paste = get_widget_assert (de->xml, "edit_paste");
 258   GtkWidget *notebook = get_widget_assert (de->xml, "notebook");
 259   GtkSheet * data_sheet ;
 260   gint row, column;
 261
 262   if ( page < 0 )
 263     page = gtk_notebook_get_current_page (GTK_NOTEBOOK(notebook));
 264
 265
 266   if ( PAGE_VAR_SHEET == page )
 267     {
 268       /* We don't yet support pasting to the var sheet */
 269       gtk_widget_set_sensitive (edit_paste, FALSE);
 270       return;
 271     }
 272
 273   data_sheet = GTK_SHEET (get_widget_assert (de->xml, "data_sheet"));
 274
 275   gtk_sheet_get_active_cell (data_sheet, &row, &column);
 276
 277   if ( row < 0 || column < 0 )
 278       gtk_widget_set_sensitive (edit_paste, FALSE);
 279   else
 280       gtk_widget_set_sensitive (edit_paste, TRUE);
 281 }
 282
 283 /* Update the Edit->Cut and Edit->Copy menuitems
 284    If PAGE is not -1 , then it should be set to the current page of
 285    the data editors notebook widget.
 286    If -1, then it'll be queried.
 287 */
 288 static void
 289 update_cut_copy_menuitem (struct data_editor *de, gint page)
 290 {
 291   GtkWidget * edit_copy = get_widget_assert (de->xml, "edit_copy");
 292   GtkWidget * edit_cut = get_widget_assert (de->xml, "edit_cut");
 293   GtkWidget *notebook = get_widget_assert (de->xml, "notebook");
 294   GtkSheet * data_sheet ;
 295   gint row, column;
 296
 297   if ( page < 0 )
 298     page = gtk_notebook_get_current_page (GTK_NOTEBOOK(notebook));
 299
 300
 301   if ( PAGE_VAR_SHEET == page )
 302     {
 303       /* We don't yet support copying from the var sheet */
 304       gtk_widget_set_sensitive (edit_copy, FALSE);
 305       gtk_widget_set_sensitive (edit_cut, FALSE);
 306       return;
 307     }
 308
 309   data_sheet = GTK_SHEET (get_widget_assert (de->xml, "data_sheet"));
 310
 311   gtk_sheet_get_active_cell (data_sheet, &row, &column);
 312
 313   if ( row < 0 || column < 0 )
 314     {
 315       gtk_widget_set_sensitive (edit_copy, FALSE);
 316       gtk_widget_set_sensitive (edit_cut, FALSE);
 317       return;
 318     }
 319
 320   gtk_widget_set_sensitive (edit_copy, TRUE);
 321   gtk_widget_set_sensitive (edit_cut, TRUE);
 322 }
 323
 324
 325 /* Callback for when the datasheet's active cell becomes active/inactive */
 326 static gboolean
 327 on_data_sheet_activate_change (GtkSheet *sheet,
 328                                gint row, gint column, gpointer data)
 329 {
 330   struct data_editor *de = data;
 331
 332   update_paste_menuitem (de, -1);
 333   update_cut_copy_menuitem (de, -1);
 334
 335   return TRUE;
 336 }
 337
 338 extern struct dataset *the_dataset;
 339
 340 /*
 341   Create a new data editor.
 342 */
 343 struct data_editor *
 344 new_data_editor (void)
 345 {
 346   struct data_editor *de ;
 347   struct editor_window *e;
 348   GtkSheet *var_sheet ;
 349   GtkSheet *data_sheet ;
 350   PsppireVarStore *vs;
 351   GtkWidget *datum_entry;
 352
 353   de = g_malloc0 (sizeof (*de));
 354
 355   e = (struct editor_window *) de;
 356
 357   de->xml = XML_NEW ("data-editor.glade");
 358
 359
 360   dataset_add_transform_change_callback (the_dataset,
 361                                          transformation_change_callback,
 362                                          de);
 363
 364   var_sheet = GTK_SHEET (get_widget_assert (de->xml, "variable_sheet"));
 365   data_sheet = GTK_SHEET (get_widget_assert (de->xml, "data_sheet"));
 366
 367
 368   g_signal_connect (G_OBJECT (data_sheet), "activate",
 369                     G_CALLBACK (on_data_sheet_activate_change), de);
 370
 371   g_signal_connect (G_OBJECT (data_sheet), "deactivate",
 372                     G_CALLBACK (on_data_sheet_activate_change), de);
 373
 374
 375   vs = PSPPIRE_VAR_STORE (gtk_sheet_get_model (var_sheet));
 376
 377   g_assert(vs); /* Traps a possible bug in win32 build */
 378
 379   g_signal_connect (G_OBJECT (data_sheet), "activate",
 380                     G_CALLBACK (update_data_ref_entry),
 381                     de->xml);
 382
 383   datum_entry = get_widget_assert (de->xml, "datum_entry");
 384
 385   g_signal_connect (G_OBJECT (datum_entry), "activate",
 386                     G_CALLBACK (datum_entry_activate),
 387                     data_sheet);
 388
 389   g_signal_connect (vs->dict, "weight-changed",
 390                     G_CALLBACK (on_weight_change),
 391                     de);
 392
 393   g_signal_connect (vs->dict, "filter-changed",
 394                     G_CALLBACK (on_filter_change),
 395                     de);
 396
 397   g_signal_connect (vs->dict, "split-changed",
 398                     G_CALLBACK (on_split_change),
 399                     de);
 400
 401   connect_help (de->xml);
 402
 403
 404
 405   g_signal_connect (get_widget_assert (de->xml, "edit_copy"),
 406                     "activate",
 407                     G_CALLBACK (on_edit_copy), de);
 408
 409   g_signal_connect (get_widget_assert (de->xml, "edit_cut"),
 410                     "activate",
 411                     G_CALLBACK (on_edit_cut), de);
 412
 413
 414   register_data_editor_actions (de);
 415
 416   de->toggle_value_labels =
 417     gtk_toggle_action_new ("toggle-value-labels",
 418                            _("Labels"),
 419                            _("Show/hide value labels"),
 420                            "pspp-value-labels");
 421
 422   g_signal_connect (de->toggle_value_labels, "activate",
 423                     G_CALLBACK (toggle_value_labels), de);
 424
 425
 426   gtk_action_connect_proxy (GTK_ACTION (de->toggle_value_labels),
 427                             get_widget_assert (de->xml,
 428                                                "togglebutton-value-labels"));
 429
 430
 431   gtk_action_connect_proxy (GTK_ACTION (de->toggle_value_labels),
 432                             get_widget_assert (de->xml,
 433                                                "view_value-labels"));
 434
 435   de->delete_cases =
 436     gtk_action_new ("clear-cases",
 437                     _("Clear"),
 438                     _("Delete the cases at the selected position(s)"),
 439                     "pspp-clear-cases");
 440
 441   g_signal_connect (de->delete_cases, "activate",
 442                     G_CALLBACK (delete_cases), de);
 443
 444   gtk_action_connect_proxy (de->delete_cases,
 445                             get_widget_assert (de->xml, "edit_clear-cases"));
 446
 447   g_signal_connect (get_widget_assert (de->xml, "edit_paste"), "activate",
 448                     G_CALLBACK (on_edit_paste), de);
 449
 450   gtk_action_set_visible (de->delete_cases, FALSE);
 451
 452   de->delete_variables =
 453     gtk_action_new ("clear-variables",
 454                     _("Clear"),
 455                     _("Delete the variables at the selected position(s)"),
 456                     "pspp-clear-variables");
 457
 458   g_signal_connect (de->delete_variables, "activate",
 459                     G_CALLBACK (delete_variables), de);
 460
 461   gtk_action_connect_proxy (de->delete_variables,
 462                             get_widget_assert (de->xml, "edit_clear-variables")
 463                             );
 464
 465   gtk_action_set_visible (de->delete_variables, FALSE);
 466
 467   de->insert_variable =
 468     gtk_action_new ("insert-variable",
 469                     _("Insert Variable"),
 470                     _("Create a new variable at the current position"),
 471                     "pspp-insert-variable");
 472
 473   g_signal_connect (de->insert_variable, "activate",
 474                     G_CALLBACK (insert_variable), de);
 475
 476
 477   gtk_action_connect_proxy (de->insert_variable,
 478                             get_widget_assert (de->xml, "button-insert-variable")
 479                             );
 480
 481   gtk_action_connect_proxy (de->insert_variable,
 482                             get_widget_assert (de->xml, "edit_insert-variable")
 483                             );
 484
 485
 486   de->insert_case =
 487     gtk_action_new ("insert-case",
 488                     _("Insert Case"),
 489                     _("Create a new case at the current position"),
 490                     "pspp-insert-case");
 491
 492   g_signal_connect (de->insert_case, "activate",
 493                     G_CALLBACK (insert_case), de);
 494
 495
 496   gtk_action_connect_proxy (de->insert_case,
 497                             get_widget_assert (de->xml, "button-insert-case")
 498                             );
 499
 500
 501   gtk_action_connect_proxy (de->insert_case,
 502                             get_widget_assert (de->xml, "edit_insert-case")
 503                             );
 504
 505
 506
 507   de->invoke_goto_dialog =
 508     gtk_action_new ("goto-case-dialog",
 509                     _("Goto Case"),
 510                     _("Jump to a Case in the Data Sheet"),
 511                     "gtk-jump-to");
 512
 513
 514   gtk_action_connect_proxy (de->invoke_goto_dialog,
 515                             get_widget_assert (de->xml, "button-goto-case")
 516                             );
 517
 518   gtk_action_connect_proxy (de->invoke_goto_dialog,
 519                             get_widget_assert (de->xml, "edit_goto-case")
 520                             );
 521
 522
 523   g_signal_connect (de->invoke_goto_dialog, "activate",
 524                     G_CALLBACK (goto_case_dialog), de);
 525
 526
 527   de->invoke_weight_cases_dialog =
 528     gtk_action_new ("weight-cases-dialog",
 529                     _("Weights"),
 530                     _("Weight cases by variable"),
 531                     "pspp-weight-cases");
 532
 533   g_signal_connect (de->invoke_weight_cases_dialog, "activate",
 534                     G_CALLBACK (weight_cases_dialog), de);
 535
 536
 537   de->invoke_transpose_dialog =
 538     gtk_action_new ("transpose-dialog",
 539                     _("Transpose"),
 540                     _("Transpose the cases with the variables"),
 541                     NULL);
 542
 543
 544   g_signal_connect (de->invoke_transpose_dialog, "activate",
 545                     G_CALLBACK (transpose_dialog), de);
 546
 547
 548
 549   de->invoke_split_file_dialog =
 550     gtk_action_new ("split-file-dialog",
 551                     _("Split"),
 552                     _("Split the active file"),
 553                     "pspp-split-file");
 554
 555   g_signal_connect (de->invoke_split_file_dialog, "activate",
 556                     G_CALLBACK (split_file_dialog), de);
 557
 558
 559
 560   de->invoke_sort_cases_dialog =
 561     gtk_action_new ("sort-cases-dialog",
 562                     _("Sort"),
 563                     _("Sort cases in the active file"),
 564                     "pspp-sort-cases");
 565
 566   g_signal_connect (de->invoke_sort_cases_dialog, "activate",
 567                     G_CALLBACK (sort_cases_dialog), de);
 568
 569   de->invoke_select_cases_dialog =
 570     gtk_action_new ("select-cases-dialog",
 571                     _("Select Cases"),
 572                     _("Select cases from the active file"),
 573                     "pspp-select-cases");
 574
 575   g_signal_connect (de->invoke_select_cases_dialog, "activate",
 576                     G_CALLBACK (select_cases_dialog), de);
 577
 578
 579   de->invoke_compute_dialog =
 580     gtk_action_new ("compute-dialog",
 581                     _("Compute"),
 582                     _("Compute new values for a variable"),
 583                     "pspp-compute");
 584
 585   g_signal_connect (de->invoke_compute_dialog, "activate",
 586                     G_CALLBACK (compute_dialog), de);
 587
 588   de->invoke_comments_dialog =
 589     gtk_action_new ("commments-dialog",
 590                     _("Data File Comments"),
 591                     _("Commentary text for the data file"),
 592                     NULL);
 593
 594   g_signal_connect (de->invoke_comments_dialog, "activate",
 595                     G_CALLBACK (comments_dialog), de);
 596
 597   de->invoke_find_dialog  =
 598     gtk_action_new ("find-dialog",
 599                     _("Find"),
 600                     _("Find Case"),
 601                     "gtk-find");
 602
 603   g_signal_connect (de->invoke_find_dialog, "activate",
 604                     G_CALLBACK (find_dialog), de);
 605
 606
 607   de->invoke_variable_info_dialog  =
 608     gtk_action_new ("variable-info-dialog",
 609                     _("Variables"),
 610                     _("Jump to Variable"),
 611                     "pspp-goto-variable");
 612
 613   g_signal_connect (de->invoke_variable_info_dialog, "activate",
 614                     G_CALLBACK (variable_info_dialog), de);
 615
 616   e->window = GTK_WINDOW (get_widget_assert (de->xml, "data_editor"));
 617
 618   g_signal_connect_swapped (get_widget_assert (de->xml,"file_new_data"),
 619                             "activate",
 620                             G_CALLBACK (gtk_action_activate),
 621                             de->action_data_new);
 622
 623   g_signal_connect_swapped (get_widget_assert (de->xml,"file_open_data"),
 624                             "activate",
 625                             G_CALLBACK (gtk_action_activate),
 626                             de->action_data_open);
 627
 628
 629 #if RECENT_LISTS_AVAILABLE
 630   {
 631     GtkRecentManager *rm = gtk_recent_manager_get_default ();
 632     GtkWidget *recent_data = get_widget_assert (de->xml, "file_recent-data");
 633     GtkWidget *recent_files = get_widget_assert (de->xml, "file_recent-files");
 634     GtkWidget *recent_separator = get_widget_assert (de->xml, "file_separator1");
 635
 636     GtkWidget *menu = gtk_recent_chooser_menu_new_for_manager (rm);
 637
 638     GtkRecentFilter *filter = gtk_recent_filter_new ();
 639
 640     gtk_widget_show (recent_data);
 641     gtk_widget_show (recent_files);
 642     gtk_widget_show (recent_separator);
 643
 644     gtk_recent_filter_add_pattern (filter, "*.sav");
 645     gtk_recent_filter_add_pattern (filter, "*.SAV");
 646
 647     gtk_recent_chooser_add_filter (GTK_RECENT_CHOOSER (menu), filter);
 648
 649     gtk_widget_set_sensitive (recent_data, TRUE);
 650     g_signal_connect (menu, "selection-done",
 651                       G_CALLBACK (on_recent_data_select), de);
 652
 653     gtk_menu_item_set_submenu (GTK_MENU_ITEM (recent_data), menu);
 654
 655
 656     filter = gtk_recent_filter_new ();
 657     menu = gtk_recent_chooser_menu_new_for_manager (rm);
 658
 659     gtk_recent_filter_add_pattern (filter, "*.sps");
 660     gtk_recent_filter_add_pattern (filter, "*.SPS");
 661
 662     gtk_recent_chooser_add_filter (GTK_RECENT_CHOOSER (menu), filter);
 663
 664     gtk_widget_set_sensitive (recent_files, TRUE);
 665     g_signal_connect (menu, "selection-done",
 666                       G_CALLBACK (on_recent_files_select), de);
 667
 668     gtk_menu_item_set_submenu (GTK_MENU_ITEM (recent_files), menu);
 669   }
 670 #endif
 671
 672   g_signal_connect (get_widget_assert (de->xml,"file_new_syntax"),
 673                     "activate",
 674                     G_CALLBACK (new_syntax_window),
 675                     e->window);
 676
 677   g_signal_connect (get_widget_assert (de->xml,"file_open_syntax"),
 678                     "activate",
 679                     G_CALLBACK (open_syntax_window),
 680                     e->window);
 681
 682   g_signal_connect_swapped (get_widget_assert (de->xml,"file_save"),
 683                             "activate",
 684                             G_CALLBACK (gtk_action_activate),
 685                             de->action_data_save);
 686
 687   g_signal_connect_swapped (get_widget_assert (de->xml,"file_save_as"),
 688                             "activate",
 689                             G_CALLBACK (gtk_action_activate),
 690                             de->action_data_save_as);
 691
 692   gtk_action_connect_proxy (de->invoke_find_dialog,
 693                             get_widget_assert (de->xml, "edit_find")
 694                             );
 695
 696   gtk_action_connect_proxy (de->invoke_find_dialog,
 697                             get_widget_assert (de->xml, "button-find")
 698                             );
 699
 700   gtk_action_connect_proxy (de->invoke_weight_cases_dialog,
 701                             get_widget_assert (de->xml, "data_weight-cases")
 702                             );
 703
 704   gtk_action_connect_proxy (de->invoke_transpose_dialog,
 705                             get_widget_assert (de->xml, "data_transpose")
 706                             );
 707
 708   gtk_action_connect_proxy (de->invoke_split_file_dialog,
 709                             get_widget_assert (de->xml, "data_split-file")
 710                             );
 711
 712   gtk_action_connect_proxy (de->invoke_sort_cases_dialog,
 713                             get_widget_assert (de->xml, "data_sort-cases")
 714                             );
 715
 716   gtk_action_connect_proxy (de->invoke_select_cases_dialog,
 717                             get_widget_assert (de->xml, "data_select-cases")
 718                             );
 719
 720   gtk_action_connect_proxy (de->invoke_compute_dialog,
 721                             get_widget_assert (de->xml, "transform_compute")
 722                             );
 723
 724   gtk_action_connect_proxy (de->invoke_comments_dialog,
 725                             get_widget_assert (de->xml, "utilities_comments")
 726                             );
 727
 728   gtk_action_connect_proxy (de->invoke_variable_info_dialog,
 729                             get_widget_assert (de->xml, "utilities_variables")
 730                             );
 731
 732   g_signal_connect (get_widget_assert (de->xml,"help_about"),
 733                     "activate",
 734                     G_CALLBACK (about_new),
 735                     e->window);
 736
 737
 738   g_signal_connect (get_widget_assert (de->xml,"help_reference"),
 739                     "activate",
 740                     G_CALLBACK (reference_manual),
 741                     e->window);
 742
 743   g_signal_connect (data_sheet,
 744                     "double-click-column",
 745                     G_CALLBACK (click2column),
 746                     de);
 747
 748   g_signal_connect (data_sheet,
 749                     "select-column",
 750                     G_CALLBACK (enable_delete_variables),
 751                     de);
 752
 753   g_signal_connect (data_sheet,
 754                     "select-row",
 755                     G_CALLBACK (enable_delete_cases),
 756                     de);
 757
 758
 759   g_signal_connect (var_sheet,
 760                     "double-click-row",
 761                     GTK_SIGNAL_FUNC (click2row),
 762                     de);
 763
 764   g_signal_connect_after (var_sheet,
 765                     "select-row",
 766                     G_CALLBACK (enable_delete_variables),
 767                     de);
 768
 769   g_signal_connect (get_widget_assert (de->xml, "notebook"),
 770                     "switch-page",
 771                     G_CALLBACK (on_switch_sheet), de);
 772
 773
 774   g_signal_connect (get_widget_assert (de->xml, "view_statusbar"),
 775                     "activate",
 776                     G_CALLBACK (status_bar_activate), de);
 777
 778
 779   g_signal_connect (get_widget_assert (de->xml, "view_gridlines"),
 780                     "activate",
 781                     G_CALLBACK (grid_lines_activate), de);
 782
 783
 784
 785   g_signal_connect (get_widget_assert (de->xml, "view_data"),
 786                     "activate",
 787                     G_CALLBACK (data_sheet_activate), de);
 788
 789   g_signal_connect (get_widget_assert (de->xml, "view_variables"),
 790                     "activate",
 791                     G_CALLBACK (variable_sheet_activate), de);
 792
 793
 794
 795   g_signal_connect (get_widget_assert (de->xml, "view_fonts"),
 796                     "activate",
 797                     G_CALLBACK (fonts_activate), de);
 798
 799
 800
 801
 802   gtk_action_connect_proxy (de->action_data_open,
 803                             get_widget_assert (de->xml, "button-open")
 804                             );
 805
 806   gtk_action_connect_proxy (de->action_data_save,
 807                             get_widget_assert (de->xml, "button-save")
 808                             );
 809
 810   gtk_action_connect_proxy (de->invoke_variable_info_dialog,
 811                             get_widget_assert (de->xml, "button-goto-variable")
 812                             );
 813
 814   gtk_action_connect_proxy (de->invoke_weight_cases_dialog,
 815                             get_widget_assert (de->xml, "button-weight-cases")
 816                             );
 817
 818   gtk_action_connect_proxy (de->invoke_split_file_dialog,
 819                             get_widget_assert (de->xml, "button-split-file")
 820                             );
 821
 822   gtk_action_connect_proxy (de->invoke_select_cases_dialog,
 823                             get_widget_assert (de->xml, "button-select-cases")
 824                             );
 825
 826
 827   g_signal_connect (get_widget_assert (de->xml, "file_quit"),
 828                     "activate",
 829                     G_CALLBACK (file_quit), de);
 830
 831   g_signal_connect (get_widget_assert (de->xml, "transform_run-pending"),
 832                     "activate",
 833                     G_CALLBACK (execute), de);
 834
 835
 836   g_signal_connect (get_widget_assert (de->xml, "windows_minimise_all"),
 837                     "activate",
 838                     G_CALLBACK (minimise_all_windows), NULL);
 839
 840
 841   create_data_sheet_variable_popup_menu (de);
 842   create_data_sheet_cases_popup_menu (de);
 843
 844   g_signal_connect (G_OBJECT (data_sheet), "button-event-column",
 845                     G_CALLBACK (popup_variable_menu), de);
 846
 847   g_signal_connect (G_OBJECT (data_sheet), "button-event-row",
 848                     G_CALLBACK (popup_cases_menu), de);
 849
 850   return de;
 851 }
 852
 853
 854 /* Callback which occurs when the var sheet's row title
 855    button is double clicked */
 856 static gboolean
 857 click2row (GtkWidget *w, gint row, gpointer data)
 858 {
 859   struct data_editor *de = data;
 860   GtkSheetRange visible_range;
 861
 862   gint current_row, current_column;
 863
 864   GtkWidget *data_sheet  = get_widget_assert (de->xml, "data_sheet");
 865
 866   data_editor_select_sheet (de, PAGE_DATA_SHEET);
 867
 868   gtk_sheet_get_active_cell (GTK_SHEET (data_sheet),
 869                              &current_row, &current_column);
 870
 871   gtk_sheet_set_active_cell (GTK_SHEET (data_sheet), current_row, row);
 872
 873   gtk_sheet_get_visible_range (GTK_SHEET (data_sheet), &visible_range);
 874
 875   if ( row < visible_range.col0 || row > visible_range.coli)
 876     {
 877       gtk_sheet_moveto (GTK_SHEET (data_sheet),
 878                         current_row, row, 0, 0);
 879     }
 880
 881   return FALSE;
 882 }
 883
 884
 885 /* Callback which occurs when the data sheet's column title
 886    is double clicked */
 887 static gboolean
 888 click2column (GtkWidget *w, gint col, gpointer data)
 889 {
 890   struct data_editor *de = data;
 891
 892   gint current_row, current_column;
 893
 894   GtkWidget *var_sheet  = get_widget_assert (de->xml, "variable_sheet");
 895
 896   data_editor_select_sheet (de, PAGE_VAR_SHEET);
 897
 898   gtk_sheet_get_active_cell (GTK_SHEET (var_sheet),
 899                              &current_row, &current_column);
 900
 901   gtk_sheet_set_active_cell (GTK_SHEET (var_sheet), col, current_column);
 902
 903   return FALSE;
 904 }
 905
 906
 907 void
 908 new_data_window (GtkMenuItem *menuitem, gpointer parent)
 909 {
 910   window_create (WINDOW_DATA, NULL);
 911 }
 912
 913 /* Callback for when the datasheet/varsheet is selected */
 914 static void
 915 on_switch_sheet (GtkNotebook *notebook,
 916                 GtkNotebookPage *page,
 917                 guint page_num,
 918                 gpointer user_data)
 919 {
 920   struct data_editor *de = user_data;
 921
 922   GtkWidget *view_data = get_widget_assert (de->xml, "view_data");
 923   GtkWidget *view_variables = get_widget_assert (de->xml, "view_variables");
 924
 925   switch (page_num)
 926     {
 927     case PAGE_VAR_SHEET:
 928       gtk_widget_hide (view_variables);
 929       gtk_widget_show (view_data);
 930       gtk_action_set_sensitive (de->insert_variable, TRUE);
 931       gtk_action_set_sensitive (de->insert_case, FALSE);
 932       gtk_action_set_sensitive (de->invoke_goto_dialog, FALSE);
 933       break;
 934     case PAGE_DATA_SHEET:
 935       gtk_widget_show (view_variables);
 936       gtk_widget_show (view_data);
 937       gtk_action_set_sensitive (de->invoke_goto_dialog, TRUE);
 938       gtk_action_set_sensitive (de->insert_case, TRUE);
 939       break;
 940     default:
 941       g_assert_not_reached ();
 942       break;
 943     }
 944
 945   update_paste_menuitem (de, page_num);
 946   update_cut_copy_menuitem (de, page_num);
 947 }
 948
 949
 950 void
 951 data_editor_select_sheet (struct data_editor *de, gint page)
 952 {
 953   gtk_notebook_set_current_page
 954    (
 955     GTK_NOTEBOOK (get_widget_assert (de->xml,"notebook")), page
 956     );
 957 }
 958
 959
 960
 961 static void
 962 status_bar_activate (GtkCheckMenuItem *menuitem, gpointer data)
 963 {
 964   struct data_editor *de = data;
 965   GtkWidget *statusbar = get_widget_assert (de->xml, "status-bar");
 966
 967   if ( gtk_check_menu_item_get_active (menuitem) )
 968     gtk_widget_show (statusbar);
 969   else
 970     gtk_widget_hide (statusbar);
 971 }
 972
 973
 974 static void
 975 grid_lines_activate (GtkCheckMenuItem *menuitem, gpointer data)
 976 {
 977   struct data_editor *de = data;
 978   const bool grid_visible = gtk_check_menu_item_get_active (menuitem);
 979
 980   gtk_sheet_show_grid (GTK_SHEET (get_widget_assert (de->xml,
 981                                                      "variable_sheet")),
 982                        grid_visible);
 983
 984   gtk_sheet_show_grid (GTK_SHEET (get_widget_assert (de->xml, "data_sheet")),
 985                        grid_visible);
 986 }
 987
 988
 989
 990 static void
 991 data_sheet_activate (GtkCheckMenuItem *menuitem, gpointer data)
 992 {
 993   struct data_editor *de = data;
 994
 995   data_editor_select_sheet (de, PAGE_DATA_SHEET);
 996 }
 997
 998
 999 static void
1000 variable_sheet_activate (GtkCheckMenuItem *menuitem, gpointer data)
1001 {
1002   struct data_editor *de = data;
1003
1004   data_editor_select_sheet (de, PAGE_VAR_SHEET);
1005 }
1006
1007
1008 static void
1009 fonts_activate (GtkMenuItem *menuitem, gpointer data)
1010 {
1011   struct data_editor *de = data;
1012   GtkWidget *dialog =
1013     gtk_font_selection_dialog_new (_("Font Selection"));
1014
1015   gtk_window_set_transient_for (GTK_WINDOW (dialog),
1016                                 GTK_WINDOW (get_widget_assert (de->xml,
1017                                                                "data_editor")));
1018   if ( GTK_RESPONSE_OK == gtk_dialog_run (GTK_DIALOG (dialog)) )
1019     {
1020       GtkSheet *data_sheet =
1021         GTK_SHEET (get_widget_assert (de->xml, "data_sheet"));
1022
1023       GtkSheet *var_sheet =
1024         GTK_SHEET (get_widget_assert (de->xml, "variable_sheet"));
1025
1026       PsppireDataStore *ds = PSPPIRE_DATA_STORE (gtk_sheet_get_model (data_sheet));
1027       PsppireVarStore *vs = PSPPIRE_VAR_STORE (gtk_sheet_get_model (var_sheet));
1028
1029       const gchar *font = gtk_font_selection_dialog_get_font_name
1030         (GTK_FONT_SELECTION_DIALOG (dialog));
1031
1032       PangoFontDescription* font_desc =
1033         pango_font_description_from_string (font);
1034
1035       psppire_var_store_set_font (vs, font_desc);
1036       psppire_data_store_set_font (ds, font_desc);
1037     }
1038
1039   gtk_widget_hide (dialog);
1040 }
1041
1042
1043
1044 /* Callback for the value labels action */
1045 static void
1046 toggle_value_labels (GtkToggleAction *ta, gpointer data)
1047 {
1048   struct data_editor *de = data;
1049
1050   GtkSheet *data_sheet = GTK_SHEET (get_widget_assert (de->xml, "data_sheet"));
1051
1052   PsppireDataStore *ds = PSPPIRE_DATA_STORE (gtk_sheet_get_model (data_sheet));
1053
1054
1055   psppire_data_store_show_labels (ds,
1056                                   gtk_toggle_action_get_active (ta));
1057 }
1058
1059
1060 static void
1061 file_quit (GtkCheckMenuItem *menuitem, gpointer data)
1062 {
1063   /* FIXME: Need to be more intelligent here.
1064      Give the user the opportunity to save any unsaved data.
1065   */
1066   gtk_main_quit ();
1067 }
1068
1069 static void
1070 delete_cases (GtkAction *action, gpointer data)
1071 {
1072   struct data_editor *de = data;
1073   GtkSheet *data_sheet =
1074     GTK_SHEET (get_widget_assert (de->xml, "data_sheet"));
1075
1076   GtkSheetRange range;
1077
1078   PsppireDataStore *data_store = PSPPIRE_DATA_STORE
1079     (gtk_sheet_get_model (data_sheet) );
1080
1081
1082   /* This shouldn't be able to happen, because the action
1083      should be disabled */
1084   g_return_if_fail (gtk_sheet_get_state (data_sheet)
1085                     ==  GTK_SHEET_ROW_SELECTED );
1086
1087   gtk_sheet_get_selected_range (data_sheet, &range);
1088
1089   gtk_sheet_unselect_range (data_sheet);
1090
1091   psppire_data_store_delete_cases (data_store, range.row0,
1092                                    1 + range.rowi - range.row0);
1093
1094 }
1095
1096 static void
1097 delete_variables (GtkAction *a, gpointer data)
1098 {
1099   struct data_editor *de = data;
1100   GtkSheetRange range;
1101
1102   GtkNotebook *notebook = GTK_NOTEBOOK (get_widget_assert (de->xml,
1103                                                            "notebook"));
1104
1105   const gint page = gtk_notebook_get_current_page (notebook);
1106
1107   GtkSheet *sheet = GTK_SHEET (get_widget_assert (de->xml,
1108                                                   (page == PAGE_VAR_SHEET) ?
1109                                                   "variable_sheet" :
1110                                                   "data_sheet"));
1111
1112
1113   gtk_sheet_get_selected_range (sheet, &range);
1114
1115   switch ( page )
1116     {
1117     case PAGE_VAR_SHEET:
1118       {
1119         PsppireVarStore *vs =
1120           PSPPIRE_VAR_STORE (gtk_sheet_get_model (sheet));
1121
1122         psppire_dict_delete_variables (vs->dict,
1123                                        range.row0,
1124                                        1 +
1125                                        range.rowi -
1126                                        range.row0 );
1127       }
1128       break;
1129     case PAGE_DATA_SHEET:
1130       {
1131         PsppireDataStore *ds =
1132           PSPPIRE_DATA_STORE (gtk_sheet_get_model (sheet));
1133
1134         psppire_dict_delete_variables (ds->dict,
1135                                        range.col0,
1136                                        1 +
1137                                        range.coli -
1138                                        range.col0 );
1139       }
1140       break;
1141     };
1142
1143   gtk_sheet_unselect_range (sheet);
1144 }
1145
1146 static void
1147 insert_case (GtkAction *action, gpointer data)
1148 {
1149   gint current_row ;
1150   struct data_editor *de = data;
1151
1152   GtkSheet *data_sheet =
1153     GTK_SHEET (get_widget_assert (de->xml, "data_sheet"));
1154
1155   PsppireDataStore *ds = PSPPIRE_DATA_STORE
1156     (gtk_sheet_get_model (data_sheet) );
1157
1158
1159   gtk_sheet_get_active_cell (data_sheet, &current_row, NULL);
1160
1161   if (current_row < 0) current_row = 0;
1162
1163   psppire_data_store_insert_new_case (ds, current_row);
1164 }
1165
1166 /* Insert a new variable before the current row in the variable sheet,
1167    or before the current column in the data sheet, whichever is selected */
1168 static void
1169 insert_variable (GtkAction *action, gpointer data)
1170 {
1171   struct data_editor *de = data;
1172   gint posn = -1;
1173
1174   GtkWidget *notebook = get_widget_assert (de->xml, "notebook");
1175
1176   GtkSheet *var_sheet =
1177     GTK_SHEET (get_widget_assert (de->xml, "variable_sheet"));
1178
1179   PsppireVarStore *vs = PSPPIRE_VAR_STORE
1180     (gtk_sheet_get_model (var_sheet) );
1181
1182   switch ( gtk_notebook_get_current_page ( GTK_NOTEBOOK (notebook)) )
1183     {
1184     case PAGE_VAR_SHEET:
1185       posn = var_sheet->active_cell.row;
1186       break;
1187     case PAGE_DATA_SHEET:
1188       {
1189         GtkSheet *data_sheet =
1190           GTK_SHEET (get_widget_assert (de->xml, "data_sheet"));
1191
1192         if ( data_sheet->state == GTK_SHEET_COLUMN_SELECTED )
1193           posn = data_sheet->range.col0;
1194         else
1195           posn = data_sheet->active_cell.col;
1196       }
1197       break;
1198     default:
1199       g_assert_not_reached ();
1200     }
1201
1202   if ( posn == -1 ) posn = 0;
1203
1204   psppire_dict_insert_variable (vs->dict, posn, NULL);
1205 }
1206
1207 /* Callback for when the dictionary changes its split variables */
1208 static void
1209 on_split_change (PsppireDict *dict, gpointer data)
1210 {
1211   struct data_editor *de = data;
1212
1213   size_t n_split_vars = dict_get_split_cnt (dict->dict);
1214
1215   GtkWidget *split_status_area =
1216     get_widget_assert (de->xml, "split-file-status-area");
1217
1218   if ( n_split_vars == 0 )
1219     {
1220       gtk_label_set_text (GTK_LABEL (split_status_area), _("No Split"));
1221     }
1222   else
1223     {
1224       gint i;
1225       GString *text;
1226       const struct variable *const * split_vars =
1227         dict_get_split_vars (dict->dict);
1228
1229       text = g_string_new (_("Split by "));
1230
1231       for (i = 0 ; i < n_split_vars - 1; ++i )
1232         {
1233           g_string_append_printf (text, "%s, ", var_get_name (split_vars[i]));
1234         }
1235       g_string_append (text, var_get_name (split_vars[i]));
1236
1237       gtk_label_set_text (GTK_LABEL (split_status_area), text->str);
1238
1239       g_string_free (text, TRUE);
1240     }
1241 }
1242
1243
1244 /* Callback for when the dictionary changes its filter variable */
1245 static void
1246 on_filter_change (GObject *o, gint filter_index, gpointer data)
1247 {
1248   struct data_editor *de = data;
1249   GtkWidget *filter_status_area =
1250     get_widget_assert (de->xml, "filter-use-status-area");
1251
1252   if ( filter_index == -1 )
1253     {
1254       gtk_label_set_text (GTK_LABEL (filter_status_area), _("Filter off"));
1255     }
1256   else
1257     {
1258       GtkSheet *var_sheet =
1259         GTK_SHEET (get_widget_assert (de->xml, "variable_sheet"));
1260
1261       PsppireVarStore *vs = PSPPIRE_VAR_STORE
1262         (gtk_sheet_get_model (var_sheet) );
1263
1264       struct variable *var = psppire_dict_get_variable (vs->dict,
1265                                                         filter_index);
1266
1267       gchar *text = g_strdup_printf (_("Filter by %s"), var_get_name (var));
1268
1269       gtk_label_set_text (GTK_LABEL (filter_status_area), text);
1270
1271       g_free (text);
1272     }
1273 }
1274
1275 /* Callback for when the dictionary changes its weights */
1276 static void
1277 on_weight_change (GObject *o, gint weight_index, gpointer data)
1278 {
1279   struct data_editor *de = data;
1280   GtkWidget *weight_status_area =
1281     get_widget_assert (de->xml, "weight-status-area");
1282
1283   if ( weight_index == -1 )
1284     {
1285       gtk_label_set_text (GTK_LABEL (weight_status_area), _("Weights off"));
1286     }
1287   else
1288     {
1289       GtkSheet *var_sheet =
1290         GTK_SHEET (get_widget_assert (de->xml, "variable_sheet"));
1291
1292       PsppireVarStore *vs = PSPPIRE_VAR_STORE
1293         (gtk_sheet_get_model (var_sheet) );
1294
1295       struct variable *var = psppire_dict_get_variable (vs->dict,
1296                                                         weight_index);
1297
1298       gchar *text = g_strdup_printf (_("Weight by %s"), var_get_name (var));
1299
1300       gtk_label_set_text (GTK_LABEL (weight_status_area), text);
1301
1302       g_free (text);
1303     }
1304 }
1305
1306
1307
1308 \f
1309 static void data_save_as_dialog (GtkAction *, struct data_editor *de);
1310 static void new_file (GtkAction *, struct editor_window *de);
1311 static void open_data_dialog (GtkAction *, struct data_editor *de);
1312 static void data_save (GtkAction *action, struct data_editor *e);
1313
1314
1315 /* Create the GtkActions and connect to their signals */
1316 static void
1317 register_data_editor_actions (struct data_editor *de)
1318 {
1319   de->action_data_open =
1320     gtk_action_new ("data-open-dialog",
1321                     _("Open"),
1322                     _("Open a data file"),
1323                     "gtk-open");
1324
1325   g_signal_connect (de->action_data_open, "activate",
1326                     G_CALLBACK (open_data_dialog), de);
1327
1328
1329   de->action_data_save = gtk_action_new ("data-save",
1330                                             _("Save"),
1331                                             _("Save data to file"),
1332                                             "gtk-save");
1333
1334   g_signal_connect (de->action_data_save, "activate",
1335                     G_CALLBACK (data_save), de);
1336
1337
1338
1339   de->action_data_save_as = gtk_action_new ("data-save-as-dialog",
1340                                             _("Save As"),
1341                                             _("Save data to file"),
1342                                             "gtk-save");
1343
1344   g_signal_connect (de->action_data_save_as, "activate",
1345                     G_CALLBACK (data_save_as_dialog), de);
1346
1347   de->action_data_new =
1348     gtk_action_new ("data-new",
1349                     _("New"),
1350                     _("New data file"),
1351                     NULL);
1352
1353   g_signal_connect (de->action_data_new, "activate",
1354                     G_CALLBACK (new_file), de);
1355 }
1356
1357 /* Returns true if NAME has a suffix which might denote a PSPP file */
1358 static gboolean
1359 name_has_suffix (const gchar *name)
1360 {
1361   if ( g_str_has_suffix (name, ".sav"))
1362     return TRUE;
1363   if ( g_str_has_suffix (name, ".SAV"))
1364     return TRUE;
1365   if ( g_str_has_suffix (name, ".por"))
1366     return TRUE;
1367   if ( g_str_has_suffix (name, ".POR"))
1368     return TRUE;
1369
1370   return FALSE;
1371 }
1372
1373 /* Append SUFFIX to the filename of DE */
1374 static void
1375 append_filename_suffix (struct data_editor *de, const gchar *suffix)
1376 {
1377   if ( ! name_has_suffix (de->file_name))
1378     {
1379       gchar *s = de->file_name;
1380       de->file_name = g_strconcat (de->file_name, suffix, NULL);
1381       g_free (s);
1382     }
1383 }
1384
1385 /* Save DE to file */
1386 static void
1387 save_file (struct data_editor *de)
1388 {
1389   struct getl_interface *sss;
1390   struct string file_name ;
1391
1392   g_assert (de->file_name);
1393
1394   ds_init_cstr (&file_name, de->file_name);
1395   gen_quoted_string (&file_name);
1396
1397   if ( de->save_as_portable )
1398     {
1399       append_filename_suffix (de, ".por");
1400       sss = create_syntax_string_source ("EXPORT OUTFILE=%s.",
1401                                          ds_cstr (&file_name));
1402     }
1403   else
1404     {
1405       append_filename_suffix (de, ".sav");
1406       sss = create_syntax_string_source ("SAVE OUTFILE=%s.",
1407                                          ds_cstr (&file_name));
1408     }
1409
1410   ds_destroy (&file_name);
1411
1412   execute_syntax (sss);
1413 }
1414
1415
1416 /* Callback for data_save action.
1417    If there's an existing file name, then just save,
1418    otherwise prompt for a file name, then save */
1419 static void
1420 data_save (GtkAction *action, struct data_editor *de)
1421 {
1422   if ( de->file_name)
1423     save_file (de);
1424   else
1425     data_save_as_dialog (action, de);
1426 }
1427
1428
1429 /* Callback for data_save_as action. Prompt for a filename and save */
1430 static void
1431 data_save_as_dialog (GtkAction *action, struct data_editor *de)
1432 {
1433   struct editor_window *e = (struct editor_window *) de;
1434
1435   GtkWidget *button_sys;
1436   GtkWidget *dialog =
1437     gtk_file_chooser_dialog_new (_("Save"),
1438                                  GTK_WINDOW (e->window),
1439                                  GTK_FILE_CHOOSER_ACTION_SAVE,
1440                                  GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
1441                                  GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
1442                                  NULL);
1443
1444   GtkFileFilter *filter = gtk_file_filter_new ();
1445   gtk_file_filter_set_name (filter, _("System Files (*.sav)"));
1446   gtk_file_filter_add_pattern (filter, "*.sav");
1447   gtk_file_filter_add_pattern (filter, "*.SAV");
1448   gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter);
1449
1450   filter = gtk_file_filter_new ();
1451   gtk_file_filter_set_name (filter, _("Portable Files (*.por) "));
1452   gtk_file_filter_add_pattern (filter, "*.por");
1453   gtk_file_filter_add_pattern (filter, "*.POR");
1454   gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter);
1455
1456   filter = gtk_file_filter_new ();
1457   gtk_file_filter_set_name (filter, _("All Files"));
1458   gtk_file_filter_add_pattern (filter, "*");
1459   gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter);
1460
1461   {
1462     GtkWidget *button_por;
1463     GtkWidget *vbox = gtk_vbox_new (TRUE, 5);
1464     button_sys =
1465       gtk_radio_button_new_with_label (NULL, _("System File"));
1466
1467     button_por =
1468       gtk_radio_button_new_with_label
1469       (gtk_radio_button_get_group (GTK_RADIO_BUTTON(button_sys)),
1470        _("Portable File"));
1471
1472     gtk_box_pack_start_defaults (GTK_BOX (vbox), button_sys);
1473     gtk_box_pack_start_defaults (GTK_BOX (vbox), button_por);
1474
1475     gtk_widget_show_all (vbox);
1476
1477     gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER(dialog), vbox);
1478   }
1479
1480   switch (gtk_dialog_run (GTK_DIALOG (dialog)))
1481     {
1482     case GTK_RESPONSE_ACCEPT:
1483       {
1484         g_free (de->file_name);
1485
1486         de->file_name =
1487           gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
1488
1489         de->save_as_portable =
1490           ! gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button_sys));
1491
1492         save_file (de);
1493
1494         window_set_name_from_filename (e, de->file_name);
1495       }
1496       break;
1497     default:
1498       break;
1499     }
1500
1501   gtk_widget_destroy (dialog);
1502 }
1503
1504
1505 /* Callback for data_new action.
1506    Performs the NEW FILE command */
1507 static void
1508 new_file (GtkAction *action, struct editor_window *e)
1509 {
1510   struct data_editor *de = (struct data_editor *) e;
1511
1512   struct getl_interface *sss =
1513     create_syntax_string_source ("NEW FILE.");
1514
1515   execute_syntax (sss);
1516
1517   g_free (de->file_name);
1518   de->file_name = NULL;
1519
1520   default_window_name (e);
1521 }
1522
1523
1524 static void
1525 open_data_file (const gchar *file_name, struct data_editor *de)
1526 {
1527   struct getl_interface *sss;
1528   struct string filename;
1529
1530   ds_init_cstr (&filename, file_name);
1531
1532   gen_quoted_string (&filename);
1533
1534   sss = create_syntax_string_source ("GET FILE=%s.",
1535                                      ds_cstr (&filename));
1536   ds_destroy (&filename);
1537
1538   if (execute_syntax (sss) )
1539   {
1540     window_set_name_from_filename ((struct editor_window *) de, file_name);
1541     add_most_recent (file_name);
1542   }
1543 }
1544
1545
1546
1547 /* Callback for the data_open action.
1548    Prompts for a filename and opens it */
1549 static void
1550 open_data_dialog (GtkAction *action, struct data_editor *de)
1551 {
1552   struct editor_window *e = (struct editor_window *) de;
1553
1554   GtkWidget *dialog =
1555     gtk_file_chooser_dialog_new (_("Open"),
1556                                  GTK_WINDOW (e->window),
1557                                  GTK_FILE_CHOOSER_ACTION_OPEN,
1558                                  GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
1559                                  GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
1560                                  NULL);
1561
1562   GtkFileFilter *filter = gtk_file_filter_new ();
1563   gtk_file_filter_set_name (filter, _("System Files (*.sav)"));
1564   gtk_file_filter_add_pattern (filter, "*.sav");
1565   gtk_file_filter_add_pattern (filter, "*.SAV");
1566   gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter);
1567
1568   filter = gtk_file_filter_new ();
1569   gtk_file_filter_set_name (filter, _("Portable Files (*.por) "));
1570   gtk_file_filter_add_pattern (filter, "*.por");
1571   gtk_file_filter_add_pattern (filter, "*.POR");
1572   gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter);
1573
1574   filter = gtk_file_filter_new ();
1575   gtk_file_filter_set_name (filter, _("All Files"));
1576   gtk_file_filter_add_pattern (filter, "*");
1577   gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter);
1578
1579
1580   if ( de->file_name)
1581     {
1582       gchar *dir_name = g_path_get_dirname (de->file_name);
1583       gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog),
1584                                            dir_name);
1585       free (dir_name);
1586     }
1587
1588   switch (gtk_dialog_run (GTK_DIALOG (dialog)))
1589     {
1590     case GTK_RESPONSE_ACCEPT:
1591       {
1592         g_free (de->file_name);
1593         de->file_name =
1594           gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
1595
1596         open_data_file (de->file_name, de);
1597       }
1598       break;
1599     default:
1600       break;
1601     }
1602
1603   gtk_widget_destroy (dialog);
1604 }
1605
1606
1607
1608 /* Update the data_ref_entry with the reference of the active cell */
1609 static gint
1610 update_data_ref_entry (const GtkSheet *sheet, gint row, gint col, gpointer data)
1611 {
1612   GladeXML *data_editor_xml = data;
1613
1614   PsppireDataStore *data_store =
1615     PSPPIRE_DATA_STORE (gtk_sheet_get_model (sheet));
1616
1617   g_return_val_if_fail (data_editor_xml, FALSE);
1618
1619   if (data_store)
1620     {
1621       const struct variable *var =
1622         psppire_dict_get_variable (data_store->dict, col);
1623
1624       /* The entry where the reference to the current cell is displayed */
1625       GtkEntry *cell_ref_entry =
1626         GTK_ENTRY (get_widget_assert (data_editor_xml,
1627                                       "cell_ref_entry"));
1628       GtkEntry *datum_entry =
1629         GTK_ENTRY (get_widget_assert (data_editor_xml,
1630                                       "datum_entry"));
1631
1632       if ( var )
1633         {
1634           gchar *text = g_strdup_printf ("%d: %s", row + FIRST_CASE_NUMBER,
1635                                          var_get_name (var));
1636
1637           gchar *s = pspp_locale_to_utf8 (text, -1, 0);
1638
1639           g_free (text);
1640
1641           gtk_entry_set_text (cell_ref_entry, s);
1642
1643           g_free (s);
1644         }
1645       else
1646         gtk_entry_set_text (cell_ref_entry, "");
1647
1648
1649       if ( var )
1650         {
1651           gchar *text =
1652             psppire_data_store_get_string (data_store, row,
1653                                            var_get_dict_index(var));
1654           g_strchug (text);
1655
1656           gtk_entry_set_text (datum_entry, text);
1657
1658           free (text);
1659         }
1660       else
1661         gtk_entry_set_text (datum_entry, "");
1662     }
1663
1664   return FALSE;
1665 }
1666
1667
1668
1669
1670
1671 static void
1672 do_sort (PsppireDataStore *ds, int var, gboolean descend)
1673 {
1674   GString *string = g_string_new ("SORT CASES BY ");
1675
1676   const struct variable *v =
1677     psppire_dict_get_variable (ds->dict, var);
1678
1679   g_string_append_printf (string, "%s", var_get_name (v));
1680
1681   if ( descend )
1682     g_string_append (string, " (D)");
1683
1684   g_string_append (string, ".");
1685
1686   execute_syntax (create_syntax_string_source (string->str));
1687
1688   g_string_free (string, TRUE);
1689 }
1690
1691
1692 static void
1693 sort_up (GtkMenuItem *item, gpointer data)
1694 {
1695   GtkSheet *sheet  = data;
1696   GtkSheetRange range;
1697   gtk_sheet_get_selected_range (sheet, &range);
1698
1699   do_sort (PSPPIRE_DATA_STORE (gtk_sheet_get_model(sheet)),
1700            range.col0, FALSE);
1701
1702 }
1703
1704 static void
1705 sort_down (GtkMenuItem *item, gpointer data)
1706 {
1707   GtkSheet *sheet  = data;
1708   GtkSheetRange range;
1709   gtk_sheet_get_selected_range (sheet, &range);
1710
1711   do_sort (PSPPIRE_DATA_STORE (gtk_sheet_get_model(sheet)),
1712            range.col0, TRUE);
1713 }
1714
1715
1716
1717
1718 static void
1719 create_data_sheet_variable_popup_menu (struct data_editor *de)
1720 {
1721   GtkSheet *sheet  = GTK_SHEET (get_widget_assert (de->xml, "data_sheet"));
1722   GtkWidget *menu = gtk_menu_new ();
1723
1724   GtkWidget *sort_ascending =
1725     gtk_menu_item_new_with_label (_("Sort Ascending"));
1726
1727   GtkWidget *sort_descending =
1728     gtk_menu_item_new_with_label (_("Sort Descending"));
1729
1730
1731   GtkWidget *insert_variable =
1732     gtk_menu_item_new_with_label (_("Insert Variable"));
1733
1734   GtkWidget *clear_variable =
1735     gtk_menu_item_new_with_label (_("Clear"));
1736
1737
1738   gtk_action_connect_proxy (de->insert_variable,
1739                             insert_variable );
1740
1741
1742   gtk_action_connect_proxy (de->delete_variables,
1743                             clear_variable );
1744
1745
1746   gtk_menu_shell_append (GTK_MENU_SHELL (menu), insert_variable);
1747
1748
1749   gtk_menu_shell_append (GTK_MENU_SHELL (menu),
1750                          gtk_separator_menu_item_new ());
1751
1752
1753   gtk_menu_shell_append (GTK_MENU_SHELL (menu), clear_variable);
1754
1755
1756   gtk_menu_shell_append (GTK_MENU_SHELL (menu),
1757                          gtk_separator_menu_item_new ());
1758
1759
1760   g_signal_connect (G_OBJECT (sort_ascending), "activate",
1761                     G_CALLBACK (sort_up), sheet);
1762
1763   gtk_menu_shell_append (GTK_MENU_SHELL (menu), sort_ascending);
1764
1765
1766   g_signal_connect (G_OBJECT (sort_descending), "activate",
1767                     G_CALLBACK (sort_down), sheet);
1768
1769
1770   gtk_menu_shell_append (GTK_MENU_SHELL (menu), sort_descending);
1771
1772   gtk_widget_show_all (menu);
1773
1774
1775   de->data_sheet_variable_popup_menu = GTK_MENU(menu);
1776 }
1777
1778
1779 static void
1780 create_data_sheet_cases_popup_menu (struct data_editor *de)
1781 {
1782   GtkWidget *menu = gtk_menu_new ();
1783
1784   GtkWidget *insert_case =
1785     gtk_menu_item_new_with_label (_("Insert Case"));
1786
1787   GtkWidget *delete_case =
1788     gtk_menu_item_new_with_label (_("Clear"));
1789
1790
1791   gtk_action_connect_proxy (de->insert_case,
1792                             insert_case);
1793
1794
1795   gtk_action_connect_proxy (de->delete_cases,
1796                             delete_case);
1797
1798
1799   gtk_menu_shell_append (GTK_MENU_SHELL (menu), insert_case);
1800
1801
1802   gtk_menu_shell_append (GTK_MENU_SHELL (menu),
1803                          gtk_separator_menu_item_new ());
1804
1805
1806   gtk_menu_shell_append (GTK_MENU_SHELL (menu), delete_case);
1807
1808
1809   gtk_widget_show_all (menu);
1810
1811
1812   de->data_sheet_cases_popup_menu = GTK_MENU (menu);
1813 }
1814
1815
1816 static void
1817 popup_variable_menu (GtkSheet *sheet, gint column,
1818                      GdkEventButton *event, gpointer data)
1819 {
1820   struct data_editor *de = data;
1821
1822   PsppireDataStore *data_store =
1823     PSPPIRE_DATA_STORE (gtk_sheet_get_model (sheet));
1824
1825   const struct variable *v =
1826     psppire_dict_get_variable (data_store->dict, column);
1827
1828   if ( v && event->button == 3)
1829     {
1830
1831       gtk_sheet_select_column (sheet, column);
1832
1833       gtk_menu_popup (GTK_MENU (de->data_sheet_variable_popup_menu),
1834                       NULL, NULL, NULL, NULL,
1835                       event->button, event->time);
1836     }
1837 }
1838
1839
1840 static void
1841 popup_cases_menu (GtkSheet *sheet, gint row,
1842                   GdkEventButton *event, gpointer data)
1843 {
1844   struct data_editor *de = data;
1845
1846   PsppireDataStore *data_store =
1847     PSPPIRE_DATA_STORE (gtk_sheet_get_model (sheet));
1848
1849   if ( row <= psppire_data_store_get_case_count (data_store) &&
1850        event->button == 3)
1851     {
1852       gtk_sheet_select_row (sheet, row);
1853
1854       gtk_menu_popup (GTK_MENU (de->data_sheet_cases_popup_menu),
1855                       NULL, NULL, NULL, NULL,
1856                       event->button, event->time);
1857     }
1858 }
1859
1860
1861 static void
1862 on_edit_paste (GtkAction *a, gpointer data)
1863 {
1864   GtkClipboard *clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
1865
1866   gtk_clipboard_request_contents (clipboard,
1867                                   gdk_atom_intern ("UTF8_STRING", TRUE),
1868                                   data_sheet_contents_received_callback,
1869                                   data);
1870 }
1871
1872
1873 static void
1874 on_edit_copy (GtkMenuItem *m, gpointer data)
1875 {
1876   struct data_editor *de = data;
1877
1878   GtkSheet *data_sheet = GTK_SHEET (get_widget_assert (de->xml,
1879                                                        "data_sheet"));
1880
1881   data_sheet_set_clip (data_sheet);
1882 }
1883
1884
1885
1886 static void
1887 on_edit_cut (GtkMenuItem *m, gpointer data)
1888 {
1889   struct data_editor *de = data;
1890   gint max_rows, max_columns;
1891   gint r;
1892   GtkSheetRange range;
1893   PsppireDataStore *ds;
1894   GtkSheet *data_sheet = GTK_SHEET (get_widget_assert (de->xml,
1895                                                        "data_sheet"));
1896
1897   data_sheet_set_clip (data_sheet);
1898
1899
1900   /* Now blank all the cells */
1901   gtk_sheet_get_selected_range (data_sheet, &range);
1902
1903   ds = PSPPIRE_DATA_STORE (gtk_sheet_get_model (data_sheet));
1904
1905
1906    /* If nothing selected, then use active cell */
1907   if ( range.row0 < 0 || range.col0 < 0 )
1908     {
1909       gint row, col;
1910       gtk_sheet_get_active_cell (data_sheet, &row, &col);
1911
1912       range.row0 = range.rowi = row;
1913       range.col0 = range.coli = col;
1914     }
1915
1916   /* The sheet range can include cells that do not include data.
1917      Exclude them from the range. */
1918   max_rows = psppire_data_store_get_case_count (ds);
1919   if (range.rowi >= max_rows)
1920     {
1921       if (max_rows == 0)
1922         return;
1923       range.rowi = max_rows - 1;
1924     }
1925
1926   max_columns = dict_get_var_cnt (ds->dict->dict);
1927   if (range.coli >= max_columns)
1928     {
1929       if (max_columns == 0)
1930         return;
1931       range.coli = max_columns - 1;
1932     }
1933
1934   g_return_if_fail (range.rowi >= range.row0);
1935   g_return_if_fail (range.row0 >= 0);
1936   g_return_if_fail (range.coli >= range.col0);
1937   g_return_if_fail (range.col0 >= 0);
1938
1939
1940   for (r = range.row0; r <= range.rowi ; ++r )
1941     {
1942       gint c;
1943
1944       for (c = range.col0 ; c <= range.coli; ++c)
1945         {
1946           psppire_data_store_set_string (ds, "", r, c);
1947         }
1948     }
1949
1950   /* and remove the selection */
1951   gtk_sheet_unselect_range (data_sheet);
1952 }
1953
1954