Remove recoding in data_store.
[pspp] / src / ui / gui / missing-val-dialog.c
1 /* PSPPIRE - a graphical user interface for PSPP.
2    Copyright (C) 2005, 2006, 2009  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 #include <gettext.h>
22 #define _(msgid) gettext (msgid)
23 #define N_(msgid) msgid
24
25
26 #include "helper.h"
27 #include <data/format.h>
28 #include "missing-val-dialog.h"
29 #include <data/missing-values.h>
30 #include <data/variable.h>
31 #include <data/data-in.h>
32
33
34 #include <gtk/gtk.h>
35
36 #include <string.h>
37
38
39 /* A simple (sub) dialog box for displaying user input errors */
40 static void
41 err_dialog (const gchar *msg, GtkWindow *window)
42 {
43   GtkWidget *hbox ;
44   GtkWidget *label = gtk_label_new (msg);
45
46   GtkWidget *dialog =
47     gtk_dialog_new_with_buttons ("PSPP",
48                                  window,
49                                  GTK_DIALOG_MODAL |
50                                  GTK_DIALOG_DESTROY_WITH_PARENT |
51                                  GTK_DIALOG_NO_SEPARATOR,
52                                  GTK_STOCK_OK,
53                                  GTK_RESPONSE_ACCEPT,
54                                  NULL);
55
56
57   GtkWidget *icon = gtk_image_new_from_stock (GTK_STOCK_DIALOG_ERROR,
58                                              GTK_ICON_SIZE_DIALOG);
59
60   g_signal_connect_swapped (dialog,
61                             "response",
62                             G_CALLBACK (gtk_widget_destroy),
63                             dialog);
64
65   hbox = gtk_hbox_new (FALSE, 10);
66
67   gtk_container_add (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox),
68                      hbox);
69
70   gtk_box_pack_start (GTK_BOX (hbox), icon, TRUE, FALSE, 10);
71   gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, TRUE, 10);
72
73   gtk_widget_show_all (dialog);
74 }
75
76
77 /* Callback which occurs when the OK button is clicked */
78 static void
79 missing_val_dialog_accept (GtkWidget *w, gpointer data)
80 {
81   struct missing_val_dialog *dialog = data;
82
83   const struct fmt_spec *write_spec = var_get_write_format (dialog->pv);
84
85   if ( gtk_toggle_button_get_active (dialog->button_discrete))
86     {
87       gint nvals = 0;
88       gint badvals = 0;
89       gint i;
90       mv_clear(&dialog->mvl);
91       for(i = 0 ; i < 3 ; ++i )
92         {
93           gchar *text =
94             g_strdup (gtk_entry_get_text (GTK_ENTRY (dialog->mv[i])));
95
96           union value v;
97           if ( !text || strlen (g_strstrip (text)) == 0 )
98             {
99               g_free (text);
100               continue;
101             }
102
103           if ( text_to_value (text, &v, *write_spec))
104             {
105               nvals++;
106               mv_add_value (&dialog->mvl, &v);
107             }
108           else
109               badvals++;
110           g_free (text);
111         }
112       if ( nvals == 0 || badvals > 0 )
113         {
114           err_dialog (_("Incorrect value for variable type"),
115                      GTK_WINDOW (dialog->window));
116           return ;
117         }
118     }
119
120   if (gtk_toggle_button_get_active (dialog->button_range))
121     {
122       gchar *discrete_text ;
123
124       union value low_val ;
125       union value high_val;
126       const gchar *low_text = gtk_entry_get_text (GTK_ENTRY (dialog->low));
127       const gchar *high_text = gtk_entry_get_text (GTK_ENTRY (dialog->high));
128
129       if ( text_to_value (low_text, &low_val, *write_spec)
130            &&
131            text_to_value (high_text, &high_val, *write_spec) )
132         {
133           if ( low_val.f > high_val.f )
134             {
135               err_dialog (_("Incorrect range specification"),
136                           GTK_WINDOW (dialog->window));
137               return ;
138             }
139         }
140       else
141         {
142           err_dialog (_("Incorrect range specification"),
143                       GTK_WINDOW (dialog->window));
144           return;
145         }
146
147       discrete_text =
148         g_strdup (gtk_entry_get_text (GTK_ENTRY (dialog->discrete)));
149
150       mv_clear (&dialog->mvl);
151       mv_add_range (&dialog->mvl, low_val.f, high_val.f);
152
153       if ( discrete_text && strlen (g_strstrip (discrete_text)) > 0 )
154         {
155           union value discrete_val;
156           if ( !text_to_value (discrete_text, &discrete_val,
157                               *write_spec))
158             {
159               err_dialog (_("Incorrect value for variable type"),
160                          GTK_WINDOW (dialog->window) );
161               g_free (discrete_text);
162               return;
163             }
164           mv_add_value (&dialog->mvl, &discrete_val);
165         }
166       g_free (discrete_text);
167     }
168
169
170   if (gtk_toggle_button_get_active (dialog->button_none))
171     mv_clear (&dialog->mvl);
172
173   var_set_missing_values (dialog->pv, &dialog->mvl);
174
175   gtk_widget_hide (dialog->window);
176 }
177
178
179 /* Callback which occurs when the 'discrete' radiobutton is toggled */
180 static void
181 discrete (GtkToggleButton *button, gpointer data)
182 {
183   gint i;
184   struct missing_val_dialog *dialog = data;
185
186   for (i = 0 ; i < 3 ; ++i )
187     {
188       gtk_widget_set_sensitive (dialog->mv[i],
189                                gtk_toggle_button_get_active (button));
190     }
191 }
192
193 /* Callback which occurs when the 'range' radiobutton is toggled */
194 static void
195 range (GtkToggleButton *button, gpointer data)
196 {
197   struct missing_val_dialog *dialog = data;
198
199   const gboolean active = gtk_toggle_button_get_active (button);
200
201   gtk_widget_set_sensitive (dialog->low, active);
202   gtk_widget_set_sensitive (dialog->high, active);
203   gtk_widget_set_sensitive (dialog->discrete, active);
204 }
205
206
207
208 /* Callback for when the Missing Value dialog is closed using
209    the window delete button.*/
210 static gint
211 on_delete (GtkWidget *w, GdkEvent *e, gpointer data)
212 {
213   struct missing_val_dialog *dialog = data;
214
215   gtk_widget_hide (dialog->window);
216
217   return TRUE;
218 }
219
220
221 /* Creates the dialog structure */
222 struct missing_val_dialog *
223 missing_val_dialog_create (GtkWindow *toplevel)
224 {
225   GtkBuilder *xml = builder_new ("var-sheet-dialogs.ui");
226
227   struct missing_val_dialog *dialog = g_malloc (sizeof (*dialog));
228
229   dialog->window = get_widget_assert (xml, "missing_values_dialog");
230
231   gtk_window_set_transient_for
232     (GTK_WINDOW (dialog->window), toplevel);
233
234   g_signal_connect_swapped (get_widget_assert (xml, "missing_val_cancel"),
235                    "clicked", G_CALLBACK (gtk_widget_hide), dialog->window);
236
237   g_signal_connect (get_widget_assert (xml, "missing_val_ok"),
238                    "clicked", G_CALLBACK (missing_val_dialog_accept), dialog);
239
240   g_signal_connect (dialog->window, "delete-event",
241                     G_CALLBACK (on_delete), dialog);
242
243   dialog->mv[0] = get_widget_assert (xml, "mv0");
244   dialog->mv[1] = get_widget_assert (xml, "mv1");
245   dialog->mv[2] = get_widget_assert (xml, "mv2");
246
247   dialog->low = get_widget_assert (xml, "mv-low");
248   dialog->high = get_widget_assert (xml, "mv-high");
249   dialog->discrete = get_widget_assert (xml, "mv-discrete");
250
251
252   dialog->button_none     =
253     GTK_TOGGLE_BUTTON (get_widget_assert (xml, "no_missing"));
254
255   dialog->button_discrete =
256     GTK_TOGGLE_BUTTON (get_widget_assert (xml, "discrete_missing"));
257
258   dialog->button_range    =
259     GTK_TOGGLE_BUTTON (get_widget_assert (xml, "range_missing"));
260
261
262   g_signal_connect (dialog->button_discrete, "toggled",
263                    G_CALLBACK (discrete), dialog);
264
265   g_signal_connect (dialog->button_range, "toggled",
266                    G_CALLBACK (range), dialog);
267
268   g_object_unref (xml);
269
270   return dialog;
271 }
272
273 /* Shows the dialog box and sets default values */
274 void
275 missing_val_dialog_show (struct missing_val_dialog *dialog)
276 {
277   const struct fmt_spec *write_spec ;
278
279   gint i;
280   g_return_if_fail (dialog);
281   g_return_if_fail (dialog->pv);
282
283   mv_copy (&dialog->mvl, var_get_missing_values (dialog->pv));
284
285   write_spec = var_get_write_format (dialog->pv);
286
287   /* Blank all entry boxes and make them insensitive */
288   gtk_entry_set_text (GTK_ENTRY (dialog->low), "");
289   gtk_entry_set_text (GTK_ENTRY (dialog->high), "");
290   gtk_entry_set_text (GTK_ENTRY (dialog->discrete), "");
291   gtk_widget_set_sensitive (dialog->low, FALSE);
292   gtk_widget_set_sensitive (dialog->high, FALSE);
293   gtk_widget_set_sensitive (dialog->discrete, FALSE);
294
295   gtk_widget_set_sensitive (GTK_WIDGET (dialog->button_range),
296                            var_is_numeric (dialog->pv));
297
298
299   for (i = 0 ; i < 3 ; ++i )
300     {
301       gtk_entry_set_text (GTK_ENTRY (dialog->mv[i]), "");
302       gtk_widget_set_sensitive (dialog->mv[i], FALSE);
303     }
304
305   if ( mv_has_range (&dialog->mvl))
306     {
307       union value low, high;
308       gchar *low_text;
309       gchar *high_text;
310       mv_get_range (&dialog->mvl, &low.f, &high.f);
311
312
313       low_text = value_to_text (low, dialog->dict, *write_spec);
314       high_text = value_to_text (high, dialog->dict,  *write_spec);
315
316       gtk_entry_set_text (GTK_ENTRY (dialog->low), low_text);
317       gtk_entry_set_text (GTK_ENTRY (dialog->high), high_text);
318       g_free (low_text);
319       g_free (high_text);
320
321       if ( mv_has_value (&dialog->mvl))
322         {
323           gchar *text;
324           text = value_to_text (*mv_get_value (&dialog->mvl, 0), dialog->dict, *write_spec);
325           gtk_entry_set_text (GTK_ENTRY (dialog->discrete), text);
326           g_free (text);
327         }
328
329       gtk_toggle_button_set_active (dialog->button_range, TRUE);
330       gtk_widget_set_sensitive (dialog->low, TRUE);
331       gtk_widget_set_sensitive (dialog->high, TRUE);
332       gtk_widget_set_sensitive (dialog->discrete, TRUE);
333
334     }
335   else if ( mv_has_value (&dialog->mvl))
336     {
337       const int n = mv_n_values (&dialog->mvl);
338
339       for (i = 0 ; i < 3 ; ++i )
340         {
341           if ( i < n)
342             {
343               gchar *text ;
344
345               text = value_to_text (*mv_get_value (&dialog->mvl, i), dialog->dict,
346                                     *write_spec);
347               gtk_entry_set_text (GTK_ENTRY (dialog->mv[i]), text);
348               g_free (text);
349             }
350           gtk_widget_set_sensitive (dialog->mv[i], TRUE);
351         }
352       gtk_toggle_button_set_active (dialog->button_discrete, TRUE);
353     }
354   else if ( mv_is_empty (&dialog->mvl))
355     {
356       gtk_toggle_button_set_active (dialog->button_none, TRUE);
357     }
358
359   gtk_widget_show (dialog->window);
360 }