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