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 "window-manager.h"
  41
  42 #include "psppire-data-store.h"
  43 #include "psppire-var-store.h"
  44
  45 #include "weight-cases-dialog.h"
  46
  47
  48 static void insert_variable (GtkCheckMenuItem *m, gpointer data);
  49
  50
  51 /* Switch between the VAR SHEET and the DATA SHEET */
  52 enum {PAGE_DATA_SHEET = 0, PAGE_VAR_SHEET};
  53
  54 static gboolean click2column (GtkWidget *w, gint col, gpointer data);
  55
  56 static gboolean click2row (GtkWidget *w, gint row, gpointer data);
  57
  58
  59 static void select_sheet (struct data_editor *de, guint page_num);
  60
  61
  62 /* Callback for when the dictionary changes properties*/
  63 static void on_weight_change (GObject *, gint, gpointer);
  64 static void on_filter_change (GObject *, gint, gpointer);
  65 static void on_split_change (PsppireDict *, gpointer);
  66
  67 static void data_var_select (GtkNotebook *notebook,
  68                             GtkNotebookPage *page,
  69                             guint page_num,
  70                             gpointer user_data);
  71
  72 static void status_bar_activate (GtkCheckMenuItem *, gpointer);
  73
  74 static void grid_lines_activate (GtkCheckMenuItem *, gpointer);
  75
  76 static void data_sheet_activate (GtkCheckMenuItem *, gpointer);
  77
  78 static void variable_sheet_activate (GtkCheckMenuItem *, gpointer );
  79
  80 static void fonts_activate (GtkMenuItem *, gpointer);
  81
  82 static void value_labels_activate (GtkCheckMenuItem *, gpointer);
  83 static void value_labels_toggled (GtkToggleToolButton *, gpointer);
  84
  85
  86 static void file_quit (GtkCheckMenuItem *, gpointer );
  87
  88 static void on_clear_activate (GtkMenuItem *, gpointer);
  89
  90 static void
  91 enable_edit_clear (GtkWidget *w, gint row, gpointer data)
  92 {
  93   struct data_editor *de = data;
  94
  95   GtkWidget *menuitem = get_widget_assert (de->xml, "edit_clear");
  96
  97   gtk_widget_set_sensitive (menuitem, TRUE);
  98 }
  99
 100 static gboolean
 101 disable_edit_clear (GtkWidget *w, gint x, gint y, gpointer data)
 102 {
 103   struct data_editor *de = data;
 104
 105   GtkWidget *menuitem = get_widget_assert (de->xml, "edit_clear");
 106
 107   gtk_widget_set_sensitive (menuitem, FALSE);
 108
 109   return FALSE;
 110 }
 111
 112 static void weight_cases_dialog (GObject *o, gpointer data);
 113
 114
 115 /*
 116   Create a new data editor.
 117 */
 118 struct data_editor *
 119 new_data_editor (void)
 120 {
 121   struct data_editor *de ;
 122   struct editor_window *e;
 123   GtkSheet *var_sheet ;
 124   PsppireVarStore *vs;
 125
 126   de = g_malloc (sizeof (*de));
 127
 128   e = (struct editor_window *) de;
 129
 130   de->xml = glade_xml_new (PKGDATADIR "/data-editor.glade", NULL, NULL);
 131
 132
 133   var_sheet = GTK_SHEET (get_widget_assert (de->xml, "variable_sheet"));
 134
 135   vs = PSPPIRE_VAR_STORE (gtk_sheet_get_model (var_sheet));
 136
 137   g_signal_connect (vs->dict, "weight-changed",
 138                     G_CALLBACK (on_weight_change),
 139                     de);
 140
 141   g_signal_connect (vs->dict, "filter-changed",
 142                     G_CALLBACK (on_filter_change),
 143                     de);
 144
 145   g_signal_connect (vs->dict, "split-changed",
 146                     G_CALLBACK (on_split_change),
 147                     de);
 148
 149   connect_help (de->xml);
 150
 151   de->invoke_weight_cases_dialog =
 152     gtk_action_new ("weight-cases-dialog",
 153                     _("Weights"),
 154                     _("Weight cases by variable"),
 155                     "pspp-weight-cases");
 156
 157
 158   g_signal_connect (de->invoke_weight_cases_dialog, "activate",
 159                     G_CALLBACK (weight_cases_dialog), de);
 160
 161   e->window = GTK_WINDOW (get_widget_assert (de->xml, "data_editor"));
 162
 163   g_signal_connect (get_widget_assert (de->xml,"file_new_data"),
 164                     "activate",
 165                     G_CALLBACK (new_data_window),
 166                     e->window);
 167
 168   g_signal_connect (get_widget_assert (de->xml,"file_open_data"),
 169                     "activate",
 170                     G_CALLBACK (open_data_window),
 171                     e->window);
 172
 173   g_signal_connect (get_widget_assert (de->xml,"file_new_syntax"),
 174                     "activate",
 175                     G_CALLBACK (new_syntax_window),
 176                     e->window);
 177
 178   g_signal_connect (get_widget_assert (de->xml,"file_open_syntax"),
 179                     "activate",
 180                     G_CALLBACK (open_syntax_window),
 181                     e->window);
 182
 183
 184   g_signal_connect (get_widget_assert (de->xml,"edit_clear"),
 185                     "activate",
 186                     G_CALLBACK (on_clear_activate),
 187                     de);
 188
 189
 190   g_signal_connect (get_widget_assert (de->xml,"data_insert-variable"),
 191                     "activate",
 192                     G_CALLBACK (insert_variable),
 193                     de);
 194
 195   gtk_action_connect_proxy (de->invoke_weight_cases_dialog,
 196                             get_widget_assert (de->xml, "data_weight-cases")
 197                             );
 198
 199   /*
 200   g_signal_connect (get_widget_assert (de->xml,"data_weight-cases"),
 201                     "activate",
 202                     G_CALLBACK (weight_cases_dialog),
 203                     de);
 204   */
 205
 206
 207   g_signal_connect (get_widget_assert (de->xml,"help_about"),
 208                     "activate",
 209                     G_CALLBACK (about_new),
 210                     e->window);
 211
 212
 213   g_signal_connect (get_widget_assert (de->xml,"help_reference"),
 214                     "activate",
 215                     G_CALLBACK (reference_manual),
 216                     e->window);
 217
 218
 219
 220   g_signal_connect (get_widget_assert (de->xml,"data_sheet"),
 221                     "double-click-column",
 222                     G_CALLBACK (click2column),
 223                     de);
 224
 225
 226   g_signal_connect (get_widget_assert (de->xml, "variable_sheet"),
 227                     "double-click-row",
 228                     GTK_SIGNAL_FUNC (click2row),
 229                     de);
 230
 231
 232   g_signal_connect (get_widget_assert (de->xml, "variable_sheet"),
 233                     "select-row",
 234                     GTK_SIGNAL_FUNC (enable_edit_clear),
 235                     de);
 236
 237   g_signal_connect (get_widget_assert (de->xml, "variable_sheet"),
 238                     "activate",
 239                     GTK_SIGNAL_FUNC (disable_edit_clear),
 240                     de);
 241
 242
 243   g_signal_connect (get_widget_assert (de->xml, "notebook"),
 244                     "switch-page",
 245                     G_CALLBACK (data_var_select), de);
 246
 247
 248
 249   g_signal_connect (get_widget_assert (de->xml, "view_statusbar"),
 250                     "activate",
 251                     G_CALLBACK (status_bar_activate), de);
 252
 253
 254   g_signal_connect (get_widget_assert (de->xml, "view_gridlines"),
 255                     "activate",
 256                     G_CALLBACK (grid_lines_activate), de);
 257
 258
 259
 260   g_signal_connect (get_widget_assert (de->xml, "view_data"),
 261                     "activate",
 262                     G_CALLBACK (data_sheet_activate), de);
 263
 264   g_signal_connect (get_widget_assert (de->xml, "view_variables"),
 265                     "activate",
 266                     G_CALLBACK (variable_sheet_activate), de);
 267
 268
 269
 270   g_signal_connect (get_widget_assert (de->xml, "view_fonts"),
 271                     "activate",
 272                     G_CALLBACK (fonts_activate), de);
 273
 274
 275
 276   g_signal_connect (get_widget_assert (de->xml, "view_valuelabels"),
 277                     "activate",
 278                     G_CALLBACK (value_labels_activate), de);
 279
 280
 281   g_signal_connect (get_widget_assert (de->xml, "togglebutton-value-labels"),
 282                     "toggled",
 283                     G_CALLBACK (value_labels_toggled), de);
 284
 285
 286   gtk_action_connect_proxy (de->invoke_weight_cases_dialog,
 287                             get_widget_assert (de->xml, "button-weight-cases")
 288                             );
 289
 290   g_signal_connect (get_widget_assert (de->xml, "file_quit"),
 291                     "activate",
 292                     G_CALLBACK (file_quit), de);
 293
 294
 295   g_signal_connect (get_widget_assert (de->xml, "windows_minimise_all"),
 296                     "activate",
 297                     G_CALLBACK (minimise_all_windows), NULL);
 298
 299
 300
 301   select_sheet (de, PAGE_DATA_SHEET);
 302
 303   return de;
 304 }
 305
 306
 307 /* Callback which occurs when the var sheet's row title
 308    button is double clicked */
 309 static gboolean
 310 click2row (GtkWidget *w, gint row, gpointer data)
 311 {
 312   struct data_editor *de = data;
 313
 314   gint current_row, current_column;
 315
 316   GtkWidget *data_sheet  = get_widget_assert (de->xml, "data_sheet");
 317
 318   data_editor_select_sheet (de, PAGE_DATA_SHEET);
 319
 320   gtk_sheet_get_active_cell (GTK_SHEET (data_sheet),
 321                              &current_row, &current_column);
 322
 323   gtk_sheet_set_active_cell (GTK_SHEET (data_sheet), current_row, row);
 324
 325   return FALSE;
 326 }
 327
 328
 329 /* Callback which occurs when the data sheet's column title
 330    is double clicked */
 331 static gboolean
 332 click2column (GtkWidget *w, gint col, gpointer data)
 333 {
 334   struct data_editor *de = data;
 335
 336   gint current_row, current_column;
 337
 338   GtkWidget *var_sheet  = get_widget_assert (de->xml, "variable_sheet");
 339
 340   data_editor_select_sheet (de, PAGE_VAR_SHEET);
 341
 342   gtk_sheet_get_active_cell (GTK_SHEET (var_sheet),
 343                              &current_row, &current_column);
 344
 345   gtk_sheet_set_active_cell (GTK_SHEET (var_sheet), col, current_column);
 346
 347   return FALSE;
 348 }
 349
 350
 351
 352
 353 void
 354 new_data_window (GtkMenuItem *menuitem, gpointer parent)
 355 {
 356   window_create (WINDOW_DATA, NULL);
 357 }
 358
 359
 360 static void
 361 select_sheet (struct data_editor *de, guint page_num)
 362 {
 363   GtkWidget *insert_variable = get_widget_assert (de->xml, "data_insert-variable");
 364   GtkWidget *insert_cases = get_widget_assert (de->xml, "insert-cases");
 365
 366   GtkWidget *view_data = get_widget_assert (de->xml, "view_data");
 367   GtkWidget *view_variables = get_widget_assert (de->xml, "view_variables");
 368
 369   switch (page_num)
 370     {
 371     case PAGE_VAR_SHEET:
 372       gtk_widget_hide (view_variables);
 373       gtk_widget_show (view_data);
 374       gtk_widget_set_sensitive (insert_variable, TRUE);
 375       gtk_widget_set_sensitive (insert_cases, FALSE);
 376       break;
 377     case PAGE_DATA_SHEET:
 378       gtk_widget_show (view_variables);
 379       gtk_widget_hide (view_data);
 380 #if 0
 381       gtk_widget_set_sensitive (insert_cases, TRUE);
 382 #endif
 383       break;
 384     default:
 385       g_assert_not_reached ();
 386       break;
 387     }
 388 }
 389
 390
 391 static void
 392 data_var_select (GtkNotebook *notebook,
 393                 GtkNotebookPage *page,
 394                 guint page_num,
 395                 gpointer user_data)
 396 {
 397   struct data_editor *de = user_data;
 398
 399   select_sheet (de, page_num);
 400 }
 401
 402
 403
 404
 405 void
 406 data_editor_select_sheet (struct data_editor *de, gint page)
 407 {
 408   gtk_notebook_set_current_page
 409    (
 410     GTK_NOTEBOOK (get_widget_assert (de->xml,"notebook")), page
 411     );
 412 }
 413
 414
 415 void
 416 open_data_window (GtkMenuItem *menuitem, gpointer parent)
 417 {
 418   bool finished = FALSE;
 419
 420   GtkWidget *dialog;
 421
 422   GtkFileFilter *filter ;
 423
 424   dialog = gtk_file_chooser_dialog_new (_("Open"),
 425                                         GTK_WINDOW (parent),
 426                                         GTK_FILE_CHOOSER_ACTION_OPEN,
 427                                         GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
 428                                         GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
 429                                         NULL);
 430
 431   filter = gtk_file_filter_new ();
 432   gtk_file_filter_set_name (filter, _("System Files (*.sav)"));
 433   gtk_file_filter_add_pattern (filter, "*.sav");
 434   gtk_file_filter_add_pattern (filter, "*.SAV");
 435   gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter);
 436
 437   filter = gtk_file_filter_new ();
 438   gtk_file_filter_set_name (filter, _("Portable Files (*.por) "));
 439   gtk_file_filter_add_pattern (filter, "*.por");
 440   gtk_file_filter_add_pattern (filter, "*.POR");
 441   gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter);
 442
 443   filter = gtk_file_filter_new ();
 444   gtk_file_filter_set_name (filter, _("All Files"));
 445   gtk_file_filter_add_pattern (filter, "*");
 446   gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter);
 447
 448   do {
 449
 450     if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
 451       {
 452         gchar *file_name =
 453           gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
 454
 455         g_free (file_name);
 456       }
 457     else
 458       finished = TRUE;
 459
 460   } while ( ! finished ) ;
 461
 462   gtk_widget_destroy (dialog);
 463 }
 464
 465
 466
 467
 468 static void
 469 status_bar_activate (GtkCheckMenuItem *menuitem, gpointer data)
 470 {
 471   struct data_editor *de = data;
 472   GtkWidget *statusbar = get_widget_assert (de->xml, "status-bar");
 473
 474   if ( gtk_check_menu_item_get_active (menuitem) )
 475     gtk_widget_show (statusbar);
 476   else
 477     gtk_widget_hide (statusbar);
 478 }
 479
 480
 481 static void
 482 grid_lines_activate (GtkCheckMenuItem *menuitem, gpointer data)
 483 {
 484   struct data_editor *de = data;
 485   const bool grid_visible = gtk_check_menu_item_get_active (menuitem);
 486
 487   gtk_sheet_show_grid (GTK_SHEET (get_widget_assert (de->xml,
 488                                                      "variable_sheet")),
 489                        grid_visible);
 490
 491   gtk_sheet_show_grid (GTK_SHEET (get_widget_assert (de->xml, "data_sheet")),
 492                        grid_visible);
 493 }
 494
 495
 496
 497 static void
 498 data_sheet_activate (GtkCheckMenuItem *menuitem, gpointer data)
 499 {
 500   struct data_editor *de = data;
 501
 502   data_editor_select_sheet (de, PAGE_DATA_SHEET);
 503 }
 504
 505
 506 static void
 507 variable_sheet_activate (GtkCheckMenuItem *menuitem, gpointer data)
 508 {
 509   struct data_editor *de = data;
 510
 511   data_editor_select_sheet (de, PAGE_VAR_SHEET);
 512 }
 513
 514
 515 static void
 516 fonts_activate (GtkMenuItem *menuitem, gpointer data)
 517 {
 518   struct data_editor *de = data;
 519   GtkWidget *dialog =
 520     gtk_font_selection_dialog_new (_("Font Selection"));
 521
 522   gtk_window_set_transient_for (GTK_WINDOW (dialog),
 523                                 GTK_WINDOW (get_widget_assert (de->xml,
 524                                                                "data_editor")));
 525   if ( GTK_RESPONSE_OK == gtk_dialog_run (GTK_DIALOG (dialog)) )
 526     {
 527       GtkSheet *data_sheet =
 528         GTK_SHEET (get_widget_assert (de->xml, "data_sheet"));
 529
 530       GtkSheet *var_sheet =
 531         GTK_SHEET (get_widget_assert (de->xml, "variable_sheet"));
 532
 533       PsppireDataStore *ds = PSPPIRE_DATA_STORE (gtk_sheet_get_model (data_sheet));
 534       PsppireVarStore *vs = PSPPIRE_VAR_STORE (gtk_sheet_get_model (var_sheet));
 535
 536       const gchar *font = gtk_font_selection_dialog_get_font_name
 537         (GTK_FONT_SELECTION_DIALOG (dialog));
 538
 539       PangoFontDescription* font_desc =
 540         pango_font_description_from_string (font);
 541
 542       psppire_var_store_set_font (vs, font_desc);
 543       psppire_data_store_set_font (ds, font_desc);
 544     }
 545
 546   gtk_widget_hide (dialog);
 547 }
 548
 549
 550 /* The next two callbacks are mutually co-operative */
 551
 552 /* Callback for the value labels menu item */
 553 static void
 554 value_labels_activate (GtkCheckMenuItem *menuitem, gpointer data)
 555 {
 556   struct data_editor *de = data;
 557
 558   GtkSheet *data_sheet = GTK_SHEET (get_widget_assert (de->xml, "data_sheet"));
 559
 560   GtkToggleToolButton *tb =
 561     GTK_TOGGLE_TOOL_BUTTON (get_widget_assert (de->xml,
 562                                                "togglebutton-value-labels"));
 563
 564   PsppireDataStore *ds = PSPPIRE_DATA_STORE (gtk_sheet_get_model (data_sheet));
 565
 566   gboolean show_value_labels = gtk_check_menu_item_get_active (menuitem);
 567
 568   gtk_toggle_tool_button_set_active (tb, show_value_labels);
 569
 570   psppire_data_store_show_labels (ds, show_value_labels);
 571 }
 572
 573
 574 /* Callback for the value labels tooglebutton */
 575 static void
 576 value_labels_toggled (GtkToggleToolButton *toggle_tool_button,
 577                       gpointer data)
 578 {
 579   struct data_editor *de = data;
 580
 581   GtkSheet *data_sheet = GTK_SHEET (get_widget_assert (de->xml, "data_sheet"));
 582
 583   GtkCheckMenuItem *item =
 584     GTK_CHECK_MENU_ITEM (get_widget_assert (de->xml, "view_valuelabels"));
 585
 586   PsppireDataStore *ds = PSPPIRE_DATA_STORE (gtk_sheet_get_model (data_sheet));
 587
 588   gboolean show_value_labels =
 589     gtk_toggle_tool_button_get_active (toggle_tool_button);
 590
 591   gtk_check_menu_item_set_active (item, show_value_labels);
 592
 593   psppire_data_store_show_labels (ds, show_value_labels);
 594 }
 595
 596
 597 static void
 598 file_quit (GtkCheckMenuItem *menuitem, gpointer data)
 599 {
 600   /* FIXME: Need to be more intelligent here.
 601      Give the user the opportunity to save any unsaved data.
 602   */
 603   gtk_main_quit ();
 604 }
 605
 606
 607
 608 /* Callback for when the Clear item in the edit menu is activated */
 609 static void
 610 on_clear_activate (GtkMenuItem *menuitem, gpointer data)
 611 {
 612   struct data_editor *de = data;
 613
 614   GtkNotebook *notebook = GTK_NOTEBOOK (get_widget_assert (de->xml,
 615                                                            "notebook"));
 616
 617   switch ( gtk_notebook_get_current_page (notebook) )
 618     {
 619     case PAGE_VAR_SHEET:
 620       {
 621         GtkSheet *var_sheet =
 622           GTK_SHEET (get_widget_assert (de->xml, "variable_sheet"));
 623
 624         PsppireVarStore *vs = PSPPIRE_VAR_STORE
 625           (gtk_sheet_get_model (var_sheet) );
 626
 627         /* This shouldn't be able to happen, because the menuitem
 628            should be disabled */
 629         g_return_if_fail (var_sheet->state  ==  GTK_SHEET_ROW_SELECTED );
 630
 631         psppire_dict_delete_variables (vs->dict,
 632                                        var_sheet->range.row0,
 633                                        1 +
 634                                        var_sheet->range.rowi -
 635                                        var_sheet->range.row0 );
 636       }
 637       break;
 638       case PAGE_DATA_SHEET:
 639         break;
 640       default:
 641         g_assert_not_reached ();
 642     }
 643 }
 644
 645
 646 /* Insert a new variable before the current row in the variable sheet,
 647    or before the current column in the data sheet, whichever is selected */
 648 static void
 649 insert_variable (GtkCheckMenuItem *m, gpointer data)
 650 {
 651   struct data_editor *de = data;
 652   gint posn;
 653
 654   GtkWidget *notebook = get_widget_assert (de->xml, "notebook");
 655
 656   GtkSheet *var_sheet =
 657     GTK_SHEET (get_widget_assert (de->xml, "variable_sheet"));
 658
 659   PsppireVarStore *vs = PSPPIRE_VAR_STORE
 660     (gtk_sheet_get_model (var_sheet) );
 661
 662   switch ( gtk_notebook_get_current_page ( GTK_NOTEBOOK (notebook)) )
 663     {
 664     case PAGE_VAR_SHEET:
 665       posn = var_sheet->active_cell.row;
 666       break;
 667     case PAGE_DATA_SHEET:
 668       {
 669         GtkSheet *data_sheet =
 670           GTK_SHEET (get_widget_assert (de->xml, "data_sheet"));
 671
 672         if ( data_sheet->state == GTK_SHEET_COLUMN_SELECTED )
 673           posn = data_sheet->range.col0;
 674         else
 675           posn = data_sheet->active_cell.col;
 676       }
 677       break;
 678     default:
 679       g_assert_not_reached ();
 680     }
 681
 682   psppire_dict_insert_variable (vs->dict, posn, NULL);
 683 }
 684
 685 /* Callback for when the dictionary changes its split variables */
 686 static void
 687 on_split_change (PsppireDict *dict, gpointer data)
 688 {
 689   struct data_editor *de = data;
 690
 691   size_t n_split_vars = dict_get_split_cnt (dict->dict);
 692
 693   GtkWidget *split_status_area =
 694     get_widget_assert (de->xml, "split-file-status-area");
 695
 696   if ( n_split_vars == 0 )
 697     {
 698       gtk_label_set_text (GTK_LABEL (split_status_area), _("No Split"));
 699     }
 700   else
 701     {
 702       gint i;
 703       GString *text;
 704       GtkSheet *var_sheet =
 705         GTK_SHEET (get_widget_assert (de->xml, "variable_sheet"));
 706
 707       PsppireVarStore *vs = PSPPIRE_VAR_STORE
 708         (gtk_sheet_get_model (var_sheet) );
 709
 710       struct variable *const * split_vars = dict_get_split_vars (dict->dict);
 711
 712       text = g_string_new (_("Split by "));
 713
 714       for (i = 0 ; i < n_split_vars - 1; ++i )
 715         {
 716           g_string_append_printf (text, "%s, ", var_get_name (split_vars[i]));
 717         }
 718       g_string_append (text, var_get_name (split_vars[i]));
 719
 720       gtk_label_set_text (GTK_LABEL (split_status_area), text->str);
 721
 722       g_string_free (text, TRUE);
 723     }
 724 }
 725
 726
 727 /* Callback for when the dictionary changes its filter variable */
 728 static void
 729 on_filter_change (GObject *o, gint filter_index, gpointer data)
 730 {
 731   struct data_editor *de = data;
 732   GtkWidget *filter_status_area =
 733     get_widget_assert (de->xml, "filter-use-status-area");
 734
 735   if ( filter_index == -1 )
 736     {
 737       gtk_label_set_text (GTK_LABEL (filter_status_area), _("Filter off"));
 738     }
 739   else
 740     {
 741       GtkSheet *var_sheet =
 742         GTK_SHEET (get_widget_assert (de->xml, "variable_sheet"));
 743
 744       PsppireVarStore *vs = PSPPIRE_VAR_STORE
 745         (gtk_sheet_get_model (var_sheet) );
 746
 747       struct variable *var = psppire_dict_get_variable (vs->dict,
 748                                                         filter_index);
 749
 750       gchar *text = g_strdup_printf (_("Filter by %s"), var_get_name (var));
 751
 752       gtk_label_set_text (GTK_LABEL (filter_status_area), text);
 753
 754       g_free (text);
 755     }
 756 }
 757
 758 /* Callback for when the dictionary changes its weights */
 759 static void
 760 on_weight_change (GObject *o, gint weight_index, gpointer data)
 761 {
 762   struct data_editor *de = data;
 763   GtkWidget *weight_status_area =
 764     get_widget_assert (de->xml, "weight-status-area");
 765
 766   if ( weight_index == -1 )
 767     {
 768       gtk_label_set_text (GTK_LABEL (weight_status_area), _("Weights off"));
 769     }
 770   else
 771     {
 772       GtkSheet *var_sheet =
 773         GTK_SHEET (get_widget_assert (de->xml, "variable_sheet"));
 774
 775       PsppireVarStore *vs = PSPPIRE_VAR_STORE
 776         (gtk_sheet_get_model (var_sheet) );
 777
 778       struct variable *var = psppire_dict_get_variable (vs->dict,
 779                                                         weight_index);
 780
 781       gchar *text = g_strdup_printf (_("Weight by %s"), var_get_name (var));
 782
 783       gtk_label_set_text (GTK_LABEL (weight_status_area), text);
 784
 785       g_free (text);
 786     }
 787 }
 788
 789
 790 static void
 791 weight_cases_dialog (GObject *o, gpointer data)
 792 {
 793   gint response;
 794   struct data_editor *de = data;
 795   GtkSheet *var_sheet =
 796     GTK_SHEET (get_widget_assert (de->xml, "variable_sheet"));
 797
 798
 799   GladeXML *xml = glade_xml_new (PKGDATADIR "/psppire.glade",
 800                                  "weight-cases-dialog", NULL);
 801
 802
 803   GtkWidget *treeview =  get_widget_assert (xml, "treeview");
 804   GtkWidget *entry =  get_widget_assert (xml, "entry1");
 805
 806
 807   PsppireVarStore *vs = PSPPIRE_VAR_STORE (gtk_sheet_get_model (var_sheet));
 808
 809   PsppireVarSelect *select = psppire_var_select_new (treeview,
 810                                                      entry, vs->dict);
 811
 812
 813   PsppireDialog *dialog = create_weight_dialog (select, xml);
 814
 815   response = psppire_dialog_run (dialog);
 816
 817   g_object_unref (xml);
 818
 819   if (response == GTK_RESPONSE_OK)
 820     {
 821       const GList *list = psppire_var_select_get_variables (select);
 822
 823       g_assert ( g_list_length (list) <= 1 );
 824
 825       if ( list == NULL)
 826         psppire_dict_set_weight_variable (select->dict, NULL);
 827       else
 828         {
 829           struct variable *var = list->data;
 830
 831           psppire_dict_set_weight_variable (select->dict, var);
 832         }
 833     }
 834 }
 835
 836