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 GtkBuilder *
 259 psppire_dialog_action_select_activate (PsppireDialogAction *a, GVariant *param)
 260 {
 261   PsppireDialogActionSelect *act = PSPPIRE_DIALOG_ACTION_SELECT (a);
 262   PsppireDialogAction *pda = PSPPIRE_DIALOG_ACTION (a);
 263
 264   GtkBuilder *xml = builder_new ( "select-cases.ui");
 265
 266   pda->dialog = get_widget_assert (xml, "select-cases-dialog");
 267   pda->source = get_widget_assert   (xml, "select-cases-treeview");
 268
 269   g_object_set (pda->source,
 270                 "selection-mode", GTK_SELECTION_SINGLE,
 271                 NULL);
 272
 273   act->entry = get_widget_assert (xml, "filter-variable-entry");
 274
 275   GtkWidget *selector = get_widget_assert (xml, "psppire-selector-filter");
 276   psppire_selector_set_filter_func (PSPPIRE_SELECTOR (selector),
 277                                     is_currently_in_entry);
 278
 279   act->rsample_dialog = get_widget_assert (xml, "select-cases-random-sample-dialog");
 280   act->percent = get_widget_assert (xml, "radiobutton-sample-percent");
 281   act->sample_n_cases = get_widget_assert (xml, "radiobutton-sample-n-cases");
 282   act->table = get_widget_assert (xml, "select-cases-random-sample-table");
 283
 284   act->l0 = get_widget_assert (xml, "random-sample-label");;
 285
 286   act->radiobutton_range = get_widget_assert (xml, "radiobutton-range");
 287   act->range_subdialog = get_widget_assert (xml, "select-cases-range-dialog");
 288
 289   act->first = get_widget_assert (xml, "range-dialog-first");
 290   act->last = get_widget_assert (xml, "range-dialog-last");
 291
 292   g_signal_connect (act->first, "value-changed", G_CALLBACK (consistency), act);
 293   g_signal_connect (act->last, "value-changed", G_CALLBACK (consistency), act);
 294
 295   act->l1 = get_widget_assert (xml, "range-sample-label");
 296   act->radiobutton_sample =  get_widget_assert (xml, "radiobutton-sample");
 297
 298   act->radiobutton_all = get_widget_assert (xml, "radiobutton-all");
 299   act->radiobutton_filter_variable =  get_widget_assert (xml, "radiobutton-filter-variable");
 300
 301   act->radiobutton_filter =  get_widget_assert (xml, "radiobutton-filter");
 302   act->radiobutton_delete = get_widget_assert (xml,   "radiobutton-delete");
 303
 304
 305   GtkWidget     *button_range = get_widget_assert (xml, "button-range");
 306   GtkWidget *button_sample = get_widget_assert (xml, "button-sample");
 307
 308   GtkWidget *button_if =get_widget_assert (xml, "button-if");
 309
 310   GtkWidget *radiobutton_if = get_widget_assert (xml, "radiobutton-if");
 311
 312   GtkWidget *sample_label = get_widget_assert (xml, "random-sample-label");
 313
 314   g_signal_connect (act->radiobutton_all, "toggled",
 315                     G_CALLBACK (set_sensitivity_from_toggle_invert),
 316                     get_widget_assert (xml, "filter-delete-button-box"));
 317
 318   g_signal_connect (button_if, "clicked",
 319                     G_CALLBACK (set_radiobutton), radiobutton_if);
 320
 321   g_signal_connect (button_sample, "clicked",
 322                     G_CALLBACK (set_radiobutton), act->radiobutton_sample);
 323
 324   g_signal_connect (button_range,  "clicked",
 325                     G_CALLBACK (set_radiobutton), act->radiobutton_range);
 326
 327   g_signal_connect (selector, "clicked",
 328                     G_CALLBACK (set_radiobutton), act->radiobutton_filter_variable);
 329
 330   g_signal_connect (selector, "selected",
 331                     G_CALLBACK (set_radiobutton), act->radiobutton_filter_variable);
 332
 333   g_signal_connect (act->radiobutton_range, "toggled",
 334                     G_CALLBACK (set_sensitivity_from_toggle),
 335                     act->l1);
 336
 337   g_signal_connect (act->radiobutton_sample, "toggled",
 338                     G_CALLBACK (set_sensitivity_from_toggle),
 339                     sample_label);
 340
 341   g_signal_connect (act->radiobutton_filter_variable, "toggled",
 342                     G_CALLBACK (set_sensitivity_from_toggle),
 343                     act->entry);
 344
 345   g_signal_connect (button_range,
 346                     "clicked", G_CALLBACK (range_subdialog), act);
 347
 348   g_signal_connect (button_sample,
 349                     "clicked", G_CALLBACK (sample_subdialog), act);
 350   psppire_dialog_action_set_refresh (pda, refresh);
 351
 352   psppire_dialog_action_set_valid_predicate (pda,
 353                                              dialog_state_valid);
 354   return xml;
 355 }
 356
 357
 358 static char *
 359 generate_syntax_filter (const PsppireDialogAction *a)
 360 {
 361   PsppireDialogActionSelect *scd = PSPPIRE_DIALOG_ACTION_SELECT (a);
 362
 363   gchar *text = NULL;
 364   struct string dss;
 365
 366   const gchar *filter = "filter_$";
 367   const gchar key[]="case_$";
 368
 369   ds_init_empty (&dss);
 370
 371   if (gtk_toggle_button_get_active
 372       (GTK_TOGGLE_BUTTON (scd->radiobutton_range)))
 373     {
 374       ds_put_c_format (&dss,
 375                        "COMPUTE filter_$ = ($CASENUM >= %ld "
 376                        "AND $CASENUM <= %ld).\n",
 377                        (long) gtk_spin_button_get_value (GTK_SPIN_BUTTON (scd->first)),
 378                        (long) gtk_spin_button_get_value (GTK_SPIN_BUTTON (scd->last)));
 379
 380       ds_put_cstr (&dss, "EXECUTE.\n");
 381     }
 382   else if ( gtk_toggle_button_get_active
 383             (GTK_TOGGLE_BUTTON (scd->radiobutton_sample)))
 384     {
 385       if ( gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (scd->percent)))
 386         {
 387           const double percentage =
 388             gtk_spin_button_get_value (GTK_SPIN_BUTTON (scd->spinbutton));
 389
 390           ds_put_c_format (&dss,
 391                            "COMPUTE %s = RV.UNIFORM (0,1) < %.*g.\n",
 392                            filter,
 393                            DBL_DIG + 1, percentage / 100.0 );
 394         }
 395       else
 396         {
 397           const gint n_cases =
 398             gtk_spin_button_get_value (GTK_SPIN_BUTTON (scd->spin_sample_size));
 399           const gint from_n_cases =
 400             gtk_spin_button_get_value (GTK_SPIN_BUTTON (scd->spin_sample_limit));
 401
 402
 403           const gchar ranvar[]="rv_$";
 404
 405           ds_put_c_format (&dss,
 406                            "COMPUTE %s = $CASENUM.\n", key);
 407
 408           ds_put_c_format (&dss,
 409                            "COMPUTE %s = %s > %d.\n",
 410                            filter, key, from_n_cases);
 411
 412           ds_put_c_format (&dss,
 413                            "COMPUTE %s = RV.UNIFORM (0, 1).\n",
 414                            ranvar);
 415
 416           ds_put_c_format (&dss,
 417                            "SORT BY %s, %s.\n",
 418                            filter, ranvar);
 419
 420           ds_put_cstr (&dss, "EXECUTE.\n");
 421
 422
 423           ds_put_c_format (&dss,
 424                            "COMPUTE %s = $CASENUM.\n",
 425                            filter );
 426
 427           ds_put_c_format (&dss,
 428                            "COMPUTE %s = %s <= %d\n",
 429                            filter,
 430                            filter,
 431                            n_cases );
 432
 433           ds_put_cstr (&dss, "EXECUTE.\n");
 434
 435
 436           ds_put_c_format (&dss,
 437                            "SORT BY %s.\n",
 438                            key);
 439
 440           ds_put_c_format (&dss,
 441                            "DELETE VARIABLES %s, %s.\n",
 442                            key, ranvar);
 443         }
 444
 445       ds_put_cstr (&dss, "EXECUTE.\n");
 446     }
 447   else
 448     {
 449       filter = gtk_entry_get_text (GTK_ENTRY (scd->entry));
 450     }
 451
 452   ds_put_c_format (&dss, "FILTER BY %s.\n", filter);
 453
 454   text  = ds_steal_cstr (&dss);
 455
 456   ds_destroy (&dss);
 457
 458   return text;
 459 }
 460
 461
 462 static gchar *
 463 generate_syntax_delete (const PsppireDialogAction *a)
 464 {
 465   PsppireDialogActionSelect *scd = PSPPIRE_DIALOG_ACTION_SELECT (a);
 466   gchar *text = NULL;
 467   struct string dss;
 468
 469   if ( gtk_toggle_button_get_active
 470        (GTK_TOGGLE_BUTTON (scd->radiobutton_all)))
 471     {
 472       return xstrdup ("\n");
 473     }
 474
 475   ds_init_empty (&dss);
 476
 477   if ( gtk_toggle_button_get_active
 478        (GTK_TOGGLE_BUTTON (scd->radiobutton_sample)))
 479     {
 480       ds_put_cstr (&dss, "SAMPLE ");
 481
 482       if ( gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (scd->percent)))
 483         {
 484           const double percentage =
 485             gtk_spin_button_get_value (GTK_SPIN_BUTTON (scd->spinbutton));
 486           ds_put_c_format (&dss, "%g.", percentage / 100.0);
 487         }
 488       else
 489         {
 490           const gint n_cases =
 491             gtk_spin_button_get_value (GTK_SPIN_BUTTON (scd->spin_sample_size));
 492           const gint from_n_cases =
 493             gtk_spin_button_get_value (GTK_SPIN_BUTTON (scd->spin_sample_limit));
 494
 495           ds_put_c_format (&dss, "%d FROM %d .", n_cases, from_n_cases);
 496         }
 497
 498     }
 499   else if ( gtk_toggle_button_get_active
 500             (GTK_TOGGLE_BUTTON (scd->radiobutton_range)))
 501     {
 502       ds_put_c_format (&dss,
 503                        "COMPUTE filter_$ = ($CASENUM >= %ld "
 504                        "AND $CASENUM <= %ld).\n",
 505                        (long) gtk_spin_button_get_value (GTK_SPIN_BUTTON (scd->first)),
 506                        (long) gtk_spin_button_get_value (GTK_SPIN_BUTTON (scd->last)));
 507       ds_put_cstr (&dss, "EXECUTE.\n");
 508       ds_put_c_format (&dss, "SELECT IF filter_$.\n");
 509
 510     }
 511   else if (gtk_toggle_button_get_active
 512             (GTK_TOGGLE_BUTTON (scd->radiobutton_filter_variable)))
 513     {
 514       ds_put_c_format (&dss, "SELECT IF (%s <> 0).",
 515                        gtk_entry_get_text (GTK_ENTRY (scd->entry)));
 516     }
 517
 518
 519   ds_put_cstr (&dss, "\n");
 520
 521   text = ds_steal_cstr (&dss);
 522
 523   ds_destroy (&dss);
 524
 525   return text;
 526 }
 527
 528
 529 static gchar *
 530 generate_syntax (const PsppireDialogAction *a)
 531 {
 532   PsppireDialogActionSelect *scd = PSPPIRE_DIALOG_ACTION_SELECT (a);
 533
 534   /* In the simple case, all we need to do is cancel any existing filter */
 535   if ( gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (scd->radiobutton_all)))
 536     {
 537       return g_strdup ("FILTER OFF.\n");
 538     }
 539
 540   /* Are we filtering or deleting ? */
 541   if ( gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (scd->radiobutton_delete)))
 542     {
 543       return generate_syntax_delete (a);
 544     }
 545   else
 546     {
 547       return generate_syntax_filter (a);
 548     }
 549 }
 550
 551
 552 static void
 553 psppire_dialog_action_select_class_init (PsppireDialogActionSelectClass *class)
 554 {
 555   PSPPIRE_DIALOG_ACTION_CLASS (class)->initial_activate = psppire_dialog_action_select_activate;
 556
 557   PSPPIRE_DIALOG_ACTION_CLASS (class)->generate_syntax = generate_syntax;
 558 }
 559
 560
 561 static void
 562 psppire_dialog_action_select_init (PsppireDialogActionSelect *act)
 563 {
 564 }
 565