Remove deprecated objects GtkAction and GtkUIManager
[pspp] / 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 }
364
365
366 static char *
367 generate_syntax_filter (const PsppireDialogAction *a)
368 {
369   PsppireDialogActionSelect *scd = PSPPIRE_DIALOG_ACTION_SELECT (a);
370
371   gchar *text = NULL;
372   struct string dss;
373
374   const gchar *filter = "filter_$";
375   const gchar key[]="case_$";
376
377   ds_init_empty (&dss);
378
379   if (gtk_toggle_button_get_active
380       (GTK_TOGGLE_BUTTON (scd->radiobutton_range)))
381     {
382       ds_put_c_format (&dss,
383                        "COMPUTE filter_$ = ($CASENUM >= %ld "
384                        "AND $CASENUM <= %ld).\n",
385                        (long) gtk_spin_button_get_value (GTK_SPIN_BUTTON (scd->first)),
386                        (long) gtk_spin_button_get_value (GTK_SPIN_BUTTON (scd->last)));
387
388       ds_put_cstr (&dss, "EXECUTE.\n");
389     }
390   else if ( gtk_toggle_button_get_active
391             (GTK_TOGGLE_BUTTON (scd->radiobutton_sample)))
392     {
393       if ( gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (scd->percent)))
394         {
395           const double percentage =
396             gtk_spin_button_get_value (GTK_SPIN_BUTTON (scd->spinbutton));
397
398           ds_put_c_format (&dss,
399                            "COMPUTE %s = RV.UNIFORM (0,1) < %.*g.\n",
400                            filter,
401                            DBL_DIG + 1, percentage / 100.0 );
402         }
403       else
404         {
405           const gint n_cases =
406             gtk_spin_button_get_value (GTK_SPIN_BUTTON (scd->spin_sample_size));
407           const gint from_n_cases =
408             gtk_spin_button_get_value (GTK_SPIN_BUTTON (scd->spin_sample_limit));
409
410
411           const gchar ranvar[]="rv_$";
412
413           ds_put_c_format (&dss,
414                            "COMPUTE %s = $CASENUM.\n", key);
415
416           ds_put_c_format (&dss,
417                            "COMPUTE %s = %s > %d.\n",
418                            filter, key, from_n_cases);
419
420           ds_put_c_format (&dss,
421                            "COMPUTE %s = RV.UNIFORM (0, 1).\n",
422                            ranvar);
423
424           ds_put_c_format (&dss,
425                            "SORT BY %s, %s.\n",
426                            filter, ranvar);
427
428           ds_put_cstr (&dss, "EXECUTE.\n");
429                                   
430
431           ds_put_c_format (&dss,
432                            "COMPUTE %s = $CASENUM.\n",
433                            filter );
434
435           ds_put_c_format (&dss,
436                            "COMPUTE %s = %s <= %d\n",
437                            filter,
438                            filter,
439                            n_cases );
440
441           ds_put_cstr (&dss, "EXECUTE.\n");
442
443
444           ds_put_c_format (&dss,
445                            "SORT BY %s.\n",
446                            key);
447
448           ds_put_c_format (&dss,
449                            "DELETE VARIABLES %s, %s.\n",
450                            key, ranvar);
451         }
452
453       ds_put_cstr (&dss, "EXECUTE.\n");
454     }
455   else
456     {
457       filter = gtk_entry_get_text (GTK_ENTRY (scd->entry));
458     }
459
460   ds_put_c_format (&dss, "FILTER BY %s.\n", filter);
461
462   text  = ds_steal_cstr (&dss);
463
464   ds_destroy (&dss);
465
466   return text;
467 }
468
469
470 static gchar *
471 generate_syntax_delete (const PsppireDialogAction *a)
472 {
473   PsppireDialogActionSelect *scd = PSPPIRE_DIALOG_ACTION_SELECT (a);
474   gchar *text = NULL;
475   struct string dss;
476
477   if ( gtk_toggle_button_get_active
478        (GTK_TOGGLE_BUTTON (scd->radiobutton_all)))
479     {
480       return xstrdup ("\n");
481     }
482
483   ds_init_empty (&dss);
484
485   if ( gtk_toggle_button_get_active
486        (GTK_TOGGLE_BUTTON (scd->radiobutton_sample)))
487     {
488       ds_put_cstr (&dss, "SAMPLE ");
489       
490       if ( gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (scd->percent)))
491         {
492           const double percentage =
493             gtk_spin_button_get_value (GTK_SPIN_BUTTON (scd->spinbutton));
494           ds_put_c_format (&dss, "%g.", percentage / 100.0);
495         }
496       else
497         {
498           const gint n_cases =
499             gtk_spin_button_get_value (GTK_SPIN_BUTTON (scd->spin_sample_size));
500           const gint from_n_cases =
501             gtk_spin_button_get_value (GTK_SPIN_BUTTON (scd->spin_sample_limit));
502           
503           ds_put_c_format (&dss, "%d FROM %d .", n_cases, from_n_cases);
504         }
505       
506     }
507   else if ( gtk_toggle_button_get_active
508             (GTK_TOGGLE_BUTTON (scd->radiobutton_range)))
509     {
510       ds_put_c_format (&dss,
511                        "COMPUTE filter_$ = ($CASENUM >= %ld "
512                        "AND $CASENUM <= %ld).\n",
513                        (long) gtk_spin_button_get_value (GTK_SPIN_BUTTON (scd->first)),
514                        (long) gtk_spin_button_get_value (GTK_SPIN_BUTTON (scd->last)));
515       ds_put_cstr (&dss, "EXECUTE.\n");
516       ds_put_c_format (&dss, "SELECT IF filter_$.\n");
517
518     }
519   else if (gtk_toggle_button_get_active
520             (GTK_TOGGLE_BUTTON (scd->radiobutton_filter_variable)))
521     {
522       ds_put_c_format (&dss, "SELECT IF (%s <> 0).",
523                        gtk_entry_get_text (GTK_ENTRY (scd->entry)));
524     }
525
526
527   ds_put_cstr (&dss, "\n");
528
529   text = ds_steal_cstr (&dss);
530
531   ds_destroy (&dss);
532
533   return text;
534 }
535
536
537 static gchar *
538 generate_syntax (const PsppireDialogAction *a)
539 {
540   PsppireDialogActionSelect *scd = PSPPIRE_DIALOG_ACTION_SELECT (a);
541
542   /* In the simple case, all we need to do is cancel any existing filter */
543   if ( gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (scd->radiobutton_all)))
544     {
545       return g_strdup ("FILTER OFF.\n");
546     }
547   
548   /* Are we filtering or deleting ? */
549   if ( gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (scd->radiobutton_delete)))
550     {
551       return generate_syntax_delete (a);
552     }
553   else
554     {
555       return generate_syntax_filter (a);
556     }
557 }
558
559
560 static void
561 psppire_dialog_action_select_class_init (PsppireDialogActionSelectClass *class)
562 {
563   psppire_dialog_action_set_activation (class, psppire_dialog_action_select_activate);
564
565   PSPPIRE_DIALOG_ACTION_CLASS (class)->generate_syntax = generate_syntax;
566 }
567
568
569 static void
570 psppire_dialog_action_select_init (PsppireDialogActionSelect *act)
571 {
572 }
573