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