pintos-os.org Git - pspp/blob - src/ui/gui/psppire-dialog-action-select.c

   1 /* PSPPIRE - a graphical user interface for PSPP.
   2    Copyright (C) 2007, 2008, 2009, 2010, 2011, 2014, 2015 Free Software Foundation, Inc.
   3
   4    This program is free software: you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation, either version 3 of the License, or
   7    (at your option) any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program.  If not, see <http://www.gnu.org/licenses/>. */
  16
  17
  18 #include <config.h>
  19
  20
  21 #include "builder-wrapper.h"
  22 #include "dialog-common.h"
  23 #include "dict-display.h"
  24 #include "libpspp/str.h"
  25 #include "psppire-data-store.h"
  26 #include "psppire-data-window.h"
  27 #include "psppire-dialog-action-select.h"
  28 #include "psppire-dialog.h"
  29 #include "psppire-dict.h"
  30 #include "psppire-scanf.h"
  31 #include "psppire-value-entry.h"
  32 #include "psppire-var-view.h"
  33 #include "widget-io.h"
  34
  35 #include <ui/syntax-gen.h>
  36
  37
  38
  39 #include <gettext.h>
  40 #define _(msgid) gettext (msgid)
  41 #define N_(msgid) msgid
  42
  43 static void psppire_dialog_action_select_class_init (PsppireDialogActionSelectClass *class);
  44
  45 G_DEFINE_TYPE (PsppireDialogActionSelect, psppire_dialog_action_select, PSPPIRE_TYPE_DIALOG_ACTION);
  46
  47 static gboolean
  48 dialog_state_valid (gpointer data)
  49 {
  50   PsppireDialogActionSelect *act = PSPPIRE_DIALOG_ACTION_SELECT (data);
  51   if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (act->radiobutton_all)))
  52     {
  53       return TRUE;
  54     }
  55   else if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (act->radiobutton_filter_variable)))
  56     {
  57       const gchar *text = gtk_entry_get_text (GTK_ENTRY (act->entry));
  58       if (!psppire_dict_lookup_var (PSPPIRE_DIALOG_ACTION (act)->dict, text))
  59         return FALSE;
  60     }
  61
  62   return TRUE;
  63 }
  64
  65
  66 static void
  67 refresh (PsppireDialogAction *pda)
  68 {
  69   PsppireDialogActionSelect *act = PSPPIRE_DIALOG_ACTION_SELECT (pda);
  70
  71   gtk_entry_set_text (GTK_ENTRY (act->entry), "");
  72   gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (act->radiobutton_all), TRUE);
  73   gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (act->radiobutton_filter), TRUE);
  74
  75   gtk_label_set_text (GTK_LABEL (act->l1), "");
  76   gtk_label_set_text (GTK_LABEL (act->l0), "");
  77 }
  78
  79
  80 static void
  81 set_radiobutton (GtkWidget *button, gpointer data)
  82 {
  83   GtkToggleButton *toggle = data;
  84   gtk_toggle_button_set_active (toggle, TRUE);
  85 }
  86
  87
  88 static const gchar label1[] = N_("Approximately %3d%% of all cases.");
  89 static const gchar label2[] = N_("Exactly %3d cases from the first %3d cases.");
  90
  91
  92 /* Ensure that the range "first" and "last" spinbuttons are self consistent */
  93 static void
  94 sample_consistent (GtkSpinButton *spin, PsppireDialogActionSelect *act)
  95 {
  96   gdouble size = gtk_spin_button_get_value (GTK_SPIN_BUTTON (act->spin_sample_size));
  97   gdouble limit  = gtk_spin_button_get_value (GTK_SPIN_BUTTON (act->spin_sample_limit));
  98
  99   if (limit < size)
 100     {
 101       if (spin == GTK_SPIN_BUTTON (act->spin_sample_size))
 102         gtk_spin_button_set_value (GTK_SPIN_BUTTON (act->spin_sample_limit), size);
 103       if (spin == GTK_SPIN_BUTTON (act->spin_sample_limit))
 104         gtk_spin_button_set_value (GTK_SPIN_BUTTON (act->spin_sample_size), limit);
 105     }
 106 }
 107
 108
 109 static void
 110 sample_subdialog (GtkButton *b, gpointer data)
 111 {
 112   gint response;
 113   PsppireDialogActionSelect *scd = PSPPIRE_DIALOG_ACTION_SELECT (data);
 114   PsppireDialogAction *pda = PSPPIRE_DIALOG_ACTION (data);
 115
 116   PsppireDataStore *data_store = NULL;
 117   g_object_get (PSPPIRE_DATA_WINDOW (pda->toplevel)->data_editor,
 118                 "data-store", &data_store,
 119                 NULL);
 120
 121   gint case_count = psppire_data_store_get_case_count (data_store);
 122
 123   if (!scd->hbox1)
 124     {
 125       scd->hbox1 = psppire_scanf_new (gettext (label1), &scd->spinbutton);
 126
 127       gtk_widget_show (scd->hbox1);
 128
 129       gtk_grid_attach (GTK_GRID (scd->table),
 130                        scd->hbox1,
 131                        1, 0,
 132                        1, 1);
 133
 134       g_signal_connect (scd->percent, "toggled",
 135                         G_CALLBACK (set_sensitivity_from_toggle), scd->hbox1);
 136
 137       gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (scd->percent), TRUE);
 138     }
 139
 140
 141   if (!scd->hbox2)
 142     {
 143       scd->hbox2 =
 144         psppire_scanf_new (gettext (label2), &scd->spin_sample_size, &scd->spin_sample_limit);
 145
 146       gtk_spin_button_set_range (GTK_SPIN_BUTTON (scd->spin_sample_size),
 147                                  1, case_count);
 148
 149       gtk_spin_button_set_range (GTK_SPIN_BUTTON (scd->spin_sample_limit),
 150                                  1, case_count);
 151
 152       g_signal_connect (scd->spin_sample_size, "value-changed", G_CALLBACK (sample_consistent), scd);
 153       g_signal_connect (scd->spin_sample_limit, "value-changed", G_CALLBACK (sample_consistent), scd);
 154
 155
 156       gtk_widget_show (scd->hbox2);
 157       gtk_widget_set_sensitive (scd->hbox2, FALSE);
 158
 159       gtk_grid_attach (GTK_GRID (scd->table),
 160                        scd->hbox2,
 161                        1, 1, 1, 1);
 162
 163       g_signal_connect (scd->sample_n_cases, "toggled",
 164                         G_CALLBACK (set_sensitivity_from_toggle), scd->hbox2);
 165
 166       gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (scd->sample_n_cases), FALSE);
 167     }
 168
 169
 170   gtk_window_set_transient_for (GTK_WINDOW (scd->rsample_dialog),
 171                                 GTK_WINDOW (pda->dialog));
 172
 173   response = psppire_dialog_run (PSPPIRE_DIALOG (scd->rsample_dialog));
 174
 175   if ( response != PSPPIRE_RESPONSE_CONTINUE)
 176     {
 177       g_signal_handlers_disconnect_by_func
 178         (G_OBJECT (scd->percent),
 179          G_CALLBACK (set_sensitivity_from_toggle),
 180          scd->hbox1);
 181
 182       g_signal_handlers_disconnect_by_func
 183         (G_OBJECT (scd->sample_n_cases),
 184          G_CALLBACK (set_sensitivity_from_toggle),
 185          scd->hbox2);
 186
 187       gtk_widget_destroy(scd->hbox1);
 188       gtk_widget_destroy(scd->hbox2);
 189       scd->hbox1 = scd->hbox2 = NULL;
 190     }
 191   else
 192     {
 193       gchar *text;
 194
 195       if ( gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (scd->percent)))
 196         {
 197           text = widget_printf (gettext(label1), scd->spinbutton);
 198           gtk_label_set_text (GTK_LABEL (scd->l0), text);
 199         }
 200       else
 201         {
 202           text =
 203             widget_printf (gettext(label2), scd->spin_sample_size, scd->spin_sample_limit);
 204           gtk_label_set_text (GTK_LABEL (scd->l0), text);
 205
 206         }
 207       g_free (text);
 208     }
 209 }
 210
 211
 212
 213 static void
 214 range_subdialog (GtkButton *b, gpointer data)
 215 {
 216   gint response;
 217   PsppireDialogActionSelect *scd = PSPPIRE_DIALOG_ACTION_SELECT (data);
 218   PsppireDialogAction *pda = PSPPIRE_DIALOG_ACTION (data);
 219
 220   PsppireDataStore *data_store = NULL;
 221   g_object_get (PSPPIRE_DATA_WINDOW (pda->toplevel)->data_editor,
 222                 "data-store", &data_store,
 223                 NULL);
 224
 225   gint n_cases = psppire_data_store_get_case_count (data_store);
 226
 227   gtk_spin_button_set_range (GTK_SPIN_BUTTON (scd->last),  1,  n_cases);
 228   gtk_spin_button_set_range (GTK_SPIN_BUTTON (scd->first), 1,  n_cases);
 229
 230   gtk_window_set_transient_for (GTK_WINDOW (scd->range_subdialog),
 231                                 GTK_WINDOW (pda->dialog));
 232
 233   response = psppire_dialog_run (PSPPIRE_DIALOG (scd->range_subdialog));
 234   if ( response == PSPPIRE_RESPONSE_CONTINUE)
 235     {
 236       gchar *text = widget_printf (_("%d thru %d"), scd->first, scd->last);
 237       gtk_label_set_text (GTK_LABEL (scd->l1), text);
 238       g_free (text);
 239     }
 240 }
 241
 242 /* Ensure that the range "first" and "last" spinbuttons are self consistent */
 243 static void
 244 consistency (GtkSpinButton *spin, PsppireDialogActionSelect *act)
 245 {
 246   gdouble first = gtk_spin_button_get_value (GTK_SPIN_BUTTON (act->first));
 247   gdouble last  = gtk_spin_button_get_value (GTK_SPIN_BUTTON (act->last));
 248
 249   if (last < first)
 250     {
 251       if (spin == GTK_SPIN_BUTTON (act->first))
 252         gtk_spin_button_set_value (GTK_SPIN_BUTTON (act->last), first);
 253       if (spin == GTK_SPIN_BUTTON (act->last))
 254         gtk_spin_button_set_value (GTK_SPIN_BUTTON (act->first), last);
 255     }
 256 }
 257
 258 static void
 259 psppire_dialog_action_select_activate (PsppireDialogAction *a)
 260 {
 261   PsppireDialogActionSelect *act = PSPPIRE_DIALOG_ACTION_SELECT (a);
 262   PsppireDialogAction *pda = PSPPIRE_DIALOG_ACTION (a);
 263
 264   GHashTable *thing = psppire_dialog_action_get_hash_table (pda);
 265   GtkBuilder *xml = g_hash_table_lookup (thing, a);
 266   if (!xml)
 267     {
 268       xml = builder_new ("select-cases.ui");
 269       g_hash_table_insert (thing, a, xml);
 270
 271
 272       pda->dialog = get_widget_assert (xml, "select-cases-dialog");
 273       pda->source = get_widget_assert   (xml, "select-cases-treeview");
 274
 275       g_object_set (pda->source,
 276                     "selection-mode", GTK_SELECTION_SINGLE,
 277                     NULL);
 278
 279       act->entry = get_widget_assert (xml, "filter-variable-entry");
 280
 281       GtkWidget *selector = get_widget_assert (xml, "psppire-selector-filter");
 282       psppire_selector_set_filter_func (PSPPIRE_SELECTOR (selector),
 283                                         is_currently_in_entry);
 284
 285       act->rsample_dialog = get_widget_assert (xml, "select-cases-random-sample-dialog");
 286       act->percent = get_widget_assert (xml, "radiobutton-sample-percent");
 287       act->sample_n_cases = get_widget_assert (xml, "radiobutton-sample-n-cases");
 288       act->table = get_widget_assert (xml, "select-cases-random-sample-table");
 289
 290       act->l0 = get_widget_assert (xml, "random-sample-label");;
 291
 292       act->radiobutton_range = get_widget_assert (xml, "radiobutton-range");
 293       act->range_subdialog = get_widget_assert (xml, "select-cases-range-dialog");
 294
 295       act->first = get_widget_assert (xml, "range-dialog-first");
 296       act->last = get_widget_assert (xml, "range-dialog-last");
 297
 298       g_signal_connect (act->first, "value-changed", G_CALLBACK (consistency), act);
 299       g_signal_connect (act->last, "value-changed", G_CALLBACK (consistency), act);
 300
 301       act->l1 = get_widget_assert (xml, "range-sample-label");
 302       act->radiobutton_sample =  get_widget_assert (xml, "radiobutton-sample");
 303
 304       act->radiobutton_all = get_widget_assert (xml, "radiobutton-all");
 305       act->radiobutton_filter_variable =  get_widget_assert (xml, "radiobutton-filter-variable");
 306
 307       act->radiobutton_filter =  get_widget_assert (xml, "radiobutton-filter");
 308       act->radiobutton_delete = get_widget_assert (xml,   "radiobutton-delete");
 309
 310
 311       GtkWidget *button_range = get_widget_assert (xml, "button-range");
 312       GtkWidget *button_sample = get_widget_assert (xml, "button-sample");
 313
 314       GtkWidget *button_if =get_widget_assert (xml, "button-if");
 315
 316       GtkWidget *radiobutton_if = get_widget_assert (xml, "radiobutton-if");
 317
 318       GtkWidget *sample_label = get_widget_assert (xml, "random-sample-label");
 319
 320       g_signal_connect (act->radiobutton_all, "toggled",
 321                         G_CALLBACK (set_sensitivity_from_toggle_invert),
 322                         get_widget_assert (xml, "filter-delete-button-box"));
 323
 324       g_signal_connect (button_if, "clicked",
 325                         G_CALLBACK (set_radiobutton), radiobutton_if);
 326
 327       g_signal_connect (button_sample, "clicked",
 328                         G_CALLBACK (set_radiobutton), act->radiobutton_sample);
 329
 330       g_signal_connect (button_range,  "clicked",
 331                         G_CALLBACK (set_radiobutton), act->radiobutton_range);
 332
 333       g_signal_connect (selector, "clicked",
 334                         G_CALLBACK (set_radiobutton), act->radiobutton_filter_variable);
 335
 336       g_signal_connect (selector, "selected",
 337                         G_CALLBACK (set_radiobutton), act->radiobutton_filter_variable);
 338
 339       g_signal_connect (act->radiobutton_range, "toggled",
 340                         G_CALLBACK (set_sensitivity_from_toggle),
 341                         act->l1);
 342
 343       g_signal_connect (act->radiobutton_sample, "toggled",
 344                         G_CALLBACK (set_sensitivity_from_toggle),
 345                         sample_label);
 346
 347       g_signal_connect (act->radiobutton_filter_variable, "toggled",
 348                         G_CALLBACK (set_sensitivity_from_toggle),
 349                         act->entry);
 350
 351       g_signal_connect (button_range,
 352                         "clicked", G_CALLBACK (range_subdialog), act);
 353
 354       g_signal_connect (button_sample,
 355                         "clicked", G_CALLBACK (sample_subdialog), act);
 356     }
 357
 358   psppire_dialog_action_set_refresh (pda, refresh);
 359
 360   psppire_dialog_action_set_valid_predicate (pda,
 361                                         dialog_state_valid);
 362
 363   if (PSPPIRE_DIALOG_ACTION_CLASS (psppire_dialog_action_select_parent_class)->activate)
 364     PSPPIRE_DIALOG_ACTION_CLASS (psppire_dialog_action_select_parent_class)->activate (pda);
 365 }
 366
 367
 368 static char *
 369 generate_syntax_filter (PsppireDialogAction *a)
 370 {
 371   PsppireDialogActionSelect *scd = PSPPIRE_DIALOG_ACTION_SELECT (a);
 372
 373   gchar *text = NULL;
 374   struct string dss;
 375
 376   const gchar *filter = "filter_$";
 377   const gchar key[]="case_$";
 378
 379   ds_init_empty (&dss);
 380
 381   if (gtk_toggle_button_get_active
 382       (GTK_TOGGLE_BUTTON (scd->radiobutton_range)))
 383     {
 384       ds_put_c_format (&dss,
 385                        "COMPUTE filter_$ = ($CASENUM >= %ld "
 386                        "AND $CASENUM <= %ld).\n",
 387                        (long) gtk_spin_button_get_value (GTK_SPIN_BUTTON (scd->first)),
 388                        (long) gtk_spin_button_get_value (GTK_SPIN_BUTTON (scd->last)));
 389
 390       ds_put_cstr (&dss, "EXECUTE.\n");
 391     }
 392   else if ( gtk_toggle_button_get_active
 393             (GTK_TOGGLE_BUTTON (scd->radiobutton_sample)))
 394     {
 395       if ( gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (scd->percent)))
 396         {
 397           const double percentage =
 398             gtk_spin_button_get_value (GTK_SPIN_BUTTON (scd->spinbutton));
 399
 400           ds_put_c_format (&dss,
 401                            "COMPUTE %s = RV.UNIFORM (0,1) < %.*g.\n",
 402                            filter,
 403                            DBL_DIG + 1, percentage / 100.0 );
 404         }
 405       else
 406         {
 407           const gint n_cases =
 408             gtk_spin_button_get_value (GTK_SPIN_BUTTON (scd->spin_sample_size));
 409           const gint from_n_cases =
 410             gtk_spin_button_get_value (GTK_SPIN_BUTTON (scd->spin_sample_limit));
 411
 412
 413           const gchar ranvar[]="rv_$";
 414
 415           ds_put_c_format (&dss,
 416                            "COMPUTE %s = $CASENUM.\n", key);
 417
 418           ds_put_c_format (&dss,
 419                            "COMPUTE %s = %s > %d.\n",
 420                            filter, key, from_n_cases);
 421
 422           ds_put_c_format (&dss,
 423                            "COMPUTE %s = RV.UNIFORM (0, 1).\n",
 424                            ranvar);
 425
 426           ds_put_c_format (&dss,
 427                            "SORT BY %s, %s.\n",
 428                            filter, ranvar);
 429
 430           ds_put_cstr (&dss, "EXECUTE.\n");
 431
 432
 433           ds_put_c_format (&dss,
 434                            "COMPUTE %s = $CASENUM.\n",
 435                            filter );
 436
 437           ds_put_c_format (&dss,
 438                            "COMPUTE %s = %s <= %d\n",
 439                            filter,
 440                            filter,
 441                            n_cases );
 442
 443           ds_put_cstr (&dss, "EXECUTE.\n");
 444
 445
 446           ds_put_c_format (&dss,
 447                            "SORT BY %s.\n",
 448                            key);
 449
 450           ds_put_c_format (&dss,
 451                            "DELETE VARIABLES %s, %s.\n",
 452                            key, ranvar);
 453         }
 454
 455       ds_put_cstr (&dss, "EXECUTE.\n");
 456     }
 457   else
 458     {
 459       filter = gtk_entry_get_text (GTK_ENTRY (scd->entry));
 460     }
 461
 462   ds_put_c_format (&dss, "FILTER BY %s.\n", filter);
 463
 464   text  = ds_steal_cstr (&dss);
 465
 466   ds_destroy (&dss);
 467
 468   return text;
 469 }
 470
 471
 472 static gchar *
 473 generate_syntax_delete (PsppireDialogAction *a)
 474 {
 475   PsppireDialogActionSelect *scd = PSPPIRE_DIALOG_ACTION_SELECT (a);
 476   gchar *text = NULL;
 477   struct string dss;
 478
 479   if ( gtk_toggle_button_get_active
 480        (GTK_TOGGLE_BUTTON (scd->radiobutton_all)))
 481     {
 482       return xstrdup ("\n");
 483     }
 484
 485   ds_init_empty (&dss);
 486
 487   if ( gtk_toggle_button_get_active
 488        (GTK_TOGGLE_BUTTON (scd->radiobutton_sample)))
 489     {
 490       ds_put_cstr (&dss, "SAMPLE ");
 491
 492       if ( gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (scd->percent)))
 493         {
 494           const double percentage =
 495             gtk_spin_button_get_value (GTK_SPIN_BUTTON (scd->spinbutton));
 496           ds_put_c_format (&dss, "%g.", percentage / 100.0);
 497         }
 498       else
 499         {
 500           const gint n_cases =
 501             gtk_spin_button_get_value (GTK_SPIN_BUTTON (scd->spin_sample_size));
 502           const gint from_n_cases =
 503             gtk_spin_button_get_value (GTK_SPIN_BUTTON (scd->spin_sample_limit));
 504
 505           ds_put_c_format (&dss, "%d FROM %d .", n_cases, from_n_cases);
 506         }
 507
 508     }
 509   else if ( gtk_toggle_button_get_active
 510             (GTK_TOGGLE_BUTTON (scd->radiobutton_range)))
 511     {
 512       ds_put_c_format (&dss,
 513                        "COMPUTE filter_$ = ($CASENUM >= %ld "
 514                        "AND $CASENUM <= %ld).\n",
 515                        (long) gtk_spin_button_get_value (GTK_SPIN_BUTTON (scd->first)),
 516                        (long) gtk_spin_button_get_value (GTK_SPIN_BUTTON (scd->last)));
 517       ds_put_cstr (&dss, "EXECUTE.\n");
 518       ds_put_c_format (&dss, "SELECT IF filter_$.\n");
 519
 520     }
 521   else if (gtk_toggle_button_get_active
 522             (GTK_TOGGLE_BUTTON (scd->radiobutton_filter_variable)))
 523     {
 524       ds_put_c_format (&dss, "SELECT IF (%s <> 0).",
 525                        gtk_entry_get_text (GTK_ENTRY (scd->entry)));
 526     }
 527
 528
 529   ds_put_cstr (&dss, "\n");
 530
 531   text = ds_steal_cstr (&dss);
 532
 533   ds_destroy (&dss);
 534
 535   return text;
 536 }
 537
 538
 539 static gchar *
 540 generate_syntax (PsppireDialogAction *a)
 541 {
 542   PsppireDialogActionSelect *scd = PSPPIRE_DIALOG_ACTION_SELECT (a);
 543
 544   /* In the simple case, all we need to do is cancel any existing filter */
 545   if ( gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (scd->radiobutton_all)))
 546     {
 547       return g_strdup ("FILTER OFF.\n");
 548     }
 549
 550   /* Are we filtering or deleting ? */
 551   if ( gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (scd->radiobutton_delete)))
 552     {
 553       return generate_syntax_delete (a);
 554     }
 555   else
 556     {
 557       return generate_syntax_filter (a);
 558     }
 559 }
 560
 561
 562 static void
 563 psppire_dialog_action_select_class_init (PsppireDialogActionSelectClass *class)
 564 {
 565   psppire_dialog_action_set_activation (class, psppire_dialog_action_select_activate);
 566
 567   PSPPIRE_DIALOG_ACTION_CLASS (class)->generate_syntax = generate_syntax;
 568 }
 569
 570
 571 static void
 572 psppire_dialog_action_select_init (PsppireDialogActionSelect *act)
 573 {
 574 }
 575