fixed goto case dialog
[pspp] / src / ui / gui / missing-val-dialog.c
1 /* PSPPIRE - a graphical user interface for PSPP.
2    Copyright (C) 2005, 2006, 2009, 2011, 2012, 2015, 2016  Free Software Foundation
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 /*  This module describes the behaviour of the Missing Values dialog box,
18     used for input of the missing values in the variable sheet */
19
20 #include <config.h>
21
22 #include "ui/gui/missing-val-dialog.h"
23
24 #include "builder-wrapper.h"
25 #include "helper.h"
26 #include <data/format.h>
27 #include "missing-val-dialog.h"
28 #include <data/missing-values.h>
29 #include <data/variable.h>
30 #include <data/data-in.h>
31
32 #include <gtk/gtk.h>
33
34 #include <string.h>
35
36 #include <gettext.h>
37 #define _(msgid) gettext (msgid)
38 #define N_(msgid) msgid
39
40 static GObject *psppire_missing_val_dialog_constructor (
41   GType type, guint, GObjectConstructParam *);
42 static void psppire_missing_val_dialog_finalize (GObject *);
43
44 G_DEFINE_TYPE (PsppireMissingValDialog,
45                psppire_missing_val_dialog,
46                PSPPIRE_TYPE_DIALOG);
47 enum
48   {
49     PROP_0,
50     PROP_VARIABLE,
51     PROP_MISSING_VALUES
52   };
53
54 static void
55 psppire_missing_val_dialog_set_property (GObject      *object,
56                                          guint         prop_id,
57                                          const GValue *value,
58                                          GParamSpec   *pspec)
59 {
60   PsppireMissingValDialog *obj = PSPPIRE_MISSING_VAL_DIALOG (object);
61
62   switch (prop_id)
63     {
64     case PROP_VARIABLE:
65       psppire_missing_val_dialog_set_variable (obj,
66                                                g_value_get_pointer (value));
67       break;
68     case PROP_MISSING_VALUES:
69     default:
70       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
71       break;
72     }
73 }
74
75 static void
76 psppire_missing_val_dialog_get_property (GObject      *object,
77                                          guint         prop_id,
78                                          GValue       *value,
79                                          GParamSpec   *pspec)
80 {
81   PsppireMissingValDialog *obj = PSPPIRE_MISSING_VAL_DIALOG (object);
82
83   switch (prop_id)
84     {
85     case PROP_MISSING_VALUES:
86       g_value_set_pointer (value, &obj->mvl);
87       break;
88     case PROP_VARIABLE:
89     default:
90       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
91       break;
92     }
93 }
94
95 static void
96 psppire_missing_val_dialog_class_init (PsppireMissingValDialogClass *class)
97 {
98   GObjectClass *gobject_class;
99   gobject_class = G_OBJECT_CLASS (class);
100
101   gobject_class->constructor = psppire_missing_val_dialog_constructor;
102   gobject_class->finalize = psppire_missing_val_dialog_finalize;
103   gobject_class->set_property = psppire_missing_val_dialog_set_property;
104   gobject_class->get_property = psppire_missing_val_dialog_get_property;
105
106   g_object_class_install_property (
107     gobject_class, PROP_VARIABLE,
108     g_param_spec_pointer ("variable",
109                           "Variable",
110                           "Variable whose missing values are to be edited.  "
111                           "The variable's print format and encoding are also "
112                           "used for editing.",
113                           G_PARAM_WRITABLE));
114
115   g_object_class_install_property (
116     gobject_class, PROP_MISSING_VALUES,
117     g_param_spec_pointer ("missing-values",
118                           "Missing Values",
119                           "Edited missing values.",
120                           G_PARAM_READABLE));
121 }
122
123 static void
124 psppire_missing_val_dialog_init (PsppireMissingValDialog *dialog)
125 {
126   /* We do all of our work on widgets in the constructor function, because that
127      runs after the construction properties have been set.  Otherwise
128      PsppireDialog's "orientation" property hasn't been set and therefore we
129      have no box to populate. */
130   mv_init (&dialog->mvl, 0);
131   dialog->encoding = NULL;
132 }
133
134 static void
135 psppire_missing_val_dialog_finalize (GObject *obj)
136 {
137   PsppireMissingValDialog *dialog = PSPPIRE_MISSING_VAL_DIALOG (obj);
138
139   mv_destroy (&dialog->mvl);
140   g_free (dialog->encoding);
141
142   G_OBJECT_CLASS (psppire_missing_val_dialog_parent_class)->finalize (obj);
143 }
144
145 PsppireMissingValDialog *
146 psppire_missing_val_dialog_new (const struct variable *var)
147 {
148   return PSPPIRE_MISSING_VAL_DIALOG (
149     g_object_new (PSPPIRE_TYPE_MISSING_VAL_DIALOG,
150                   "variable", var,
151                   NULL));
152 }
153
154 gint
155 psppire_missing_val_dialog_run (GtkWindow *parent_window,
156                                 const struct variable *var,
157                                 struct missing_values *mv)
158 {
159   PsppireMissingValDialog *dialog;
160
161   dialog = psppire_missing_val_dialog_new (var);
162   gtk_window_set_transient_for (GTK_WINDOW (dialog), parent_window);
163   gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
164   gtk_widget_show (GTK_WIDGET (dialog));
165
166   gint result = psppire_dialog_run (PSPPIRE_DIALOG (dialog));
167   if (result == GTK_RESPONSE_OK)
168     mv_copy (mv, psppire_missing_val_dialog_get_missing_values (dialog));
169   else
170     mv_copy (mv, var_get_missing_values (var));
171
172   gtk_widget_destroy (GTK_WIDGET (dialog));
173   return result;
174 }
175
176
177 /* A simple (sub) dialog box for displaying user input errors */
178 static void
179 err_dialog (const gchar *msg, GtkWindow *window)
180 {
181   GtkWidget *dialog =
182     gtk_message_dialog_new (window,
183                             GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
184                             GTK_MESSAGE_ERROR,
185                             GTK_BUTTONS_CLOSE,
186                             "%s",msg);
187
188   gtk_dialog_run (GTK_DIALOG (dialog));
189   gtk_widget_destroy (dialog);
190 }
191
192 /* Interpret text, display error dialog
193    If parsing is o.k., the value is initialized and it is the responsibility of
194    the caller to destroy the variable. */
195 static gboolean
196 try_missing_value(const PsppireMissingValDialog *dialog, const gchar *text, union value *vp)
197 {
198   const int var_width = fmt_var_width (&dialog->format);
199   char *error_txt = NULL;
200
201   value_init(vp, var_width);
202   error_txt = data_in (ss_cstr(text), "UTF-8", dialog->format.type,
203                        vp, var_width, dialog->encoding);
204   if (error_txt)
205     {
206       err_dialog (error_txt, GTK_WINDOW (dialog));
207       free (error_txt);
208       goto error;
209     }
210   else
211     {
212       if (mv_is_acceptable (vp, var_width))
213         return TRUE;
214       else
215         {
216           err_dialog (_("The maximum length of a missing value"
217                         " for a string variable is 8 in UTF-8."),
218                       GTK_WINDOW (dialog));
219           goto error;
220         }
221     }
222  error:
223   value_destroy (vp, var_width);
224   return FALSE;
225 }
226
227 /* Acceptability predicate for PsppireMissingValDialog.
228
229    This function is also the only place that dialog->mvl gets updated. */
230 static gboolean
231 missing_val_dialog_acceptable (gpointer data)
232 {
233   PsppireMissingValDialog *dialog = data;
234   int var_width = fmt_var_width (&dialog->format);
235
236   if ( gtk_toggle_button_get_active (dialog->button_discrete))
237     {
238       gint nvals = 0;
239       gint i;
240
241       mv_clear(&dialog->mvl);
242       for(i = 0 ; i < 3 ; ++i )
243         {
244           gchar *text =
245             g_strdup (gtk_entry_get_text (GTK_ENTRY (dialog->mv[i])));
246
247           union value v;
248           if ( !text || strlen (g_strstrip (text)) == 0 )
249             {
250               g_free (text);
251               continue;
252             }
253
254           if (!try_missing_value (dialog, text, &v))
255             {
256               g_free (text);
257               gtk_widget_grab_focus (dialog->mv[i]);
258               return FALSE;
259             }
260           mv_add_value (&dialog->mvl, &v);
261           nvals++;
262           g_free (text);
263           value_destroy (&v, var_width);
264         }
265       if ( nvals == 0 )
266         {
267           err_dialog (_("At least one value must be specified"),
268                       GTK_WINDOW (dialog));
269           gtk_widget_grab_focus (dialog->mv[0]);
270           return FALSE;
271         }
272     }
273
274   if (gtk_toggle_button_get_active (dialog->button_range))
275     {
276       gchar *discrete_text;
277       union value low_val ;
278       union value high_val;
279       const gchar *low_text = gtk_entry_get_text (GTK_ENTRY (dialog->low));
280       const gchar *high_text = gtk_entry_get_text (GTK_ENTRY (dialog->high));
281
282       assert (var_width == 0); /* Ranges are only for numeric variables */
283
284       if (!try_missing_value(dialog, low_text, &low_val))
285         {
286           gtk_widget_grab_focus (dialog->low);
287           return FALSE;
288         }
289       if (!try_missing_value (dialog, high_text, &high_val))
290         {
291           gtk_widget_grab_focus (dialog->high);
292           value_destroy (&low_val, var_width);
293           return FALSE;
294         }
295       if (low_val.f > high_val.f)
296         {
297           err_dialog (_("Incorrect range specification"),
298                       GTK_WINDOW (dialog));
299           value_destroy (&low_val, var_width);
300           value_destroy (&high_val, var_width);
301           gtk_widget_grab_focus (dialog->low);
302           return FALSE;
303         }
304       mv_clear (&dialog->mvl);
305       mv_add_range (&dialog->mvl, low_val.f, high_val.f);
306       value_destroy (&low_val, var_width);
307       value_destroy (&high_val, var_width);
308
309       discrete_text = g_strdup (gtk_entry_get_text (GTK_ENTRY (dialog->discrete)));
310
311       if ( discrete_text && strlen (g_strstrip (discrete_text)) > 0 )
312         {
313           union value discrete_val;
314           if (!try_missing_value (dialog, discrete_text, &discrete_val))
315             {
316               g_free (discrete_text);
317               gtk_widget_grab_focus (dialog->discrete);
318               return FALSE;
319             }
320           mv_add_value (&dialog->mvl, &discrete_val);
321           value_destroy (&discrete_val, var_width);
322         }
323       g_free (discrete_text);
324     }
325
326   if (gtk_toggle_button_get_active (dialog->button_none))
327     mv_clear (&dialog->mvl);
328
329   return TRUE;
330 }
331
332
333 /* Callback which occurs when the 'discrete' radiobutton is toggled */
334 static void
335 discrete (GtkToggleButton *button, gpointer data)
336 {
337   gint i;
338   PsppireMissingValDialog *dialog = data;
339
340   for (i = 0 ; i < 3 ; ++i )
341     {
342       gtk_widget_set_sensitive (dialog->mv[i],
343                                gtk_toggle_button_get_active (button));
344     }
345 }
346
347 /* Callback which occurs when the 'range' radiobutton is toggled */
348 static void
349 range (GtkToggleButton *button, gpointer data)
350 {
351   PsppireMissingValDialog *dialog = data;
352
353   const gboolean active = gtk_toggle_button_get_active (button);
354
355   gtk_widget_set_sensitive (dialog->low, active);
356   gtk_widget_set_sensitive (dialog->high, active);
357   gtk_widget_set_sensitive (dialog->discrete, active);
358 }
359
360
361
362 /* Shows the dialog box and sets default values */
363 static GObject *
364 psppire_missing_val_dialog_constructor (GType                  type,
365                                         guint                  n_properties,
366                                         GObjectConstructParam *properties)
367 {
368   PsppireMissingValDialog *dialog;
369   GtkContainer *content_area;
370   GtkBuilder *xml;
371   GObject *obj;
372
373   obj = G_OBJECT_CLASS (psppire_missing_val_dialog_parent_class)->constructor (
374     type, n_properties, properties);
375   dialog = PSPPIRE_MISSING_VAL_DIALOG (obj);
376
377   content_area = GTK_CONTAINER (PSPPIRE_DIALOG (dialog));
378   xml = builder_new ("missing-val-dialog.ui");
379   gtk_container_add (GTK_CONTAINER (content_area),
380                      get_widget_assert (xml, "missing-values-dialog"));
381
382   dialog->mv[0] = get_widget_assert (xml, "mv0");
383   dialog->mv[1] = get_widget_assert (xml, "mv1");
384   dialog->mv[2] = get_widget_assert (xml, "mv2");
385
386   dialog->low = get_widget_assert (xml, "mv-low");
387   dialog->high = get_widget_assert (xml, "mv-high");
388   dialog->discrete = get_widget_assert (xml, "mv-discrete");
389
390
391   dialog->button_none     =
392     GTK_TOGGLE_BUTTON (get_widget_assert (xml, "no_missing"));
393
394   dialog->button_discrete =
395     GTK_TOGGLE_BUTTON (get_widget_assert (xml, "discrete_missing"));
396
397   dialog->button_range    =
398     GTK_TOGGLE_BUTTON (get_widget_assert (xml, "range_missing"));
399
400   psppire_dialog_set_accept_predicate (PSPPIRE_DIALOG (dialog),
401                                        missing_val_dialog_acceptable,
402                                        dialog);
403
404   g_signal_connect (dialog->button_discrete, "toggled",
405                    G_CALLBACK (discrete), dialog);
406
407   g_signal_connect (dialog->button_range, "toggled",
408                    G_CALLBACK (range), dialog);
409
410   g_object_unref (xml);
411
412   return obj;
413 }
414
415 void
416 psppire_missing_val_dialog_set_variable (PsppireMissingValDialog *dialog,
417                                          const struct variable *var)
418 {
419   enum val_type var_type;
420   gint i;
421
422   mv_destroy (&dialog->mvl);
423   g_free (dialog->encoding);
424
425   if (var != NULL)
426     {
427       const struct missing_values *vmv = var_get_missing_values (var);
428       if (mv_is_empty(vmv))
429         mv_init (&dialog->mvl, var_get_width(var));
430       else
431         mv_copy (&dialog->mvl, vmv);
432       dialog->encoding = g_strdup (var_get_encoding (var));
433       dialog->format = *var_get_print_format (var);
434     }
435   else
436     {
437       mv_init (&dialog->mvl, 0);
438       dialog->encoding = NULL;
439       dialog->format = F_8_0;
440     }
441
442   /* Blank all entry boxes and make them insensitive */
443   gtk_entry_set_text (GTK_ENTRY (dialog->low), "");
444   gtk_entry_set_text (GTK_ENTRY (dialog->high), "");
445   gtk_entry_set_text (GTK_ENTRY (dialog->discrete), "");
446   gtk_widget_set_sensitive (dialog->low, FALSE);
447   gtk_widget_set_sensitive (dialog->high, FALSE);
448   gtk_widget_set_sensitive (dialog->discrete, FALSE);
449
450   var_type = val_type_from_width (fmt_var_width (&dialog->format));
451   gtk_widget_set_sensitive (GTK_WIDGET (dialog->button_range),
452                             var_type == VAL_NUMERIC);
453
454   if (var == NULL)
455     return;
456
457   for (i = 0 ; i < 3 ; ++i )
458     {
459       gtk_entry_set_text (GTK_ENTRY (dialog->mv[i]), "");
460       gtk_widget_set_sensitive (dialog->mv[i], FALSE);
461     }
462
463   if ( mv_has_range (&dialog->mvl))
464     {
465       union value low, high;
466       gchar *low_text;
467       gchar *high_text;
468       mv_get_range (&dialog->mvl, &low.f, &high.f);
469
470
471       low_text = value_to_text__ (low, &dialog->format, dialog->encoding);
472       high_text = value_to_text__ (high, &dialog->format, dialog->encoding);
473
474       gtk_entry_set_text (GTK_ENTRY (dialog->low), low_text);
475       gtk_entry_set_text (GTK_ENTRY (dialog->high), high_text);
476       g_free (low_text);
477       g_free (high_text);
478
479       if ( mv_has_value (&dialog->mvl))
480         {
481           gchar *text;
482           text = value_to_text__ (*mv_get_value (&dialog->mvl, 0),
483                                   &dialog->format, dialog->encoding);
484           gtk_entry_set_text (GTK_ENTRY (dialog->discrete), text);
485           g_free (text);
486         }
487
488       gtk_toggle_button_set_active (dialog->button_range, TRUE);
489       gtk_widget_set_sensitive (dialog->low, TRUE);
490       gtk_widget_set_sensitive (dialog->high, TRUE);
491       gtk_widget_set_sensitive (dialog->discrete, TRUE);
492
493     }
494   else if ( mv_has_value (&dialog->mvl))
495     {
496       const int n = mv_n_values (&dialog->mvl);
497
498       for (i = 0 ; i < 3 ; ++i )
499         {
500           if ( i < n)
501             {
502               gchar *text ;
503
504               text = value_to_text__ (*mv_get_value (&dialog->mvl, i),
505                                       &dialog->format, dialog->encoding);
506               gtk_entry_set_text (GTK_ENTRY (dialog->mv[i]), text);
507               g_free (text);
508             }
509           gtk_widget_set_sensitive (dialog->mv[i], TRUE);
510         }
511       gtk_toggle_button_set_active (dialog->button_discrete, TRUE);
512     }
513   else if ( mv_is_empty (&dialog->mvl))
514     {
515       gtk_toggle_button_set_active (dialog->button_none, TRUE);
516     }
517 }
518
519 const struct missing_values *
520 psppire_missing_val_dialog_get_missing_values (
521   const PsppireMissingValDialog *dialog)
522 {
523   return &dialog->mvl;
524 }