src/ui/gui/missing-val-dialog.c

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