src/ui/gui/data-editor.c

   1 /*
   2     PSPPIRE --- A Graphical User Interface for PSPP
   3     Copyright (C) 2006, 2007  Free Software Foundation
   4
   5     This program is free software; you can redistribute it and/or modify
   6     it under the terms of the GNU General Public License as published by
   7     the Free Software Foundation; either version 2 of the License, or
   8     (at your option) any later version.
   9
  10     This program is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13     GNU General Public License for more details.
  14
  15     You should have received a copy of the GNU General Public License
  16     along with this program; if not, write to the Free Software
  17     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  18     02110-1301, USA. */
  19
  20 #include <config.h>
  21 #include <stdlib.h>
  22 #include <gettext.h>
  23
  24 #include <glade/glade.h>
  25 #include <gtk/gtk.h>
  26
  27 #include "window-manager.h"
  28 #include <gtksheet/gtksheet.h>
  29
  30 #include "helper.h"
  31 #include "about.h"
  32 #include "psppire-dialog.h"
  33 #include "psppire-var-select.h"
  34
  35 #define _(msgid) gettext (msgid)
  36 #define N_(msgid) msgid
  37
  38 #include "data-editor.h"
  39 #include "syntax-editor.h"
  40 #include <language/syntax-string-source.h>
  41 #include "window-manager.h"
  42
  43 #include "psppire-data-store.h"
  44 #include "psppire-var-store.h"
  45
  46 #include "weight-cases-dialog.h"
  47
  48 static void register_data_editor_actions (struct data_editor *de);
  49
  50 static void insert_variable (GtkCheckMenuItem *m, gpointer data);
  51
  52
  53 /* Switch between the VAR SHEET and the DATA SHEET */
  54 enum {PAGE_DATA_SHEET = 0, PAGE_VAR_SHEET};
  55
  56 static gboolean click2column (GtkWidget *w, gint col, gpointer data);
  57
  58 static gboolean click2row (GtkWidget *w, gint row, gpointer data);
  59
  60
  61 static void select_sheet (struct data_editor *de, guint page_num);
  62
  63
  64 /* Callback for when the dictionary changes properties*/
  65 static void on_weight_change (GObject *, gint, gpointer);
  66 static void on_filter_change (GObject *, gint, gpointer);
  67 static void on_split_change (PsppireDict *, gpointer);
  68
  69 static void data_var_select (GtkNotebook *notebook,
  70                             GtkNotebookPage *page,
  71                             guint page_num,
  72                             gpointer user_data);
  73
  74 static void status_bar_activate (GtkCheckMenuItem *, gpointer);
  75
  76 static void grid_lines_activate (GtkCheckMenuItem *, gpointer);
  77
  78 static void data_sheet_activate (GtkCheckMenuItem *, gpointer);
  79
  80 static void variable_sheet_activate (GtkCheckMenuItem *, gpointer );
  81
  82 static void fonts_activate (GtkMenuItem *, gpointer);
  83
  84 static void value_labels_activate (GtkCheckMenuItem *, gpointer);
  85 static void value_labels_toggled (GtkToggleToolButton *, gpointer);
  86
  87
  88 static void file_quit (GtkCheckMenuItem *, gpointer );
  89
  90 static void on_clear_activate (GtkMenuItem *, gpointer);
  91
  92 static void
  93 enable_edit_clear (GtkWidget *w, gint row, gpointer data)
  94 {
  95   struct data_editor *de = data;
  96
  97   GtkWidget *menuitem = get_widget_assert (de->xml, "edit_clear");
  98
  99   gtk_widget_set_sensitive (menuitem, TRUE);
 100 }
 101
 102 static gboolean
 103 disable_edit_clear (GtkWidget *w, gint x, gint y, gpointer data)
 104 {
 105   struct data_editor *de = data;
 106
 107   GtkWidget *menuitem = get_widget_assert (de->xml, "edit_clear");
 108
 109   gtk_widget_set_sensitive (menuitem, FALSE);
 110
 111   return FALSE;
 112 }
 113
 114 static void weight_cases_dialog (GObject *o, gpointer data);
 115
 116
 117 /*
 118   Create a new data editor.
 119 */
 120 struct data_editor *
 121 new_data_editor (void)
 122 {
 123   struct data_editor *de ;
 124   struct editor_window *e;
 125   GtkSheet *var_sheet ;
 126   PsppireVarStore *vs;
 127
 128   de = g_malloc0 (sizeof (*de));
 129
 130   e = (struct editor_window *) de;
 131
 132   de->xml = glade_xml_new (PKGDATADIR "/data-editor.glade", NULL, NULL);
 133
 134
 135   var_sheet = GTK_SHEET (get_widget_assert (de->xml, "variable_sheet"));
 136
 137   vs = PSPPIRE_VAR_STORE (gtk_sheet_get_model (var_sheet));
 138
 139   g_signal_connect (vs->dict, "weight-changed",
 140                     G_CALLBACK (on_weight_change),
 141                     de);
 142
 143   g_signal_connect (vs->dict, "filter-changed",
 144                     G_CALLBACK (on_filter_change),
 145                     de);
 146
 147   g_signal_connect (vs->dict, "split-changed",
 148                     G_CALLBACK (on_split_change),
 149                     de);
 150
 151   connect_help (de->xml);
 152
 153
 154   register_data_editor_actions (de);
 155
 156   de->invoke_weight_cases_dialog =
 157     gtk_action_new ("weight-cases-dialog",
 158                     _("Weights"),
 159                     _("Weight cases by variable"),
 160                     "pspp-weight-cases");
 161
 162
 163   g_signal_connect (de->invoke_weight_cases_dialog, "activate",
 164                     G_CALLBACK (weight_cases_dialog), de);
 165
 166   e->window = GTK_WINDOW (get_widget_assert (de->xml, "data_editor"));
 167
 168   g_signal_connect_swapped (get_widget_assert (de->xml,"file_new_data"),
 169                             "activate",
 170                             G_CALLBACK (gtk_action_activate),
 171                             de->action_data_new);
 172
 173   g_signal_connect_swapped (get_widget_assert (de->xml,"file_open_data"),
 174                             "activate",
 175                             G_CALLBACK (gtk_action_activate),
 176                             de->action_data_open);
 177
 178   g_signal_connect (get_widget_assert (de->xml,"file_new_syntax"),
 179                     "activate",
 180                     G_CALLBACK (new_syntax_window),
 181                     e->window);
 182
 183   g_signal_connect (get_widget_assert (de->xml,"file_open_syntax"),
 184                     "activate",
 185                     G_CALLBACK (open_syntax_window),
 186                     e->window);
 187
 188   g_signal_connect_swapped (get_widget_assert (de->xml,"file_save"),
 189                             "activate",
 190                             G_CALLBACK (gtk_action_activate),
 191                             de->action_data_save);
 192
 193   g_signal_connect_swapped (get_widget_assert (de->xml,"file_save_as"),
 194                             "activate",
 195                             G_CALLBACK (gtk_action_activate),
 196                             de->action_data_save_as);
 197
 198
 199   g_signal_connect (get_widget_assert (de->xml,"edit_clear"),
 200                     "activate",
 201                     G_CALLBACK (on_clear_activate),
 202                     de);
 203
 204
 205   g_signal_connect (get_widget_assert (de->xml,"data_insert-variable"),
 206                     "activate",
 207                     G_CALLBACK (insert_variable),
 208                     de);
 209
 210   gtk_action_connect_proxy (de->invoke_weight_cases_dialog,
 211                             get_widget_assert (de->xml, "data_weight-cases")
 212                             );
 213
 214
 215   g_signal_connect (get_widget_assert (de->xml,"help_about"),
 216                     "activate",
 217                     G_CALLBACK (about_new),
 218                     e->window);
 219
 220
 221   g_signal_connect (get_widget_assert (de->xml,"help_reference"),
 222                     "activate",
 223                     G_CALLBACK (reference_manual),
 224                     e->window);
 225
 226
 227
 228   g_signal_connect (get_widget_assert (de->xml,"data_sheet"),
 229                     "double-click-column",
 230                     G_CALLBACK (click2column),
 231                     de);
 232
 233
 234   g_signal_connect (get_widget_assert (de->xml, "variable_sheet"),
 235                     "double-click-row",
 236                     GTK_SIGNAL_FUNC (click2row),
 237                     de);
 238
 239
 240   g_signal_connect (get_widget_assert (de->xml, "variable_sheet"),
 241                     "select-row",
 242                     GTK_SIGNAL_FUNC (enable_edit_clear),
 243                     de);
 244
 245   g_signal_connect (get_widget_assert (de->xml, "variable_sheet"),
 246                     "activate",
 247                     GTK_SIGNAL_FUNC (disable_edit_clear),
 248                     de);
 249
 250
 251   g_signal_connect (get_widget_assert (de->xml, "notebook"),
 252                     "switch-page",
 253                     G_CALLBACK (data_var_select), de);
 254
 255
 256
 257   g_signal_connect (get_widget_assert (de->xml, "view_statusbar"),
 258                     "activate",
 259                     G_CALLBACK (status_bar_activate), de);
 260
 261
 262   g_signal_connect (get_widget_assert (de->xml, "view_gridlines"),
 263                     "activate",
 264                     G_CALLBACK (grid_lines_activate), de);
 265
 266
 267
 268   g_signal_connect (get_widget_assert (de->xml, "view_data"),
 269                     "activate",
 270                     G_CALLBACK (data_sheet_activate), de);
 271
 272   g_signal_connect (get_widget_assert (de->xml, "view_variables"),
 273                     "activate",
 274                     G_CALLBACK (variable_sheet_activate), de);
 275
 276
 277
 278   g_signal_connect (get_widget_assert (de->xml, "view_fonts"),
 279                     "activate",
 280                     G_CALLBACK (fonts_activate), de);
 281
 282
 283
 284   g_signal_connect (get_widget_assert (de->xml, "view_valuelabels"),
 285                     "activate",
 286                     G_CALLBACK (value_labels_activate), de);
 287
 288
 289   g_signal_connect (get_widget_assert (de->xml, "togglebutton-value-labels"),
 290                     "toggled",
 291                     G_CALLBACK (value_labels_toggled), de);
 292
 293   gtk_action_connect_proxy (de->action_data_open,
 294                             get_widget_assert (de->xml, "button-open")
 295                             );
 296
 297   gtk_action_connect_proxy (de->action_data_save,
 298                             get_widget_assert (de->xml, "button-save")
 299                             );
 300
 301   gtk_action_connect_proxy (de->invoke_weight_cases_dialog,
 302                             get_widget_assert (de->xml, "button-weight-cases")
 303                             );
 304
 305   g_signal_connect (get_widget_assert (de->xml, "file_quit"),
 306                     "activate",
 307                     G_CALLBACK (file_quit), de);
 308
 309
 310   g_signal_connect (get_widget_assert (de->xml, "windows_minimise_all"),
 311                     "activate",
 312                     G_CALLBACK (minimise_all_windows), NULL);
 313
 314
 315   select_sheet (de, PAGE_DATA_SHEET);
 316
 317   return de;
 318 }
 319
 320
 321 /* Callback which occurs when the var sheet's row title
 322    button is double clicked */
 323 static gboolean
 324 click2row (GtkWidget *w, gint row, gpointer data)
 325 {
 326   struct data_editor *de = data;
 327
 328   gint current_row, current_column;
 329
 330   GtkWidget *data_sheet  = get_widget_assert (de->xml, "data_sheet");
 331
 332   data_editor_select_sheet (de, PAGE_DATA_SHEET);
 333
 334   gtk_sheet_get_active_cell (GTK_SHEET (data_sheet),
 335                              &current_row, &current_column);
 336
 337   gtk_sheet_set_active_cell (GTK_SHEET (data_sheet), current_row, row);
 338
 339   return FALSE;
 340 }
 341
 342
 343 /* Callback which occurs when the data sheet's column title
 344    is double clicked */
 345 static gboolean
 346 click2column (GtkWidget *w, gint col, gpointer data)
 347 {
 348   struct data_editor *de = data;
 349
 350   gint current_row, current_column;
 351
 352   GtkWidget *var_sheet  = get_widget_assert (de->xml, "variable_sheet");
 353
 354   data_editor_select_sheet (de, PAGE_VAR_SHEET);
 355
 356   gtk_sheet_get_active_cell (GTK_SHEET (var_sheet),
 357                              &current_row, &current_column);
 358
 359   gtk_sheet_set_active_cell (GTK_SHEET (var_sheet), col, current_column);
 360
 361   return FALSE;
 362 }
 363
 364
 365 void
 366 new_data_window (GtkMenuItem *menuitem, gpointer parent)
 367 {
 368   window_create (WINDOW_DATA, NULL);
 369 }
 370
 371
 372 static void
 373 select_sheet (struct data_editor *de, guint page_num)
 374 {
 375   GtkWidget *insert_variable = get_widget_assert (de->xml, "data_insert-variable");
 376   GtkWidget *insert_cases = get_widget_assert (de->xml, "insert-cases");
 377
 378   GtkWidget *view_data = get_widget_assert (de->xml, "view_data");
 379   GtkWidget *view_variables = get_widget_assert (de->xml, "view_variables");
 380
 381   switch (page_num)
 382     {
 383     case PAGE_VAR_SHEET:
 384       gtk_widget_hide (view_variables);
 385       gtk_widget_show (view_data);
 386       gtk_widget_set_sensitive (insert_variable, TRUE);
 387       gtk_widget_set_sensitive (insert_cases, FALSE);
 388       break;
 389     case PAGE_DATA_SHEET:
 390       gtk_widget_show (view_variables);
 391       gtk_widget_hide (view_data);
 392 #if 0
 393       gtk_widget_set_sensitive (insert_cases, TRUE);
 394 #endif
 395       break;
 396     default:
 397       g_assert_not_reached ();
 398       break;
 399     }
 400 }
 401
 402
 403 static void
 404 data_var_select (GtkNotebook *notebook,
 405                 GtkNotebookPage *page,
 406                 guint page_num,
 407                 gpointer user_data)
 408 {
 409   struct data_editor *de = user_data;
 410
 411   select_sheet (de, page_num);
 412 }
 413
 414
 415
 416
 417 void
 418 data_editor_select_sheet (struct data_editor *de, gint page)
 419 {
 420   gtk_notebook_set_current_page
 421    (
 422     GTK_NOTEBOOK (get_widget_assert (de->xml,"notebook")), page
 423     );
 424 }
 425
 426
 427 static void
 428 status_bar_activate (GtkCheckMenuItem *menuitem, gpointer data)
 429 {
 430   struct data_editor *de = data;
 431   GtkWidget *statusbar = get_widget_assert (de->xml, "status-bar");
 432
 433   if ( gtk_check_menu_item_get_active (menuitem) )
 434     gtk_widget_show (statusbar);
 435   else
 436     gtk_widget_hide (statusbar);
 437 }
 438
 439
 440 static void
 441 grid_lines_activate (GtkCheckMenuItem *menuitem, gpointer data)
 442 {
 443   struct data_editor *de = data;
 444   const bool grid_visible = gtk_check_menu_item_get_active (menuitem);
 445
 446   gtk_sheet_show_grid (GTK_SHEET (get_widget_assert (de->xml,
 447                                                      "variable_sheet")),
 448                        grid_visible);
 449
 450   gtk_sheet_show_grid (GTK_SHEET (get_widget_assert (de->xml, "data_sheet")),
 451                        grid_visible);
 452 }
 453
 454
 455
 456 static void
 457 data_sheet_activate (GtkCheckMenuItem *menuitem, gpointer data)
 458 {
 459   struct data_editor *de = data;
 460
 461   data_editor_select_sheet (de, PAGE_DATA_SHEET);
 462 }
 463
 464
 465 static void
 466 variable_sheet_activate (GtkCheckMenuItem *menuitem, gpointer data)
 467 {
 468   struct data_editor *de = data;
 469
 470   data_editor_select_sheet (de, PAGE_VAR_SHEET);
 471 }
 472
 473
 474 static void
 475 fonts_activate (GtkMenuItem *menuitem, gpointer data)
 476 {
 477   struct data_editor *de = data;
 478   GtkWidget *dialog =
 479     gtk_font_selection_dialog_new (_("Font Selection"));
 480
 481   gtk_window_set_transient_for (GTK_WINDOW (dialog),
 482                                 GTK_WINDOW (get_widget_assert (de->xml,
 483                                                                "data_editor")));
 484   if ( GTK_RESPONSE_OK == gtk_dialog_run (GTK_DIALOG (dialog)) )
 485     {
 486       GtkSheet *data_sheet =
 487         GTK_SHEET (get_widget_assert (de->xml, "data_sheet"));
 488
 489       GtkSheet *var_sheet =
 490         GTK_SHEET (get_widget_assert (de->xml, "variable_sheet"));
 491
 492       PsppireDataStore *ds = PSPPIRE_DATA_STORE (gtk_sheet_get_model (data_sheet));
 493       PsppireVarStore *vs = PSPPIRE_VAR_STORE (gtk_sheet_get_model (var_sheet));
 494
 495       const gchar *font = gtk_font_selection_dialog_get_font_name
 496         (GTK_FONT_SELECTION_DIALOG (dialog));
 497
 498       PangoFontDescription* font_desc =
 499         pango_font_description_from_string (font);
 500
 501       psppire_var_store_set_font (vs, font_desc);
 502       psppire_data_store_set_font (ds, font_desc);
 503     }
 504
 505   gtk_widget_hide (dialog);
 506 }
 507
 508
 509 /* The next two callbacks are mutually co-operative */
 510
 511 /* Callback for the value labels menu item */
 512 static void
 513 value_labels_activate (GtkCheckMenuItem *menuitem, gpointer data)
 514 {
 515   struct data_editor *de = data;
 516
 517   GtkSheet *data_sheet = GTK_SHEET (get_widget_assert (de->xml, "data_sheet"));
 518
 519   GtkToggleToolButton *tb =
 520     GTK_TOGGLE_TOOL_BUTTON (get_widget_assert (de->xml,
 521                                                "togglebutton-value-labels"));
 522
 523   PsppireDataStore *ds = PSPPIRE_DATA_STORE (gtk_sheet_get_model (data_sheet));
 524
 525   gboolean show_value_labels = gtk_check_menu_item_get_active (menuitem);
 526
 527   gtk_toggle_tool_button_set_active (tb, show_value_labels);
 528
 529   psppire_data_store_show_labels (ds, show_value_labels);
 530 }
 531
 532
 533 /* Callback for the value labels tooglebutton */
 534 static void
 535 value_labels_toggled (GtkToggleToolButton *toggle_tool_button,
 536                       gpointer data)
 537 {
 538   struct data_editor *de = data;
 539
 540   GtkSheet *data_sheet = GTK_SHEET (get_widget_assert (de->xml, "data_sheet"));
 541
 542   GtkCheckMenuItem *item =
 543     GTK_CHECK_MENU_ITEM (get_widget_assert (de->xml, "view_valuelabels"));
 544
 545   PsppireDataStore *ds = PSPPIRE_DATA_STORE (gtk_sheet_get_model (data_sheet));
 546
 547   gboolean show_value_labels =
 548     gtk_toggle_tool_button_get_active (toggle_tool_button);
 549
 550   gtk_check_menu_item_set_active (item, show_value_labels);
 551
 552   psppire_data_store_show_labels (ds, show_value_labels);
 553 }
 554
 555
 556 static void
 557 file_quit (GtkCheckMenuItem *menuitem, gpointer data)
 558 {
 559   /* FIXME: Need to be more intelligent here.
 560      Give the user the opportunity to save any unsaved data.
 561   */
 562   gtk_main_quit ();
 563 }
 564
 565
 566
 567 /* Callback for when the Clear item in the edit menu is activated */
 568 static void
 569 on_clear_activate (GtkMenuItem *menuitem, gpointer data)
 570 {
 571   struct data_editor *de = data;
 572
 573   GtkNotebook *notebook = GTK_NOTEBOOK (get_widget_assert (de->xml,
 574                                                            "notebook"));
 575
 576   switch ( gtk_notebook_get_current_page (notebook) )
 577     {
 578     case PAGE_VAR_SHEET:
 579       {
 580         GtkSheet *var_sheet =
 581           GTK_SHEET (get_widget_assert (de->xml, "variable_sheet"));
 582
 583         PsppireVarStore *vs = PSPPIRE_VAR_STORE
 584           (gtk_sheet_get_model (var_sheet) );
 585
 586         /* This shouldn't be able to happen, because the menuitem
 587            should be disabled */
 588         g_return_if_fail (var_sheet->state  ==  GTK_SHEET_ROW_SELECTED );
 589
 590         psppire_dict_delete_variables (vs->dict,
 591                                        var_sheet->range.row0,
 592                                        1 +
 593                                        var_sheet->range.rowi -
 594                                        var_sheet->range.row0 );
 595       }
 596       break;
 597       case PAGE_DATA_SHEET:
 598         break;
 599       default:
 600         g_assert_not_reached ();
 601     }
 602 }
 603
 604
 605 /* Insert a new variable before the current row in the variable sheet,
 606    or before the current column in the data sheet, whichever is selected */
 607 static void
 608 insert_variable (GtkCheckMenuItem *m, gpointer data)
 609 {
 610   struct data_editor *de = data;
 611   gint posn;
 612
 613   GtkWidget *notebook = get_widget_assert (de->xml, "notebook");
 614
 615   GtkSheet *var_sheet =
 616     GTK_SHEET (get_widget_assert (de->xml, "variable_sheet"));
 617
 618   PsppireVarStore *vs = PSPPIRE_VAR_STORE
 619     (gtk_sheet_get_model (var_sheet) );
 620
 621   switch ( gtk_notebook_get_current_page ( GTK_NOTEBOOK (notebook)) )
 622     {
 623     case PAGE_VAR_SHEET:
 624       posn = var_sheet->active_cell.row;
 625       break;
 626     case PAGE_DATA_SHEET:
 627       {
 628         GtkSheet *data_sheet =
 629           GTK_SHEET (get_widget_assert (de->xml, "data_sheet"));
 630
 631         if ( data_sheet->state == GTK_SHEET_COLUMN_SELECTED )
 632           posn = data_sheet->range.col0;
 633         else
 634           posn = data_sheet->active_cell.col;
 635       }
 636       break;
 637     default:
 638       g_assert_not_reached ();
 639     }
 640
 641   psppire_dict_insert_variable (vs->dict, posn, NULL);
 642 }
 643
 644 /* Callback for when the dictionary changes its split variables */
 645 static void
 646 on_split_change (PsppireDict *dict, gpointer data)
 647 {
 648   struct data_editor *de = data;
 649
 650   size_t n_split_vars = dict_get_split_cnt (dict->dict);
 651
 652   GtkWidget *split_status_area =
 653     get_widget_assert (de->xml, "split-file-status-area");
 654
 655   if ( n_split_vars == 0 )
 656     {
 657       gtk_label_set_text (GTK_LABEL (split_status_area), _("No Split"));
 658     }
 659   else
 660     {
 661       gint i;
 662       GString *text;
 663       struct variable *const * split_vars = dict_get_split_vars (dict->dict);
 664
 665       text = g_string_new (_("Split by "));
 666
 667       for (i = 0 ; i < n_split_vars - 1; ++i )
 668         {
 669           g_string_append_printf (text, "%s, ", var_get_name (split_vars[i]));
 670         }
 671       g_string_append (text, var_get_name (split_vars[i]));
 672
 673       gtk_label_set_text (GTK_LABEL (split_status_area), text->str);
 674
 675       g_string_free (text, TRUE);
 676     }
 677 }
 678
 679
 680 /* Callback for when the dictionary changes its filter variable */
 681 static void
 682 on_filter_change (GObject *o, gint filter_index, gpointer data)
 683 {
 684   struct data_editor *de = data;
 685   GtkWidget *filter_status_area =
 686     get_widget_assert (de->xml, "filter-use-status-area");
 687
 688   if ( filter_index == -1 )
 689     {
 690       gtk_label_set_text (GTK_LABEL (filter_status_area), _("Filter off"));
 691     }
 692   else
 693     {
 694       GtkSheet *var_sheet =
 695         GTK_SHEET (get_widget_assert (de->xml, "variable_sheet"));
 696
 697       PsppireVarStore *vs = PSPPIRE_VAR_STORE
 698         (gtk_sheet_get_model (var_sheet) );
 699
 700       struct variable *var = psppire_dict_get_variable (vs->dict,
 701                                                         filter_index);
 702
 703       gchar *text = g_strdup_printf (_("Filter by %s"), var_get_name (var));
 704
 705       gtk_label_set_text (GTK_LABEL (filter_status_area), text);
 706
 707       g_free (text);
 708     }
 709 }
 710
 711 /* Callback for when the dictionary changes its weights */
 712 static void
 713 on_weight_change (GObject *o, gint weight_index, gpointer data)
 714 {
 715   struct data_editor *de = data;
 716   GtkWidget *weight_status_area =
 717     get_widget_assert (de->xml, "weight-status-area");
 718
 719   if ( weight_index == -1 )
 720     {
 721       gtk_label_set_text (GTK_LABEL (weight_status_area), _("Weights off"));
 722     }
 723   else
 724     {
 725       GtkSheet *var_sheet =
 726         GTK_SHEET (get_widget_assert (de->xml, "variable_sheet"));
 727
 728       PsppireVarStore *vs = PSPPIRE_VAR_STORE
 729         (gtk_sheet_get_model (var_sheet) );
 730
 731       struct variable *var = psppire_dict_get_variable (vs->dict,
 732                                                         weight_index);
 733
 734       gchar *text = g_strdup_printf (_("Weight by %s"), var_get_name (var));
 735
 736       gtk_label_set_text (GTK_LABEL (weight_status_area), text);
 737
 738       g_free (text);
 739     }
 740 }
 741
 742 static void
 743 weight_cases_dialog (GObject *o, gpointer data)
 744 {
 745   gint response;
 746   struct data_editor *de = data;
 747   GtkSheet *var_sheet =
 748     GTK_SHEET (get_widget_assert (de->xml, "variable_sheet"));
 749
 750
 751   GladeXML *xml = glade_xml_new (PKGDATADIR "/psppire.glade",
 752                                  "weight-cases-dialog", NULL);
 753
 754
 755   GtkWidget *treeview =  get_widget_assert (xml, "treeview");
 756   GtkWidget *entry =  get_widget_assert (xml, "entry1");
 757
 758
 759   PsppireVarStore *vs = PSPPIRE_VAR_STORE (gtk_sheet_get_model (var_sheet));
 760
 761   PsppireVarSelect *select = psppire_var_select_new (treeview,
 762                                                      entry, vs->dict);
 763
 764
 765   PsppireDialog *dialog = create_weight_dialog (select, xml);
 766
 767   response = psppire_dialog_run (dialog);
 768
 769   g_object_unref (xml);
 770
 771   switch (response)
 772     {
 773     case GTK_RESPONSE_OK:
 774     {
 775       struct getl_interface *sss ;
 776       const GList *list = psppire_var_select_get_variables (select);
 777
 778       g_assert ( g_list_length ((GList *)list) <= 1 );
 779
 780       if ( list == NULL)
 781           {
 782             sss = create_syntax_string_source ("WEIGHT OFF.");
 783           }
 784       else
 785         {
 786           struct variable *var = list->data;
 787
 788             sss = create_syntax_string_source ("WEIGHT BY %s.\n",
 789                                                var_get_name (var));
 790           }
 791
 792         execute_syntax (sss);
 793         }
 794       break;
 795     case PSPPIRE_RESPONSE_PASTE:
 796       {
 797         struct syntax_editor *se =  (struct syntax_editor *) window_create (WINDOW_SYNTAX, NULL);
 798
 799         const GList *list = psppire_var_select_get_variables (select);
 800
 801         g_assert ( g_list_length ((GList *)list) <= 1 );
 802
 803         if ( list == NULL)
 804           {
 805             gtk_text_buffer_insert_at_cursor (se->buffer, "WEIGHT OFF.", -1);
 806           }
 807         else
 808           {
 809             struct variable *var = list->data;
 810
 811             gchar *text = g_strdup_printf ("WEIGHT BY %s.",
 812                                            var_get_name (var));
 813
 814             gtk_text_buffer_insert_at_cursor (se->buffer,
 815                                               text, -1);
 816
 817             g_free (text);
 818           }
 819       }
 820       break;
 821     default:
 822       break;
 823     }
 824 }
 825
 826
 827
 828 \f
 829 static void data_save_as_dialog (GtkAction *, struct data_editor *de);
 830 static void new_file (GtkAction *, struct editor_window *de);
 831 static void open_data_dialog (GtkAction *, struct data_editor *de);
 832 static void data_save (GtkAction *action, struct data_editor *e);
 833
 834
 835 /* Create the GtkActions and connect to their signals */
 836 static void
 837 register_data_editor_actions (struct data_editor *de)
 838 {
 839   de->action_data_open =
 840     gtk_action_new ("data-open-dialog",
 841                     _("Open"),
 842                     _("Open a data file"),
 843                     "gtk-open");
 844
 845   g_signal_connect (de->action_data_open, "activate",
 846                     G_CALLBACK (open_data_dialog), de);
 847
 848
 849   de->action_data_save = gtk_action_new ("data-save",
 850                                             _("Save"),
 851                                             _("Save data to file"),
 852                                             "gtk-save");
 853
 854   g_signal_connect (de->action_data_save, "activate",
 855                     G_CALLBACK (data_save), de);
 856
 857
 858
 859   de->action_data_save_as = gtk_action_new ("data-save-as-dialog",
 860                                             _("Save As"),
 861                                             _("Save data to file"),
 862                                             "gtk-save");
 863
 864   g_signal_connect (de->action_data_save_as, "activate",
 865                     G_CALLBACK (data_save_as_dialog), de);
 866
 867   de->action_data_new =
 868     gtk_action_new ("data-new",
 869                     _("New"),
 870                     _("New data file"),
 871                     NULL);
 872
 873   g_signal_connect (de->action_data_new, "activate",
 874                     G_CALLBACK (new_file), de);
 875 }
 876
 877 /* Returns true if NAME has a suffix which might denote a PSPP file */
 878 static gboolean
 879 name_has_suffix (const gchar *name)
 880 {
 881   if ( g_str_has_suffix (name, ".sav"))
 882     return TRUE;
 883   if ( g_str_has_suffix (name, ".SAV"))
 884     return TRUE;
 885   if ( g_str_has_suffix (name, ".por"))
 886     return TRUE;
 887   if ( g_str_has_suffix (name, ".POR"))
 888     return TRUE;
 889
 890   return FALSE;
 891 }
 892
 893 /* Append SUFFIX to the filename of DE */
 894 static void
 895 append_filename_suffix (struct data_editor *de, const gchar *suffix)
 896 {
 897   if ( ! name_has_suffix (de->file_name))
 898     {
 899       gchar *s = de->file_name;
 900       de->file_name = g_strconcat (de->file_name, suffix, NULL);
 901       g_free (s);
 902     }
 903 }
 904
 905 /* Save DE to file */
 906 static void
 907 save_file (struct data_editor *de)
 908 {
 909   struct getl_interface *sss;
 910
 911   g_assert (de->file_name);
 912
 913   if ( de->save_as_portable )
 914     {
 915       append_filename_suffix (de, ".por");
 916       sss = create_syntax_string_source ("EXPORT OUTFILE='%s'.",
 917                                          de->file_name);
 918     }
 919   else
 920     {
 921       append_filename_suffix (de, ".sav");
 922       sss = create_syntax_string_source ("SAVE OUTFILE='%s'.",
 923                                          de->file_name);
 924     }
 925
 926   execute_syntax (sss);
 927 }
 928
 929
 930 /* Callback for data_save action.
 931    If there's an existing file name, then just save,
 932    otherwise prompt for a file name, then save */
 933 static void
 934 data_save (GtkAction *action, struct data_editor *de)
 935 {
 936   if ( de->file_name)
 937     save_file (de);
 938   else
 939     data_save_as_dialog (action, de);
 940 }
 941
 942
 943 /* Callback for data_save_as action. Prompt for a filename and save */
 944 static void
 945 data_save_as_dialog (GtkAction *action, struct data_editor *de)
 946 {
 947   struct editor_window *e = (struct editor_window *) de;
 948
 949   GtkWidget *button_sys;
 950   GtkWidget *dialog =
 951     gtk_file_chooser_dialog_new (_("Save"),
 952                                  GTK_WINDOW (e->window),
 953                                  GTK_FILE_CHOOSER_ACTION_SAVE,
 954                                  GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
 955                                  GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
 956                                  NULL);
 957
 958   GtkFileFilter *filter = gtk_file_filter_new ();
 959   gtk_file_filter_set_name (filter, _("System Files (*.sav)"));
 960   gtk_file_filter_add_pattern (filter, "*.sav");
 961   gtk_file_filter_add_pattern (filter, "*.SAV");
 962   gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter);
 963
 964   filter = gtk_file_filter_new ();
 965   gtk_file_filter_set_name (filter, _("Portable Files (*.por) "));
 966   gtk_file_filter_add_pattern (filter, "*.por");
 967   gtk_file_filter_add_pattern (filter, "*.POR");
 968   gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter);
 969
 970   filter = gtk_file_filter_new ();
 971   gtk_file_filter_set_name (filter, _("All Files"));
 972   gtk_file_filter_add_pattern (filter, "*");
 973   gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter);
 974
 975   {
 976     GtkWidget *button_por;
 977     GtkWidget *vbox = gtk_vbox_new (TRUE, 5);
 978     button_sys =
 979       gtk_radio_button_new_with_label (NULL, _("System File"));
 980
 981     button_por =
 982       gtk_radio_button_new_with_label
 983       (gtk_radio_button_get_group (GTK_RADIO_BUTTON(button_sys)),
 984        _("Portable File"));
 985
 986     gtk_box_pack_start_defaults (GTK_BOX (vbox), button_sys);
 987     gtk_box_pack_start_defaults (GTK_BOX (vbox), button_por);
 988
 989     gtk_widget_show_all (vbox);
 990
 991     gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER(dialog), vbox);
 992   }
 993
 994   switch (gtk_dialog_run (GTK_DIALOG (dialog)))
 995     {
 996     case GTK_RESPONSE_ACCEPT:
 997       {
 998         g_free (de->file_name);
 999
1000         de->file_name =
1001           gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
1002
1003         de->save_as_portable =
1004           ! gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button_sys));
1005
1006         save_file (de);
1007
1008         window_set_name_from_filename (e, de->file_name);
1009       }
1010       break;
1011     default:
1012       break;
1013     }
1014
1015   gtk_widget_destroy (dialog);
1016 }
1017
1018
1019 /* Callback for data_new action.
1020    Performs the NEW FILE command */
1021 static void
1022 new_file (GtkAction *action, struct editor_window *de)
1023 {
1024   struct getl_interface *sss =
1025     create_syntax_string_source ("NEW FILE.");
1026
1027   execute_syntax (sss);
1028
1029   default_window_name (de);
1030 }
1031
1032
1033 /* Callback for the data_open action.
1034    Prompts for a filename and opens it */
1035 static void
1036 open_data_dialog (GtkAction *action, struct data_editor *de)
1037 {
1038   struct editor_window *e = (struct editor_window *) de;
1039
1040   GtkWidget *dialog =
1041     gtk_file_chooser_dialog_new (_("Open"),
1042                                  GTK_WINDOW (e->window),
1043                                  GTK_FILE_CHOOSER_ACTION_OPEN,
1044                                  GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
1045                                  GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
1046                                  NULL);
1047
1048   GtkFileFilter *filter = gtk_file_filter_new ();
1049   gtk_file_filter_set_name (filter, _("System Files (*.sav)"));
1050   gtk_file_filter_add_pattern (filter, "*.sav");
1051   gtk_file_filter_add_pattern (filter, "*.SAV");
1052   gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter);
1053
1054   filter = gtk_file_filter_new ();
1055   gtk_file_filter_set_name (filter, _("Portable Files (*.por) "));
1056   gtk_file_filter_add_pattern (filter, "*.por");
1057   gtk_file_filter_add_pattern (filter, "*.POR");
1058   gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter);
1059
1060   filter = gtk_file_filter_new ();
1061   gtk_file_filter_set_name (filter, _("All Files"));
1062   gtk_file_filter_add_pattern (filter, "*");
1063   gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter);
1064
1065   switch (gtk_dialog_run (GTK_DIALOG (dialog)))
1066     {
1067     case GTK_RESPONSE_ACCEPT:
1068       {
1069         struct getl_interface *sss;
1070         g_free (de->file_name);
1071         de->file_name =
1072           gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
1073
1074         sss = create_syntax_string_source ("GET FILE='%s'.", de->file_name);
1075
1076         execute_syntax (sss);
1077
1078         window_set_name_from_filename (e, de->file_name);
1079       }
1080       break;
1081     default:
1082       break;
1083     }
1084
1085   gtk_widget_destroy (dialog);
1086 }
1087
1088
1089
1090