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 void
 266 recreate_save_handle(struct file_handle **handle)
 267 {
 268   GtkWidget *dialog;
 269
 270   GtkWidget *data_editor  = get_widget_assert(xml, "data_editor");
 271
 272   dialog = gtk_file_chooser_dialog_new (_("Save Data As"),
 273                                         GTK_WINDOW(data_editor),
 274                                         GTK_FILE_CHOOSER_ACTION_SAVE,
 275                                         GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
 276                                         GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
 277                                         NULL);
 278
 279   if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
 280     {
 281       char *file_name = gtk_file_chooser_get_filename
 282         (GTK_FILE_CHOOSER (dialog));
 283
 284
 285       if ( *handle )
 286         fh_free(*handle);
 287
 288       *handle = fh_create_file (handle_name, file_name, fh_default_properties());
 289
 290       psppire_set_window_title(basename(file_name));
 291
 292       g_free (file_name);
 293     }
 294
 295   gtk_widget_destroy (dialog);
 296 }
 297
 298 void
 299 on_save1_activate                      (GtkMenuItem     *menuitem,
 300                                         gpointer         user_data)
 301 {
 302   GtkSheet *data_sheet ;
 303   PsppireDataStore *data_store ;
 304
 305   if ( ! psppire_handle )
 306     recreate_save_handle(&psppire_handle);
 307
 308   data_sheet = GTK_SHEET(get_widget_assert(xml, "data_sheet"));
 309   data_store = PSPPIRE_DATA_STORE(gtk_sheet_get_model(data_sheet));
 310
 311   if ( psppire_handle )
 312     psppire_data_store_create_system_file(data_store,
 313                                        psppire_handle);
 314 }
 315
 316
 317 void
 318 on_save_as1_activate                   (GtkMenuItem     *menuitem,
 319                                         gpointer         user_data)
 320 {
 321   GtkSheet *data_sheet ;
 322   PsppireDataStore *data_store ;
 323
 324   recreate_save_handle(&psppire_handle);
 325   if ( ! psppire_handle )
 326     return ;
 327
 328   data_sheet = GTK_SHEET(get_widget_assert(xml, "data_sheet"));
 329   data_store = PSPPIRE_DATA_STORE(gtk_sheet_get_model(data_sheet));
 330
 331   if ( psppire_handle )
 332     psppire_data_store_create_system_file(data_store,
 333                                        psppire_handle);
 334 }
 335
 336
 337 void
 338 on_quit1_activate                      (GtkMenuItem     *menuitem,
 339                                         gpointer         user_data)
 340 {
 341   gtk_main_quit();
 342 }
 343
 344
 345 void
 346 on_clear_activate                    (GtkMenuItem     *menuitem,
 347                                       gpointer         user_data)
 348 {
 349   GtkNotebook *notebook = GTK_NOTEBOOK(get_widget_assert(xml, "notebook1"));
 350   gint page = -1;
 351
 352   page = gtk_notebook_get_current_page(notebook);
 353
 354   switch (page)
 355     {
 356     case PAGE_DATA_SHEET:
 357       {
 358         GtkSheet *data_sheet = GTK_SHEET(get_widget_assert(xml, "data_sheet"));
 359         PsppireDataStore *data_store =
 360           PSPPIRE_DATA_STORE(gtk_sheet_get_model(data_sheet));
 361
 362
 363         switch ( data_sheet->state )
 364           {
 365           case GTK_SHEET_ROW_SELECTED:
 366             psppire_case_file_delete_cases(data_store->case_file,
 367                                            data_sheet->range.rowi
 368                                            - data_sheet->range.row0 + 1,
 369                                            data_sheet->range.row0);
 370             break;
 371           case GTK_SHEET_COLUMN_SELECTED:
 372             {
 373               gint fv;
 374               struct PsppireVariable *pv =
 375                 psppire_dict_get_variable(the_dictionary,
 376                                           data_sheet->range.col0);
 377               fv = psppire_variable_get_fv(pv);
 378
 379
 380               psppire_dict_delete_variables(the_dictionary,
 381                                             data_sheet->range.col0,
 382                                             1);
 383
 384               psppire_case_file_insert_values(data_store->case_file,
 385                                               -1, fv);
 386             }
 387             break;
 388           default:
 389             gtk_sheet_cell_clear(data_sheet,
 390                                  data_sheet->active_cell.row,
 391                                  data_sheet->active_cell.col);
 392             break;
 393           }
 394
 395       }
 396       break;
 397     }
 398
 399 }
 400
 401 void
 402 on_insert1_activate                    (GtkMenuItem     *menuitem,
 403                                         gpointer         user_data)
 404 {
 405   GtkNotebook *notebook = GTK_NOTEBOOK(get_widget_assert(xml, "notebook1"));
 406   gint page = -1;
 407
 408   page = gtk_notebook_get_current_page(notebook);
 409
 410   switch (page)
 411     {
 412     case PAGE_DATA_SHEET:
 413 #if 0
 414       {
 415         GtkSheet *data_sheet = GTK_SHEET(get_widget_assert(xml, "data_sheet"));
 416         PsppireDataStore *data_store =
 417           PSPPIRE_DATA_STORE(gtk_sheet_get_model(data_sheet));
 418
 419         psppire_case_array_insert_case(data_store->cases,
 420                                        data_sheet->range.row0,
 421                                        blank_case, the_dictionary);
 422       }
 423       break;
 424 #endif
 425     case PAGE_VAR_SHEET:
 426       {
 427         GtkSheet *var_sheet =
 428           GTK_SHEET(get_widget_assert(xml, "variable_sheet"));
 429
 430         PsppireVarStore *var_store =
 431           PSPPIRE_VAR_STORE(gtk_sheet_get_model(var_sheet));
 432
 433         psppire_dict_insert_variable(var_store->dict, var_sheet->range.row0, 0);
 434       }
 435       break;
 436     }
 437 }
 438
 439 #if 0
 440 void
 441 on_delete1_activate                    (GtkMenuItem     *menuitem,
 442                                         gpointer         user_data)
 443 {
 444   gint page = -1;
 445   GtkWidget *notebook = get_widget_assert(xml, "notebook1");
 446
 447   page = gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook));
 448   switch ( page)
 449     {
 450 #if 0
 451     case PAGE_DATA_SHEET:
 452       {
 453         GtkSheet *data_sheet = GTK_SHEET(get_widget_assert(xml, "data_sheet"));
 454         PsppireDataStore *data_store =
 455           PSPPIRE_DATA_STORE(gtk_sheet_get_model(data_sheet));
 456
 457         psppire_case_array_delete_cases(data_store->cases,
 458                                     data_sheet->range.row0,
 459                                     1 + data_sheet->range.rowi
 460                                     - data_sheet->range.row0  );
 461       }
 462       break;
 463 #endif
 464     case PAGE_VAR_SHEET:
 465       {
 466         GtkSheet *var_sheet =
 467           GTK_SHEET(get_widget_assert(xml, "variable_sheet"));
 468
 469         PsppireVarStore *var_store =
 470           PSPPIRE_VAR_STORE(gtk_sheet_get_model(var_sheet));
 471
 472         psppire_dict_delete_variables(var_store->dict,
 473                                    var_sheet->range.row0,
 474                                    1 + var_sheet->range.rowi
 475                                    - var_sheet->range.row0  );
 476       }
 477       break;
 478     }
 479 }
 480 #endif
 481
 482 void
 483 on_about1_activate(GtkMenuItem     *menuitem,
 484                    gpointer         user_data)
 485 {
 486   GtkWidget *about =  get_widget_assert(xml, "aboutdialog1");
 487
 488
 489   GdkPixbuf *pb  = gdk_pixbuf_new_from_file_at_size( "pspplogo.png", 64, 64, 0);
 490
 491   gtk_about_dialog_set_logo(GTK_ABOUT_DIALOG(about), pb);
 492
 493   gtk_widget_show(about);
 494
 495   gtk_window_set_transient_for(GTK_WINDOW(about),
 496                                GTK_WINDOW(get_widget_assert(xml, "data_editor")));
 497 }
 498
 499
 500 /* Set the value labels state from the toolbar's toggle button */
 501 void
 502 on_togglebutton_value_labels_toggled(GtkToggleToolButton *toggle_tool_button,
 503                                      gpointer             user_data)
 504 {
 505   GtkSheet *data_sheet = GTK_SHEET(get_widget_assert(xml, "data_sheet"));
 506   GtkCheckMenuItem *item =
 507     GTK_CHECK_MENU_ITEM(get_widget_assert(xml, "menuitem-value-labels"));
 508
 509   PsppireDataStore *ds = PSPPIRE_DATA_STORE(gtk_sheet_get_model(data_sheet));
 510
 511   gboolean show_value_labels = gtk_toggle_tool_button_get_active(toggle_tool_button);
 512
 513   gtk_check_menu_item_set_active(item, show_value_labels);
 514
 515   psppire_data_store_show_labels(ds, show_value_labels);
 516 }
 517
 518 /* Set the value labels state from the view menu */
 519 void
 520 on_value_labels_activate(GtkCheckMenuItem     *menuitem,
 521                           gpointer         user_data)
 522 {
 523   GtkSheet *data_sheet = GTK_SHEET(get_widget_assert(xml, "data_sheet"));
 524   GtkToggleToolButton *tb =
 525    GTK_TOGGLE_TOOL_BUTTON(get_widget_assert(xml, "togglebutton-value-labels"));
 526
 527   PsppireDataStore *ds = PSPPIRE_DATA_STORE(gtk_sheet_get_model(data_sheet));
 528
 529   gboolean show_value_labels = gtk_check_menu_item_get_active(menuitem);
 530
 531   gtk_toggle_tool_button_set_active(tb, show_value_labels);
 532
 533   psppire_data_store_show_labels(ds, show_value_labels);
 534 }
 535
 536 void
 537 on_status_bar1_activate(GtkCheckMenuItem     *menuitem,
 538  gpointer         user_data)
 539 {
 540
 541   if ( gtk_check_menu_item_get_active(menuitem) )
 542     gtk_widget_show(get_widget_assert(xml, "statusbar1"));
 543   else
 544     gtk_widget_hide(get_widget_assert(xml, "statusbar1"));
 545 }
 546
 547 void
 548 on_grid_lines1_activate(GtkCheckMenuItem     *menuitem,
 549  gpointer         user_data)
 550 {
 551
 552   const bool grid_visible = gtk_check_menu_item_get_active(menuitem);
 553
 554   gtk_sheet_show_grid(GTK_SHEET(get_widget_assert(xml, "variable_sheet")),
 555                       grid_visible);
 556
 557   gtk_sheet_show_grid(GTK_SHEET(get_widget_assert(xml, "data_sheet")),
 558                       grid_visible);
 559 }
 560
 561
 562 void
 563 on_fonts1_activate(GtkMenuItem     *menuitem,
 564  gpointer         user_data)
 565 {
 566   static GtkWidget *dialog = 0 ;
 567   if ( !dialog )
 568     dialog   = gtk_font_selection_dialog_new(_("Font Selection"));
 569
 570   gtk_window_set_transient_for(GTK_WINDOW(dialog),
 571                                GTK_WINDOW(get_widget_assert(xml, "data_editor")));
 572
 573
 574   if ( GTK_RESPONSE_OK == gtk_dialog_run(GTK_DIALOG(dialog)) )
 575     {
 576       GtkSheet *data_sheet =
 577         GTK_SHEET(get_widget_assert(xml, "data_sheet"));
 578
 579       GtkSheet *var_sheet =
 580         GTK_SHEET(get_widget_assert(xml, "variable_sheet"));
 581
 582       PsppireDataStore *ds = PSPPIRE_DATA_STORE(gtk_sheet_get_model(data_sheet));
 583       PsppireVarStore *vs = PSPPIRE_VAR_STORE(gtk_sheet_get_model(var_sheet));
 584
 585       const gchar *font = gtk_font_selection_dialog_get_font_name
 586         (GTK_FONT_SELECTION_DIALOG(dialog));
 587
 588       PangoFontDescription* font_desc =
 589         pango_font_description_from_string(font);
 590
 591       psppire_var_store_set_font(vs, font_desc);
 592       psppire_data_store_set_font(ds, font_desc);
 593     }
 594
 595   gtk_widget_hide(dialog);
 596
 597 }
 598
 599
 600 static GtkWidget *menuitems[2];
 601 static GtkNotebook *notebook = 0;
 602
 603 static void
 604 switch_menus(gint page)
 605 {
 606   GtkWidget *insert_variable = get_widget_assert(xml, "insert-variable");
 607   GtkWidget *insert_cases = get_widget_assert(xml, "insert-cases");
 608
 609   switch (page)
 610     {
 611     case PAGE_VAR_SHEET:
 612       gtk_widget_hide(menuitems[PAGE_VAR_SHEET]);
 613       gtk_widget_show(menuitems[PAGE_DATA_SHEET]);
 614       gtk_widget_set_sensitive(insert_variable, TRUE);
 615       gtk_widget_set_sensitive(insert_cases, FALSE);
 616       break;
 617     case PAGE_DATA_SHEET:
 618       gtk_widget_show(menuitems[PAGE_VAR_SHEET]);
 619       gtk_widget_hide(menuitems[PAGE_DATA_SHEET]);
 620       gtk_widget_set_sensitive(insert_variable, FALSE);
 621       gtk_widget_set_sensitive(insert_cases, TRUE);
 622       break;
 623     default:
 624       g_assert_not_reached();
 625       break;
 626     }
 627 }
 628
 629
 630 void
 631 select_sheet(gint page)
 632 {
 633   gtk_notebook_set_current_page(notebook, page);
 634   switch_menus(page);
 635 }
 636
 637
 638
 639 static void
 640 data_var_select(GtkNotebook *notebook,
 641                 GtkNotebookPage *page,
 642                 guint page_num,
 643                 gpointer user_data)
 644 {
 645   switch_menus(page_num);
 646 }
 647
 648
 649 /* Initialised things on the variable sheet */
 650 void
 651 var_data_selection_init(void)
 652 {
 653   notebook = GTK_NOTEBOOK(get_widget_assert(xml, "notebook1"));
 654   menuitems[PAGE_DATA_SHEET] = get_widget_assert(xml, "data1");
 655   menuitems[PAGE_VAR_SHEET] = get_widget_assert(xml, "variables1");
 656
 657   gtk_notebook_set_current_page(notebook, PAGE_DATA_SHEET);
 658   gtk_widget_hide(menuitems[PAGE_DATA_SHEET]);
 659   gtk_widget_show(menuitems[PAGE_VAR_SHEET]);
 660
 661
 662   g_signal_connect(G_OBJECT(notebook), "switch-page",
 663                    G_CALLBACK(data_var_select), 0);
 664
 665 }
 666
 667
 668 void
 669 on_data1_activate(GtkMenuItem     *menuitem,
 670                   gpointer         user_data)
 671 {
 672   select_sheet(PAGE_DATA_SHEET);
 673 }
 674
 675
 676 void
 677 on_variables1_activate(GtkMenuItem     *menuitem,
 678                   gpointer         user_data)
 679 {
 680   select_sheet(PAGE_VAR_SHEET);
 681 }
 682
 683
 684
 685 void
 686 on_go_to_case_activate(GtkMenuItem     *menuitem,
 687                        gpointer         user_data)
 688 {
 689   GtkWidget *dialog = get_widget_assert(xml, "go_to_case_dialog");
 690   GtkEntry *entry = GTK_ENTRY(get_widget_assert(xml, "entry_go_to_case"));
 691   GtkSheet *data_sheet = GTK_SHEET(get_widget_assert(xml, "data_sheet"));
 692
 693   gint result = gtk_dialog_run(GTK_DIALOG(dialog));
 694
 695
 696
 697   switch (result)
 698     {
 699     case GTK_RESPONSE_OK:
 700       {
 701         gint row, column;
 702         const gchar *text = gtk_entry_get_text(entry);
 703         gint casenum = g_strtod(text, NULL);
 704
 705         gtk_sheet_get_active_cell(data_sheet, &row, &column);
 706         if ( column < 0 ) column = 0;
 707         if ( row < 0 ) row = 0;
 708
 709         gtk_sheet_set_active_cell(data_sheet, casenum, column);
 710       }
 711       break;
 712     default:
 713       break;
 714     }
 715
 716   gtk_widget_hide(dialog);
 717   gtk_entry_set_text(entry, "");
 718 }
 719
 720
 721
 722 void
 723 on_sort_cases_activate (GtkMenuItem     *menuitem,
 724                         gpointer         user_data)
 725 {
 726   gint response;
 727   PsppireDataStore *data_store ;
 728
 729   struct sort_criteria criteria;
 730   static struct sort_cases_dialog *dialog ;
 731
 732   GtkSheet *data_sheet = GTK_SHEET(get_widget_assert(xml, "data_sheet"));
 733
 734   data_store = PSPPIRE_DATA_STORE(gtk_sheet_get_model(data_sheet));
 735
 736   if ( NULL == dialog)
 737     dialog = sort_cases_dialog_create(xml);
 738
 739   response = sort_cases_dialog_run(dialog, the_dictionary, &criteria);
 740
 741   switch ( response)
 742     {
 743     case GTK_RESPONSE_OK:
 744       psppire_case_file_sort(data_store->case_file, &criteria);
 745       break;
 746     }
 747 }
 748
 749
 750 static void
 751 insert_case(void)
 752 {
 753   gint row, col;
 754   PsppireDataStore *data_store ;
 755   GtkSheet *data_sheet = GTK_SHEET(get_widget_assert(xml, "data_sheet"));
 756
 757   data_store = PSPPIRE_DATA_STORE(gtk_sheet_get_model(data_sheet));
 758
 759   gtk_sheet_get_active_cell(data_sheet, &row, &col);
 760
 761   psppire_case_file_insert_case(data_store->case_file, row);
 762 }
 763
 764 void
 765 on_insert_case_clicked (GtkButton *button, gpointer user_data)
 766 {
 767   insert_case();
 768 }
 769
 770 void
 771 on_insert_cases (GtkMenuItem *menuitem, gpointer user_data)
 772 {
 773   insert_case();
 774 }
 775
 776
 777 void
 778 on_insert_variable (GtkMenuItem *menuitem, gpointer user_data)
 779 {
 780   gint row, col;
 781   GtkSheet *var_sheet = GTK_SHEET(get_widget_assert(xml, "variable_sheet"));
 782
 783   gtk_sheet_get_active_cell(var_sheet, &row, &col);
 784
 785   psppire_dict_insert_variable(the_dictionary, row, NULL);
 786 }
 787
 788