src/ui/gui/menu-actions.c

   1 /*
   2     PSPPIRE --- A Graphical User Interface for PSPP
   3     Copyright (C) 2004, 2005  Free Software Foundation
   4     Written by John Darrington
   5
   6     This program is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     This program is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with this program; if not, write to the Free Software
  18     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19     02110-1301, USA. */
  20
  21 #include <config.h>
  22 #include <stdlib.h>
  23
  24 #include <data/file-handle-def.h>
  25 #include <data/sys-file-reader.h>
  26 #include <data/case.h>
  27
  28 #include <glade/glade.h>
  29 #include <gtk/gtk.h>
  30
  31 #include <gtksheet/gtksheet.h>
  32 #include "helper.h"
  33 #include "menu-actions.h"
  34 #include "psppire-variable.h"
  35 #include "psppire-dict.h"
  36
  37 #include "var-sheet.h"
  38 #include "data-sheet.h"
  39
  40 #include "psppire-var-store.h"
  41 #include "psppire-data-store.h"
  42
  43 #define _(A) A
  44 #define N_(A) A
  45
  46
  47 extern GladeXML *xml;
  48
  49
  50 extern PsppireDict *the_dictionary ;
  51 extern PsppireCaseArray *the_cases ;
  52
  53
  54 static struct file_handle *psppire_handle = 0;
  55
  56 static const gchar handle_name[] = "psppire_handle";
  57
  58 static const gchar untitled[] = _("Untitled");
  59
  60 static const gchar window_title[]=_("PSPP Data Editor");
  61
  62
  63 static void
  64 psppire_set_window_title(const gchar *text)
  65 {
  66   GtkWidget *data_editor = get_widget_assert(xml, "data_editor");
  67
  68   gchar *title = g_strdup_printf("%s --- %s", text, window_title);
  69
  70   gtk_window_set_title(GTK_WINDOW(data_editor), title);
  71
  72   g_free(title);
  73 }
  74
  75 void
  76 on_new1_activate                       (GtkMenuItem     *menuitem,
  77                                         gpointer         user_data)
  78 {
  79   psppire_dict_clear(the_dictionary);
  80   psppire_case_array_clear(the_cases);
  81
  82   psppire_set_window_title(untitled);
  83
  84   if (psppire_handle)
  85     fh_free(psppire_handle);
  86   psppire_handle = 0 ;
  87 }
  88
  89 static gboolean
  90 populate_case_from_reader(struct ccase *c, gpointer aux)
  91 {
  92   struct sfm_reader *reader = aux;
  93
  94   return sfm_read_case(reader, c);
  95 }
  96
  97
  98 void
  99 on_open1_activate                      (GtkMenuItem     *menuitem,
 100                                         gpointer         user_data)
 101 {
 102   bool finished = FALSE;
 103
 104   GtkWidget *dialog;
 105   GtkWidget *data_editor  = get_widget_assert(xml, "data_editor");
 106   GtkFileFilter *filter ;
 107
 108   dialog = gtk_file_chooser_dialog_new (_("Open"),
 109                                         GTK_WINDOW(data_editor),
 110                                         GTK_FILE_CHOOSER_ACTION_OPEN,
 111                                         GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
 112                                         GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
 113                                         NULL);
 114
 115   filter = gtk_file_filter_new();
 116   gtk_file_filter_set_name(filter, _("System Files (*.sav)"));
 117   gtk_file_filter_add_pattern(filter, "*.sav");
 118   gtk_file_filter_add_pattern(filter, "*.SAV");
 119   gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), filter);
 120
 121   filter = gtk_file_filter_new();
 122   gtk_file_filter_set_name(filter, _("Portable Files (*.por) "));
 123   gtk_file_filter_add_pattern(filter, "*.por");
 124   gtk_file_filter_add_pattern(filter, "*.POR");
 125   gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), filter);
 126
 127   filter = gtk_file_filter_new();
 128   gtk_file_filter_set_name(filter, _("All Files"));
 129   gtk_file_filter_add_pattern(filter, "*");
 130   gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), filter);
 131
 132
 133   do {
 134
 135     if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
 136       {
 137         PsppireVarStore *var_store ;
 138         PsppireDataStore *data_store ;
 139         struct dictionary *new_dict;
 140         struct sfm_read_info ri;
 141         struct sfm_reader *reader ;
 142
 143         GtkWidget *data_sheet = get_widget_assert(xml, "data_sheet");
 144         GtkWidget *var_sheet = get_widget_assert(xml, "variable_sheet");
 145         gchar *filename;
 146
 147         g_assert(data_sheet);
 148         g_assert(var_sheet);
 149
 150         filename = gtk_file_chooser_get_filename
 151           (GTK_FILE_CHOOSER (dialog));
 152
 153         if ( psppire_handle )
 154           fh_free(psppire_handle);
 155
 156         psppire_handle =
 157           fh_create_file (handle_name, filename, fh_default_properties());
 158
 159         if ( !psppire_handle )
 160           {
 161             g_warning("Cannot read handle for reading system file \"%s\"\n",
 162                       filename);
 163             continue;
 164           }
 165
 166
 167         reader = sfm_open_reader (psppire_handle, &new_dict, &ri);
 168
 169         if ( ! reader )
 170           continue;
 171
 172         the_dictionary = psppire_dict_new_from_dict(new_dict);
 173
 174         var_store =
 175           PSPPIRE_VAR_STORE(gtk_sheet_get_model(GTK_SHEET(var_sheet)));
 176
 177         psppire_var_store_set_dictionary(var_store, the_dictionary);
 178
 179
 180         data_store =
 181           PSPPIRE_DATA_STORE(gtk_sheet_get_model(GTK_SHEET(data_sheet)));
 182
 183
 184         psppire_data_store_set_dictionary(data_store,
 185                                           the_dictionary);
 186
 187         psppire_case_array_clear(data_store->cases);
 188
 189
 190         psppire_set_window_title(basename(filename));
 191
 192         g_free (filename);
 193
 194         {
 195           const int ni = dict_get_next_value_idx(the_dictionary->dict);
 196           gint case_num;
 197           if ( ni == 0 )
 198             goto done;
 199
 200
 201           for(case_num=0;;case_num++)
 202             {
 203               if (!psppire_case_array_add_case(the_cases,
 204                                                populate_case_from_reader,
 205                                                reader))
 206                 break;
 207             }
 208         }
 209
 210         sfm_close_reader(reader);
 211         finished = TRUE;
 212       }
 213     else
 214       {
 215         finished = TRUE;
 216       }
 217   } while ( ! finished ) ;
 218
 219  done:
 220   gtk_widget_destroy (dialog);
 221 }
 222
 223
 224 /* Re initialise HANDLE, by interrogating the user for a new file name */
 225 static void
 226 recreate_save_handle(struct file_handle **handle)
 227 {
 228   GtkWidget *dialog;
 229
 230   GtkWidget *data_editor  = get_widget_assert(xml, "data_editor");
 231
 232   dialog = gtk_file_chooser_dialog_new (_("Save Data As"),
 233                                         GTK_WINDOW(data_editor),
 234                                         GTK_FILE_CHOOSER_ACTION_SAVE,
 235                                         GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
 236                                         GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
 237                                         NULL);
 238
 239   if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
 240     {
 241       char *filename = gtk_file_chooser_get_filename
 242         (GTK_FILE_CHOOSER (dialog));
 243
 244 #if 0
 245       if ( *handle )
 246         destroy_file_handle(*handle, 0);
 247 #endif
 248       *handle = fh_create_file (handle_name, filename, fh_default_properties());
 249
 250       psppire_set_window_title(basename(filename));
 251
 252       g_free (filename);
 253     }
 254
 255   gtk_widget_destroy (dialog);
 256 }
 257
 258 void
 259 on_save1_activate                      (GtkMenuItem     *menuitem,
 260                                         gpointer         user_data)
 261 {
 262   GtkSheet *data_sheet ;
 263   PsppireDataStore *data_store ;
 264
 265   if ( ! psppire_handle )
 266     recreate_save_handle(&psppire_handle);
 267
 268   data_sheet = GTK_SHEET(get_widget_assert(xml, "data_sheet"));
 269   data_store = PSPPIRE_DATA_STORE(gtk_sheet_get_model(data_sheet));
 270
 271   if ( psppire_handle )
 272     psppire_data_store_create_system_file(data_store,
 273                                        psppire_handle);
 274 }
 275
 276
 277 void
 278 on_save_as1_activate                   (GtkMenuItem     *menuitem,
 279                                         gpointer         user_data)
 280 {
 281   GtkSheet *data_sheet ;
 282   PsppireDataStore *data_store ;
 283
 284   recreate_save_handle(&psppire_handle);
 285   if ( ! psppire_handle )
 286     return ;
 287
 288   data_sheet = GTK_SHEET(get_widget_assert(xml, "data_sheet"));
 289   data_store = PSPPIRE_DATA_STORE(gtk_sheet_get_model(data_sheet));
 290
 291   if ( psppire_handle )
 292     psppire_data_store_create_system_file(data_store,
 293                                        psppire_handle);
 294 }
 295
 296
 297 void
 298 on_quit1_activate                      (GtkMenuItem     *menuitem,
 299                                         gpointer         user_data)
 300 {
 301   gtk_main_quit();
 302 }
 303
 304
 305 void
 306 on_cut1_activate                       (GtkMenuItem     *menuitem,
 307                                         gpointer         user_data)
 308 {
 309
 310 }
 311
 312
 313 void
 314 on_copy1_activate                      (GtkMenuItem     *menuitem,
 315                                         gpointer         user_data)
 316 {
 317
 318 }
 319
 320
 321 void
 322 on_paste1_activate                     (GtkMenuItem     *menuitem,
 323                                         gpointer         user_data)
 324 {
 325
 326 }
 327
 328
 329 void
 330 on_insert1_activate                    (GtkMenuItem     *menuitem,
 331                                         gpointer         user_data)
 332 {
 333   GtkNotebook *notebook = GTK_NOTEBOOK(get_widget_assert(xml, "notebook1"));
 334   gint page = -1;
 335
 336   page = gtk_notebook_get_current_page(notebook);
 337
 338   switch (page)
 339     {
 340     case PAGE_DATA_SHEET:
 341       {
 342         GtkSheet *data_sheet = GTK_SHEET(get_widget_assert(xml, "data_sheet"));
 343         PsppireDataStore *data_store =
 344           PSPPIRE_DATA_STORE(gtk_sheet_get_model(data_sheet));
 345
 346         psppire_case_array_insert_case(data_store->cases, data_sheet->range.row0);
 347       }
 348       break;
 349     case PAGE_VAR_SHEET:
 350       {
 351         GtkSheet *var_sheet =
 352           GTK_SHEET(get_widget_assert(xml, "variable_sheet"));
 353
 354         PsppireVarStore *var_store =
 355           PSPPIRE_VAR_STORE(gtk_sheet_get_model(var_sheet));
 356
 357         psppire_dict_insert_variable(var_store->dict, var_sheet->range.row0, 0);
 358       }
 359       break;
 360     }
 361 }
 362
 363 void
 364 on_delete1_activate                    (GtkMenuItem     *menuitem,
 365                                         gpointer         user_data)
 366 {
 367   gint page = -1;
 368   GtkWidget *notebook = get_widget_assert(xml, "notebook1");
 369
 370   page = gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook));
 371   switch ( page)
 372     {
 373     case PAGE_DATA_SHEET:
 374       {
 375         GtkSheet *data_sheet = GTK_SHEET(get_widget_assert(xml, "data_sheet"));
 376         PsppireDataStore *data_store =
 377           PSPPIRE_DATA_STORE(gtk_sheet_get_model(data_sheet));
 378
 379         psppire_case_array_delete_cases(data_store->cases,
 380                                     data_sheet->range.row0,
 381                                     1 + data_sheet->range.rowi
 382                                     - data_sheet->range.row0  );
 383       }
 384       break;
 385     case PAGE_VAR_SHEET:
 386       {
 387         GtkSheet *var_sheet =
 388           GTK_SHEET(get_widget_assert(xml, "variable_sheet"));
 389
 390         PsppireVarStore *var_store =
 391           PSPPIRE_VAR_STORE(gtk_sheet_get_model(var_sheet));
 392
 393         psppire_dict_delete_variables(var_store->dict,
 394                                    var_sheet->range.row0,
 395                                    1 + var_sheet->range.rowi
 396                                    - var_sheet->range.row0  );
 397       }
 398       break;
 399     }
 400 }
 401
 402
 403 void
 404 on_about1_activate(GtkMenuItem     *menuitem,
 405                    gpointer         user_data)
 406 {
 407   GtkWidget *about =  get_widget_assert(xml, "aboutdialog1");
 408
 409
 410   GdkPixbuf *pb  = gdk_pixbuf_new_from_file_at_size( "pspplogo.png", 64, 64, 0);
 411
 412   gtk_about_dialog_set_logo(GTK_ABOUT_DIALOG(about), pb);
 413
 414   gtk_widget_show(about);
 415
 416   gtk_window_set_transient_for(GTK_WINDOW(about),
 417                                GTK_WINDOW(get_widget_assert(xml, "data_editor")));
 418 }
 419
 420
 421
 422 void
 423 on_toolbars1_activate
 424                      (GtkMenuItem     *menuitem,
 425                                         gpointer         user_data)
 426 {
 427
 428
 429 }
 430
 431 void
 432 on_value_labels1_activate(GtkCheckMenuItem     *menuitem,
 433                           gpointer         user_data)
 434 {
 435   GtkSheet *data_sheet = GTK_SHEET(get_widget_assert(xml, "data_sheet"));
 436   PsppireDataStore *ds = PSPPIRE_DATA_STORE(gtk_sheet_get_model(data_sheet));
 437
 438   psppire_data_store_show_labels(ds,
 439                               gtk_check_menu_item_get_active(menuitem));
 440 }
 441
 442 void
 443 on_status_bar1_activate(GtkCheckMenuItem     *menuitem,
 444  gpointer         user_data)
 445 {
 446
 447   if ( gtk_check_menu_item_get_active(menuitem) )
 448     gtk_widget_show(get_widget_assert(xml, "statusbar1"));
 449   else
 450     gtk_widget_hide(get_widget_assert(xml, "statusbar1"));
 451 }
 452
 453 void
 454 on_grid_lines1_activate(GtkCheckMenuItem     *menuitem,
 455  gpointer         user_data)
 456 {
 457
 458   const bool grid_visible = gtk_check_menu_item_get_active(menuitem);
 459
 460   gtk_sheet_show_grid(GTK_SHEET(get_widget_assert(xml, "variable_sheet")),
 461                       grid_visible);
 462
 463   gtk_sheet_show_grid(GTK_SHEET(get_widget_assert(xml, "data_sheet")),
 464                       grid_visible);
 465 }
 466
 467
 468 void
 469 on_fonts1_activate(GtkMenuItem     *menuitem,
 470  gpointer         user_data)
 471 {
 472   static GtkWidget *dialog = 0 ;
 473   if ( !dialog )
 474     dialog   = gtk_font_selection_dialog_new(_("Font Selection"));
 475
 476   gtk_window_set_transient_for(GTK_WINDOW(dialog),
 477                                GTK_WINDOW(get_widget_assert(xml, "data_editor")));
 478
 479
 480   if ( GTK_RESPONSE_OK == gtk_dialog_run(GTK_DIALOG(dialog)) )
 481     {
 482       GtkSheet *data_sheet =
 483         GTK_SHEET(get_widget_assert(xml, "data_sheet"));
 484
 485       GtkSheet *var_sheet =
 486         GTK_SHEET(get_widget_assert(xml, "variable_sheet"));
 487
 488       PsppireDataStore *ds = PSPPIRE_DATA_STORE(gtk_sheet_get_model(data_sheet));
 489       PsppireVarStore *vs = PSPPIRE_VAR_STORE(gtk_sheet_get_model(var_sheet));
 490
 491       const gchar *font = gtk_font_selection_dialog_get_font_name
 492         (GTK_FONT_SELECTION_DIALOG(dialog));
 493
 494       PangoFontDescription* font_desc =
 495         pango_font_description_from_string(font);
 496
 497       psppire_var_store_set_font(vs, font_desc);
 498       psppire_data_store_set_font(ds, font_desc);
 499     }
 500
 501   gtk_widget_hide(dialog);
 502
 503 }
 504
 505
 506 static GtkWidget *menuitems[2];
 507 static GtkNotebook *notebook = 0;
 508
 509 static void
 510 switch_menus(gint page)
 511 {
 512   switch (page)
 513     {
 514     case PAGE_VAR_SHEET:
 515       gtk_widget_hide(menuitems[PAGE_VAR_SHEET]);
 516       gtk_widget_show(menuitems[PAGE_DATA_SHEET]);
 517       break;
 518     case PAGE_DATA_SHEET:
 519       gtk_widget_show(menuitems[PAGE_VAR_SHEET]);
 520       gtk_widget_hide(menuitems[PAGE_DATA_SHEET]);
 521       break;
 522     default:
 523       g_assert_not_reached();
 524       break;
 525     }
 526 }
 527
 528
 529 void
 530 select_sheet(gint page)
 531 {
 532   gtk_notebook_set_current_page(notebook, page);
 533   switch_menus(page);
 534 }
 535
 536
 537
 538 static void
 539 data_var_select(GtkNotebook *notebook,
 540                 GtkNotebookPage *page,
 541                 guint page_num,
 542                 gpointer user_data)
 543 {
 544   switch_menus(page_num);
 545 }
 546
 547 static void
 548 var_data_selection_init()
 549 {
 550   notebook = GTK_NOTEBOOK(get_widget_assert(xml, "notebook1"));
 551   menuitems[PAGE_DATA_SHEET] = get_widget_assert(xml, "data1");
 552   menuitems[PAGE_VAR_SHEET] = get_widget_assert(xml, "variables1");
 553
 554   gtk_notebook_set_current_page(notebook, PAGE_DATA_SHEET);
 555   gtk_widget_hide(menuitems[PAGE_DATA_SHEET]);
 556   gtk_widget_show(menuitems[PAGE_VAR_SHEET]);
 557
 558
 559   g_signal_connect(G_OBJECT(notebook), "switch-page",
 560                    G_CALLBACK(data_var_select), 0);
 561
 562 }
 563
 564
 565 void
 566 on_data1_activate(GtkMenuItem     *menuitem,
 567                   gpointer         user_data)
 568 {
 569   select_sheet(PAGE_DATA_SHEET);
 570 }
 571
 572
 573 void
 574 on_variables1_activate(GtkMenuItem     *menuitem,
 575                   gpointer         user_data)
 576 {
 577   select_sheet(PAGE_VAR_SHEET);
 578 }
 579
 580
 581 /* Callback which occurs when gtk_main is entered */
 582 gboolean
 583 callbacks_on_init(gpointer data)
 584 {
 585   psppire_set_window_title(untitled);
 586
 587   var_data_selection_init();
 588
 589   return FALSE;
 590 }