src/ui/gui/menu-actions.c

   1 /*
   2     PSPPIRE --- A Graphical User Interface for PSPP
   3     Copyright (C) 2004, 2005, 2006  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 #include <gettext.h>
  24 #define _(msgid) gettext (msgid)
  25 #define N_(msgid) msgid
  26
  27 #include <math/sort.h>
  28
  29 #include <data/casefile.h>
  30 #include <data/file-handle-def.h>
  31 #include <data/sys-file-reader.h>
  32 #include <data/case.h>
  33
  34 #include <glade/glade.h>
  35 #include <gtk/gtk.h>
  36
  37 #include <libpspp/str.h>
  38
  39 #include <gtksheet/gtksheet.h>
  40 #include "helper.h"
  41 #include "menu-actions.h"
  42 #include "psppire-variable.h"
  43 #include "psppire-dict.h"
  44
  45 #include "var-sheet.h"
  46 #include "data-sheet.h"
  47
  48 #include "psppire-var-store.h"
  49 #include "psppire-data-store.h"
  50
  51 #include "sort-cases-dialog.h"
  52
  53
  54 extern GladeXML *xml;
  55
  56
  57 extern PsppireDict *the_dictionary ;
  58
  59 static struct file_handle *psppire_handle = 0;
  60
  61 static const gchar handle_name[] = "psppire_handle";
  62
  63 static const gchar untitled[] = N_("Untitled");
  64
  65 static const gchar window_title[] = N_("PSPP Data Editor");
  66
  67
  68 /* Sets the title bar to TEXT */
  69 static void
  70 psppire_set_window_title(const gchar *text)
  71 {
  72   GtkWidget *data_editor = get_widget_assert(xml, "data_editor");
  73
  74   gchar *title = g_strdup_printf("%s --- %s", text, gettext(window_title));
  75
  76   gtk_window_set_title(GTK_WINDOW(data_editor), title);
  77
  78   g_free(title);
  79 }
  80
  81 /* Clear the active file and set the data and var sheets to
  82    reflect this.
  83  */
  84 gboolean
  85 clear_file(void)
  86 {
  87   PsppireDataStore *data_store ;
  88   GtkSheet *data_sheet = GTK_SHEET(get_widget_assert(xml, "data_sheet"));
  89   GtkSheet *var_sheet = GTK_SHEET(get_widget_assert(xml, "variable_sheet"));
  90
  91   gtk_sheet_set_active_cell(data_sheet, -1, -1);
  92   gtk_sheet_set_active_cell(var_sheet, 0, 0);
  93
  94   if ( GTK_WIDGET_REALIZED(GTK_WIDGET(data_sheet)))
  95     gtk_sheet_unselect_range(data_sheet);
  96
  97   if ( GTK_WIDGET_REALIZED(GTK_WIDGET(var_sheet)))
  98     gtk_sheet_unselect_range(var_sheet);
  99
 100   gtk_sheet_moveto(data_sheet, 0, 0, 0.0, 0.0);
 101   gtk_sheet_moveto(var_sheet,  0, 0, 0.0, 0.0);
 102
 103   data_store = PSPPIRE_DATA_STORE(gtk_sheet_get_model(data_sheet));
 104
 105   psppire_data_store_clear(data_store);
 106
 107   psppire_set_window_title(gettext(untitled));
 108
 109   if (psppire_handle)
 110     fh_free(psppire_handle);
 111   psppire_handle = 0 ;
 112
 113   return TRUE;
 114 }
 115
 116 void
 117 on_new1_activate                       (GtkMenuItem     *menuitem,
 118                                         gpointer         user_data)
 119 {
 120   clear_file();
 121 }
 122
 123
 124
 125 /* Load a system file.
 126    Return TRUE if successfull
 127 */
 128 gboolean
 129 load_system_file(const gchar *file_name)
 130 {
 131   int var_cnt ;
 132
 133   PsppireVarStore *var_store ;
 134   PsppireDataStore *data_store ;
 135   struct dictionary *new_dict;
 136   struct sfm_read_info ri;
 137   struct sfm_reader *reader ;
 138
 139   GtkWidget *data_sheet = get_widget_assert(xml, "data_sheet");
 140   GtkWidget *var_sheet = get_widget_assert(xml, "variable_sheet");
 141
 142   g_assert(data_sheet);
 143   g_assert(var_sheet);
 144
 145   clear_file();
 146
 147   psppire_handle =
 148     fh_create_file (handle_name, file_name, fh_default_properties());
 149
 150   if ( !psppire_handle )
 151     {
 152       g_warning("Cannot read handle for reading system file \"%s\"\n",
 153                 file_name);
 154       return FALSE;
 155     }
 156
 157   reader = sfm_open_reader (psppire_handle, &new_dict, &ri);
 158
 159   if ( ! reader )
 160     return FALSE;
 161
 162   /* FIXME: We need a better way of updating a dictionary than this */
 163   the_dictionary = psppire_dict_new_from_dict(new_dict);
 164
 165   var_store =
 166     PSPPIRE_VAR_STORE(gtk_sheet_get_model(GTK_SHEET(var_sheet)));
 167
 168   psppire_var_store_set_dictionary(var_store, the_dictionary);
 169
 170
 171   data_store =
 172     PSPPIRE_DATA_STORE(gtk_sheet_get_model(GTK_SHEET(data_sheet)));
 173
 174   psppire_data_store_set_dictionary(data_store,
 175                                     the_dictionary);
 176
 177   psppire_set_window_title(basename(file_name));
 178
 179   var_cnt = dict_get_next_value_idx(the_dictionary->dict);
 180   if ( var_cnt == 0 )
 181     return FALSE;
 182
 183
 184   for(;;)
 185     {
 186       struct ccase c;
 187       case_create(&c, var_cnt);
 188       if ( 0 == sfm_read_case (reader, &c) )
 189         {
 190           case_destroy(&c);
 191           break;
 192         }
 193
 194       if ( !psppire_case_file_append_case(data_store->case_file, &c) )
 195         {
 196           g_warning("Cannot write case to casefile\n");
 197           break;
 198         }
 199       case_destroy(&c);
 200     }
 201
 202   sfm_close_reader(reader);
 203
 204   psppire_case_file_get_case_count(data_store->case_file);
 205
 206   return TRUE;
 207 }
 208
 209
 210 void
 211 on_open1_activate                      (GtkMenuItem     *menuitem,
 212                                         gpointer         user_data)
 213 {
 214   bool finished = FALSE;
 215
 216   GtkWidget *dialog;
 217   GtkWidget *data_editor  = get_widget_assert(xml, "data_editor");
 218   GtkFileFilter *filter ;
 219
 220   dialog = gtk_file_chooser_dialog_new (_("Open"),
 221                                         GTK_WINDOW(data_editor),
 222                                         GTK_FILE_CHOOSER_ACTION_OPEN,
 223                                         GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
 224                                         GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
 225                                         NULL);
 226
 227   filter = gtk_file_filter_new();
 228   gtk_file_filter_set_name(filter, _("System Files (*.sav)"));
 229   gtk_file_filter_add_pattern(filter, "*.sav");
 230   gtk_file_filter_add_pattern(filter, "*.SAV");
 231   gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), filter);
 232
 233   filter = gtk_file_filter_new();
 234   gtk_file_filter_set_name(filter, _("Portable Files (*.por) "));
 235   gtk_file_filter_add_pattern(filter, "*.por");
 236   gtk_file_filter_add_pattern(filter, "*.POR");
 237   gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), filter);
 238
 239   filter = gtk_file_filter_new();
 240   gtk_file_filter_set_name(filter, _("All Files"));
 241   gtk_file_filter_add_pattern(filter, "*");
 242   gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), filter);
 243
 244   do {
 245
 246     if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
 247       {
 248         gchar *file_name =
 249           gtk_file_chooser_get_filename(GTK_FILE_CHOOSER (dialog));
 250
 251         finished =  load_system_file(file_name) ;
 252
 253         g_free(file_name);
 254       }
 255     else
 256       finished = TRUE;
 257
 258   } while ( ! finished ) ;
 259
 260   gtk_widget_destroy (dialog);
 261 }
 262
 263
 264 /* Re initialise HANDLE, by interrogating the user for a new file name */
 265 static gboolean
 266 recreate_save_handle(struct file_handle **handle)
 267 {
 268   gint response;
 269   GtkWidget *dialog;
 270
 271   GtkWidget *data_editor  = get_widget_assert(xml, "data_editor");
 272
 273   dialog = gtk_file_chooser_dialog_new (_("Save Data As"),
 274                                         GTK_WINDOW(data_editor),
 275                                         GTK_FILE_CHOOSER_ACTION_SAVE,
 276                                         GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
 277                                         GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
 278                                         NULL);
 279
 280   response = gtk_dialog_run (GTK_DIALOG (dialog));
 281
 282   if (response == GTK_RESPONSE_ACCEPT)
 283     {
 284       char *file_name = gtk_file_chooser_get_filename
 285         (GTK_FILE_CHOOSER (dialog));
 286
 287
 288       if ( *handle )
 289         fh_free(*handle);
 290
 291       *handle = fh_create_file (handle_name, file_name,
 292                         fh_default_properties());
 293
 294       psppire_set_window_title(basename(file_name));
 295
 296       g_free (file_name);
 297     }
 298
 299   gtk_widget_destroy (dialog);
 300
 301   return ( response == GTK_RESPONSE_ACCEPT ) ;
 302 }
 303
 304 void
 305 on_save1_activate                      (GtkMenuItem     *menuitem,
 306                                         gpointer         user_data)
 307 {
 308   GtkSheet *data_sheet ;
 309   PsppireDataStore *data_store ;
 310
 311   if ( ! psppire_handle )
 312     {
 313       if ( ! recreate_save_handle(&psppire_handle) )
 314         return;
 315     }
 316
 317   data_sheet = GTK_SHEET(get_widget_assert(xml, "data_sheet"));
 318   data_store = PSPPIRE_DATA_STORE(gtk_sheet_get_model(data_sheet));
 319
 320   if ( psppire_handle )
 321     psppire_data_store_create_system_file(data_store,
 322                                        psppire_handle);
 323 }
 324
 325
 326 void
 327 on_save_as1_activate                   (GtkMenuItem     *menuitem,
 328                                         gpointer         user_data)
 329 {
 330   GtkSheet *data_sheet ;
 331   PsppireDataStore *data_store ;
 332
 333   if ( ! recreate_save_handle(&psppire_handle) )
 334     return ;
 335
 336   if ( ! psppire_handle )
 337     return ;
 338
 339   data_sheet = GTK_SHEET(get_widget_assert(xml, "data_sheet"));
 340   data_store = PSPPIRE_DATA_STORE(gtk_sheet_get_model(data_sheet));
 341
 342   if ( psppire_handle )
 343     psppire_data_store_create_system_file(data_store,
 344                                        psppire_handle);
 345 }
 346
 347
 348 void
 349 on_quit1_activate                      (GtkMenuItem     *menuitem,
 350                                         gpointer         user_data)
 351 {
 352   gtk_main_quit();
 353 }
 354
 355
 356 void
 357 on_clear_activate                    (GtkMenuItem     *menuitem,
 358                                       gpointer         user_data)
 359 {
 360   GtkNotebook *notebook = GTK_NOTEBOOK(get_widget_assert(xml, "notebook1"));
 361   gint page = -1;
 362
 363   page = gtk_notebook_get_current_page(notebook);
 364
 365   switch (page)
 366     {
 367     case PAGE_VAR_SHEET:
 368             break;
 369     case PAGE_DATA_SHEET:
 370       {
 371         GtkSheet *data_sheet = GTK_SHEET(get_widget_assert(xml, "data_sheet"));
 372         PsppireDataStore *data_store =
 373           PSPPIRE_DATA_STORE(gtk_sheet_get_model(data_sheet));
 374
 375
 376         switch ( data_sheet->state )
 377           {
 378           case GTK_SHEET_ROW_SELECTED:
 379             psppire_case_file_delete_cases(data_store->case_file,
 380                                            data_sheet->range.rowi
 381                                            - data_sheet->range.row0 + 1,
 382                                            data_sheet->range.row0);
 383             break;
 384           case GTK_SHEET_COLUMN_SELECTED:
 385             {
 386               gint fv;
 387               struct PsppireVariable *pv =
 388                 psppire_dict_get_variable(the_dictionary,
 389                                           data_sheet->range.col0);
 390               fv = psppire_variable_get_fv(pv);
 391
 392
 393               psppire_dict_delete_variables(the_dictionary,
 394                                             data_sheet->range.col0,
 395                                             1);
 396
 397               psppire_case_file_insert_values(data_store->case_file,
 398                                               -1, fv);
 399             }
 400             break;
 401           default:
 402             gtk_sheet_cell_clear(data_sheet,
 403                                  data_sheet->active_cell.row,
 404                                  data_sheet->active_cell.col);
 405             break;
 406           }
 407
 408       }
 409       break;
 410     }
 411
 412 }
 413
 414 void
 415 on_about1_activate(GtkMenuItem     *menuitem,
 416                    gpointer         user_data)
 417 {
 418   GtkWidget *about =  get_widget_assert(xml, "aboutdialog1");
 419
 420
 421   GdkPixbuf *pb  = gdk_pixbuf_new_from_file_at_size( "pspplogo.png", 64, 64, 0);
 422
 423   gtk_about_dialog_set_logo(GTK_ABOUT_DIALOG(about), pb);
 424
 425   gtk_widget_show(about);
 426
 427   gtk_window_set_transient_for(GTK_WINDOW(about),
 428                                GTK_WINDOW(get_widget_assert(xml, "data_editor")));
 429 }
 430
 431
 432 /* Set the value labels state from the toolbar's toggle button */
 433 void
 434 on_togglebutton_value_labels_toggled(GtkToggleToolButton *toggle_tool_button,
 435                                      gpointer             user_data)
 436 {
 437   GtkSheet *data_sheet = GTK_SHEET(get_widget_assert(xml, "data_sheet"));
 438   GtkCheckMenuItem *item =
 439     GTK_CHECK_MENU_ITEM(get_widget_assert(xml, "menuitem-value-labels"));
 440
 441   PsppireDataStore *ds = PSPPIRE_DATA_STORE(gtk_sheet_get_model(data_sheet));
 442
 443   gboolean show_value_labels = gtk_toggle_tool_button_get_active(toggle_tool_button);
 444
 445   gtk_check_menu_item_set_active(item, show_value_labels);
 446
 447   psppire_data_store_show_labels(ds, show_value_labels);
 448 }
 449
 450 /* Set the value labels state from the view menu */
 451 void
 452 on_value_labels_activate(GtkCheckMenuItem     *menuitem,
 453                           gpointer         user_data)
 454 {
 455   GtkSheet *data_sheet = GTK_SHEET(get_widget_assert(xml, "data_sheet"));
 456   GtkToggleToolButton *tb =
 457    GTK_TOGGLE_TOOL_BUTTON(get_widget_assert(xml, "togglebutton-value-labels"));
 458
 459   PsppireDataStore *ds = PSPPIRE_DATA_STORE(gtk_sheet_get_model(data_sheet));
 460
 461   gboolean show_value_labels = gtk_check_menu_item_get_active(menuitem);
 462
 463   gtk_toggle_tool_button_set_active(tb, show_value_labels);
 464
 465   psppire_data_store_show_labels(ds, show_value_labels);
 466 }
 467
 468 void
 469 on_status_bar1_activate(GtkCheckMenuItem     *menuitem,
 470  gpointer         user_data)
 471 {
 472
 473   if ( gtk_check_menu_item_get_active(menuitem) )
 474     gtk_widget_show(get_widget_assert(xml, "statusbar1"));
 475   else
 476     gtk_widget_hide(get_widget_assert(xml, "statusbar1"));
 477 }
 478
 479 void
 480 on_grid_lines1_activate(GtkCheckMenuItem     *menuitem,
 481  gpointer         user_data)
 482 {
 483
 484   const bool grid_visible = gtk_check_menu_item_get_active(menuitem);
 485
 486   gtk_sheet_show_grid(GTK_SHEET(get_widget_assert(xml, "variable_sheet")),
 487                       grid_visible);
 488
 489   gtk_sheet_show_grid(GTK_SHEET(get_widget_assert(xml, "data_sheet")),
 490                       grid_visible);
 491 }
 492
 493
 494 void
 495 on_fonts1_activate(GtkMenuItem     *menuitem,
 496  gpointer         user_data)
 497 {
 498   static GtkWidget *dialog = 0 ;
 499   if ( !dialog )
 500     dialog   = gtk_font_selection_dialog_new(_("Font Selection"));
 501
 502   gtk_window_set_transient_for(GTK_WINDOW(dialog),
 503                                GTK_WINDOW(get_widget_assert(xml, "data_editor")));
 504
 505
 506   if ( GTK_RESPONSE_OK == gtk_dialog_run(GTK_DIALOG(dialog)) )
 507     {
 508       GtkSheet *data_sheet =
 509         GTK_SHEET(get_widget_assert(xml, "data_sheet"));
 510
 511       GtkSheet *var_sheet =
 512         GTK_SHEET(get_widget_assert(xml, "variable_sheet"));
 513
 514       PsppireDataStore *ds = PSPPIRE_DATA_STORE(gtk_sheet_get_model(data_sheet));
 515       PsppireVarStore *vs = PSPPIRE_VAR_STORE(gtk_sheet_get_model(var_sheet));
 516
 517       const gchar *font = gtk_font_selection_dialog_get_font_name
 518         (GTK_FONT_SELECTION_DIALOG(dialog));
 519
 520       PangoFontDescription* font_desc =
 521         pango_font_description_from_string(font);
 522
 523       psppire_var_store_set_font(vs, font_desc);
 524       psppire_data_store_set_font(ds, font_desc);
 525     }
 526
 527   gtk_widget_hide(dialog);
 528
 529 }
 530
 531
 532 static GtkWidget *menuitems[2];
 533 static GtkNotebook *notebook = 0;
 534
 535 static void
 536 switch_menus(gint page)
 537 {
 538   GtkWidget *insert_variable = get_widget_assert(xml, "insert-variable");
 539   GtkWidget *insert_cases = get_widget_assert(xml, "insert-cases");
 540
 541   switch (page)
 542     {
 543     case PAGE_VAR_SHEET:
 544       gtk_widget_hide(menuitems[PAGE_VAR_SHEET]);
 545       gtk_widget_show(menuitems[PAGE_DATA_SHEET]);
 546       gtk_widget_set_sensitive(insert_variable, TRUE);
 547       gtk_widget_set_sensitive(insert_cases, FALSE);
 548       break;
 549     case PAGE_DATA_SHEET:
 550       gtk_widget_show(menuitems[PAGE_VAR_SHEET]);
 551       gtk_widget_hide(menuitems[PAGE_DATA_SHEET]);
 552       gtk_widget_set_sensitive(insert_variable, FALSE);
 553       gtk_widget_set_sensitive(insert_cases, TRUE);
 554       break;
 555     default:
 556       g_assert_not_reached();
 557       break;
 558     }
 559 }
 560
 561
 562 void
 563 select_sheet(gint page)
 564 {
 565   gtk_notebook_set_current_page(notebook, page);
 566   switch_menus(page);
 567 }
 568
 569
 570
 571 static void
 572 data_var_select(GtkNotebook *notebook,
 573                 GtkNotebookPage *page,
 574                 guint page_num,
 575                 gpointer user_data)
 576 {
 577   switch_menus(page_num);
 578 }
 579
 580
 581 /* Initialised things on the variable sheet */
 582 void
 583 var_data_selection_init(void)
 584 {
 585   notebook = GTK_NOTEBOOK(get_widget_assert(xml, "notebook1"));
 586   menuitems[PAGE_DATA_SHEET] = get_widget_assert(xml, "data1");
 587   menuitems[PAGE_VAR_SHEET] = get_widget_assert(xml, "variables1");
 588
 589   gtk_notebook_set_current_page(notebook, PAGE_DATA_SHEET);
 590   gtk_widget_hide(menuitems[PAGE_DATA_SHEET]);
 591   gtk_widget_show(menuitems[PAGE_VAR_SHEET]);
 592
 593
 594   g_signal_connect(G_OBJECT(notebook), "switch-page",
 595                    G_CALLBACK(data_var_select), 0);
 596
 597 }
 598
 599
 600 void
 601 on_data1_activate(GtkMenuItem     *menuitem,
 602                   gpointer         user_data)
 603 {
 604   select_sheet(PAGE_DATA_SHEET);
 605 }
 606
 607
 608 void
 609 on_variables1_activate(GtkMenuItem     *menuitem,
 610                   gpointer         user_data)
 611 {
 612   select_sheet(PAGE_VAR_SHEET);
 613 }
 614
 615
 616
 617 void
 618 on_go_to_case_activate(GtkMenuItem     *menuitem,
 619                        gpointer         user_data)
 620 {
 621   GtkWidget *dialog = get_widget_assert(xml, "go_to_case_dialog");
 622   GtkEntry *entry = GTK_ENTRY(get_widget_assert(xml, "entry_go_to_case"));
 623   GtkSheet *data_sheet = GTK_SHEET(get_widget_assert(xml, "data_sheet"));
 624
 625   gint result = gtk_dialog_run(GTK_DIALOG(dialog));
 626
 627
 628
 629   switch (result)
 630     {
 631     case GTK_RESPONSE_OK:
 632       {
 633         gint row, column;
 634         const gchar *text = gtk_entry_get_text(entry);
 635         gint casenum = g_strtod(text, NULL);
 636
 637         gtk_sheet_get_active_cell(data_sheet, &row, &column);
 638         if ( column < 0 ) column = 0;
 639         if ( row < 0 ) row = 0;
 640
 641         gtk_sheet_set_active_cell(data_sheet, casenum, column);
 642       }
 643       break;
 644     default:
 645       break;
 646     }
 647
 648   gtk_widget_hide(dialog);
 649   gtk_entry_set_text(entry, "");
 650 }
 651
 652
 653
 654 void
 655 on_sort_cases_activate (GtkMenuItem     *menuitem,
 656                         gpointer         user_data)
 657 {
 658   gint response;
 659   PsppireDataStore *data_store ;
 660
 661   struct sort_criteria criteria;
 662   static struct sort_cases_dialog *dialog ;
 663
 664   GtkSheet *data_sheet = GTK_SHEET(get_widget_assert(xml, "data_sheet"));
 665
 666   data_store = PSPPIRE_DATA_STORE(gtk_sheet_get_model(data_sheet));
 667
 668   if ( NULL == dialog)
 669     dialog = sort_cases_dialog_create(xml);
 670
 671   response = sort_cases_dialog_run(dialog, the_dictionary, &criteria);
 672
 673   switch ( response)
 674     {
 675     case GTK_RESPONSE_OK:
 676       psppire_case_file_sort(data_store->case_file, &criteria);
 677       break;
 678     }
 679 }
 680
 681
 682 static void
 683 insert_case(void)
 684 {
 685   gint row, col;
 686   PsppireDataStore *data_store ;
 687   GtkSheet *data_sheet = GTK_SHEET(get_widget_assert(xml, "data_sheet"));
 688
 689   data_store = PSPPIRE_DATA_STORE(gtk_sheet_get_model(data_sheet));
 690
 691   gtk_sheet_get_active_cell(data_sheet, &row, &col);
 692
 693   psppire_data_store_insert_new_case(data_store, row);
 694 }
 695
 696 void
 697 on_insert_case_clicked (GtkButton *button, gpointer user_data)
 698 {
 699   insert_case();
 700 }
 701
 702 void
 703 on_insert_cases (GtkMenuItem *menuitem, gpointer user_data)
 704 {
 705   insert_case();
 706 }
 707
 708
 709 void
 710 on_insert_variable (GtkMenuItem *menuitem, gpointer user_data)
 711 {
 712   gint row, col;
 713   GtkSheet *var_sheet = GTK_SHEET(get_widget_assert(xml, "variable_sheet"));
 714
 715   gtk_sheet_get_active_cell(var_sheet, &row, &col);
 716
 717   psppire_dict_insert_variable(the_dictionary, row, NULL);
 718 }
 719
 720