pintos-os.org Git - pspp/blob - src/ui/gui/psppire-val-chooser.c

   1 /* PSPPIRE - a graphical user interface for PSPP.
   2    Copyright (C) 2011, 2014, 2022  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 #include <config.h>
  18
  19 #include <float.h>
  20 #include <gtk/gtk.h>
  21 #include "dialog-common.h"
  22 #include "psppire-val-chooser.h"
  23
  24 #include "libpspp/str.h"
  25 #include "ui/gui/glibfix.h"
  26
  27 #include "ui/syntax-gen.h"
  28
  29 #include <gettext.h>
  30 #define _(msgid) gettext (msgid)
  31 #define N_(msgid) msgid
  32
  33 static void psppire_val_chooser_class_init    (PsppireValChooserClass *class);
  34 static void psppire_val_chooser_init          (PsppireValChooser      *vc);
  35
  36 static void psppire_val_chooser_realize       (GtkWidget *w);
  37
  38 G_DEFINE_TYPE (PsppireValChooser, psppire_val_chooser, GTK_TYPE_FRAME)
  39
  40 static void
  41 psppire_val_chooser_finalize (GObject *object)
  42 {
  43
  44 }
  45
  46 /* Properties */
  47 enum
  48 {
  49   PROP_0,
  50   PROP_IS_STRING,
  51   PROP_SHOW_ELSE
  52 };
  53
  54
  55 enum
  56   {
  57     VC_VALUE,
  58     VC_SYSMIS,
  59     VC_MISSING,
  60     VC_RANGE,
  61     VC_LOW_UP,
  62     VC_HIGH_DOWN,
  63     VC_ELSE
  64   };
  65
  66 static void
  67 psppire_val_chooser_set_property (GObject         *object,
  68                                guint            prop_id,
  69                                const GValue    *value,
  70                                GParamSpec      *pspec)
  71 {
  72   PsppireValChooser *vr = PSPPIRE_VAL_CHOOSER (object);
  73
  74   switch (prop_id)
  75     {
  76     case PROP_SHOW_ELSE:
  77       {
  78         gboolean x = g_value_get_boolean (value);
  79         gtk_widget_set_visible (GTK_WIDGET (vr->rw[VC_ELSE].rb), x);
  80         gtk_widget_set_visible (GTK_WIDGET (vr->rw[VC_ELSE].label), x);
  81       }
  82       break;
  83     case PROP_IS_STRING:
  84       vr->input_var_is_string = g_value_get_boolean (value);
  85       gtk_widget_set_sensitive (GTK_WIDGET (vr->rw[VC_SYSMIS].rb), !vr->input_var_is_string);
  86       gtk_widget_set_sensitive (GTK_WIDGET (vr->rw[VC_MISSING].rb), !vr->input_var_is_string);
  87       gtk_widget_set_sensitive (GTK_WIDGET (vr->rw[VC_RANGE].rb), !vr->input_var_is_string);
  88       gtk_widget_set_sensitive (GTK_WIDGET (vr->rw[VC_LOW_UP].rb), !vr->input_var_is_string);
  89       gtk_widget_set_sensitive (GTK_WIDGET (vr->rw[VC_HIGH_DOWN].rb), !vr->input_var_is_string);
  90       break;
  91     default:
  92       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
  93       break;
  94     };
  95 }
  96
  97
  98 static void
  99 psppire_val_chooser_get_property (GObject         *object,
 100                                guint            prop_id,
 101                                GValue          *value,
 102                                GParamSpec      *pspec)
 103 {
 104   PsppireValChooser *vr = PSPPIRE_VAL_CHOOSER (object);
 105
 106   switch (prop_id)
 107     {
 108     case PROP_SHOW_ELSE:
 109       {
 110         gboolean x =
 111           gtk_widget_get_visible (GTK_WIDGET (vr->rw[VC_ELSE].rb));
 112         g_value_set_boolean (value, x);
 113       }
 114       break;
 115     case PROP_IS_STRING:
 116       g_value_set_boolean (value, vr->input_var_is_string);
 117       break;
 118     default:
 119       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 120       break;
 121     };
 122 }
 123
 124
 125 static GObjectClass * parent_class = NULL;
 126
 127 static void
 128 psppire_val_chooser_class_init (PsppireValChooserClass *class)
 129 {
 130   GObjectClass *object_class = G_OBJECT_CLASS (class);
 131
 132   object_class->finalize = psppire_val_chooser_finalize;
 133   GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (class);
 134
 135   GParamSpec *is_string_spec =
 136     g_param_spec_boolean ("is-string",
 137                           "String Value",
 138                           "Should the value range be a string value",
 139                           FALSE,
 140                           G_PARAM_READWRITE);
 141
 142   GParamSpec *show_else_spec =
 143     g_param_spec_boolean ("show-else",
 144                           "Show Else",
 145                           "Should the \"All other values\" item be visible",
 146                           TRUE,
 147                           G_PARAM_READWRITE);
 148
 149
 150   parent_class = g_type_class_peek_parent (class);
 151
 152   object_class->set_property = psppire_val_chooser_set_property;
 153   object_class->get_property = psppire_val_chooser_get_property;
 154
 155   widget_class->realize = psppire_val_chooser_realize;
 156
 157   g_object_class_install_property (object_class,
 158                                    PROP_IS_STRING,
 159                                    is_string_spec);
 160
 161   g_object_class_install_property (object_class,
 162                                    PROP_SHOW_ELSE,
 163                                    show_else_spec);
 164 }
 165
 166
 167 /* Set the focus of B to follow the sensitivity of A */
 168 static void
 169 focus_follows_sensitivity (GtkWidget *a, GParamSpec *pspec, GtkWidget *b)
 170 {
 171   gboolean sens = gtk_widget_get_sensitive (a);
 172
 173   g_object_set (b, "has-focus", sens, NULL);
 174 }
 175
 176
 177 struct layout;
 178 typedef GtkWidget *filler_f (struct layout *, struct range_widgets *);
 179 typedef void set_f (PsppireValChooser *, struct old_value *, const struct range_widgets *);
 180
 181 struct layout
 182 {
 183   const gchar *label;
 184   filler_f *fill;
 185   set_f *set;
 186 };
 187
 188
 189
 190 static void simple_set (PsppireValChooser *vr, struct old_value *ov, const struct range_widgets *rw)
 191 {
 192   const gchar *text = gtk_entry_get_text (rw->e1);
 193
 194   if (vr->input_var_is_string)
 195     {
 196       ov->type = OV_STRING;
 197       ov->v.s = g_strdup (text);
 198     }
 199   else
 200     {
 201       ov->type = OV_NUMERIC;
 202       ov->v.v = g_strtod (text, 0);
 203     }
 204 }
 205
 206 static void lo_up_set (PsppireValChooser *vr, struct old_value *ov, const struct range_widgets  *rw)
 207 {
 208   const gchar *text = gtk_entry_get_text (rw->e1);
 209
 210   ov->type = OV_LOW_UP;
 211   ov->v.range[1] = g_strtod (text, 0);
 212 }
 213
 214
 215 static void hi_down_set (PsppireValChooser *vr, struct old_value *ov, const struct range_widgets *rw)
 216 {
 217   const gchar *text = gtk_entry_get_text (rw->e1);
 218
 219   ov->type = OV_HIGH_DOWN;
 220   ov->v.range[0] = g_strtod (text, 0);
 221 }
 222
 223 static void missing_set (PsppireValChooser *vr, struct old_value *ov, const struct range_widgets *l)
 224 {
 225   ov->type = OV_MISSING;
 226 }
 227
 228
 229 static void sysmis_set (PsppireValChooser *vr, struct old_value *ov, const struct range_widgets *l)
 230 {
 231   ov->type = OV_SYSMIS;
 232 }
 233
 234 static void else_set (PsppireValChooser *vr, struct old_value *ov, const struct range_widgets *l)
 235 {
 236   ov->type = OV_ELSE;
 237 }
 238
 239
 240 static void range_set (PsppireValChooser *vr, struct old_value *ov, const struct range_widgets *rw)
 241 {
 242   const gchar *text = gtk_entry_get_text (rw->e1);
 243
 244   ov->type = OV_RANGE;
 245   ov->v.range[0] = g_strtod (text, 0);
 246
 247   text = gtk_entry_get_text (rw->e2);
 248   ov->v.range[1] = g_strtod (text, 0);
 249 }
 250
 251 static GtkWidget * range_entry (struct layout *l, struct range_widgets *rw)
 252 {
 253   GtkWidget *vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 3);
 254   GtkWidget *entrylo = gtk_entry_new ();
 255   GtkWidget *label = gtk_label_new (_("through"));
 256   GtkWidget *entryhi = gtk_entry_new ();
 257
 258   rw->e1 = GTK_ENTRY (entrylo);
 259   rw->e2 = GTK_ENTRY (entryhi);
 260
 261   g_object_set (G_OBJECT (label),
 262                 "valign", GTK_ALIGN_CENTER,
 263                 "halign", GTK_ALIGN_START,
 264                 NULL);
 265
 266
 267   g_signal_connect (vbox, "notify::sensitive", G_CALLBACK (focus_follows_sensitivity), entrylo);
 268
 269   gtk_box_pack_start (GTK_BOX (vbox), entrylo, TRUE, TRUE, 0);
 270   gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, TRUE, 0);
 271   gtk_box_pack_start (GTK_BOX (vbox), entryhi, TRUE, TRUE, 0);
 272   return vbox;
 273 }
 274
 275 static GtkWidget * simple_entry (struct layout *l, struct range_widgets *rw)
 276 {
 277   GtkWidget *entry = gtk_entry_new ();
 278
 279   rw->e1 = GTK_ENTRY (entry);
 280
 281   g_signal_connect (entry, "notify::sensitive", G_CALLBACK (focus_follows_sensitivity), entry);
 282   return entry;
 283 }
 284
 285
 286 static struct layout range_opt[n_VAL_CHOOSER_BUTTONS]=
 287   {
 288     {N_("_Value:"),                    simple_entry, simple_set },
 289     {N_("_System Missing"),            NULL,         sysmis_set },
 290     {N_("System _or User Missing"),    NULL,         missing_set},
 291     {N_("_Range:"),                    range_entry,  range_set  },
 292     {N_("Range, _LOWEST thru value"),  simple_entry, lo_up_set  },
 293     {N_("Range, value thru _HIGHEST"), simple_entry, hi_down_set},
 294     {N_("_All other values"),          NULL,         else_set   }
 295   };
 296
 297 static void
 298 psppire_val_chooser_init (PsppireValChooser *vr)
 299 {
 300   gint i;
 301   GtkWidget *grid = gtk_grid_new ();
 302   GSList *group = NULL;
 303   gint row = 0;
 304
 305   g_object_set (G_OBJECT (grid),
 306                 "margin-start", 5,
 307                 "margin-end", 5,
 308                 NULL);
 309
 310   vr->input_var_is_string = FALSE;
 311
 312   for (i = 0; i < n_VAL_CHOOSER_BUTTONS; ++i)
 313     {
 314       struct layout *l = &range_opt[i];
 315       vr->rw[i].label = GTK_LABEL (gtk_label_new (gettext (l->label)));
 316       gtk_label_set_use_underline (vr->rw[i].label, TRUE);
 317       vr->rw[i].rb = GTK_TOGGLE_BUTTON (gtk_radio_button_new (group));
 318       gtk_label_set_mnemonic_widget (vr->rw[i].label, GTK_WIDGET (vr->rw[i].rb));
 319
 320       g_object_set (G_OBJECT (vr->rw[i].label),
 321                     "valign", GTK_ALIGN_CENTER,
 322                     "halign", GTK_ALIGN_START,
 323                     NULL);
 324
 325       group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (vr->rw[i].rb));
 326
 327       /* Attach the buttons */
 328       gtk_grid_attach (GTK_GRID (grid), GTK_WIDGET (vr->rw[i].rb),
 329                        0, row, 1, 1);
 330
 331       gtk_widget_set_hexpand (GTK_WIDGET (vr->rw[i].rb), FALSE);
 332
 333       /* Attach the labels */
 334       gtk_grid_attach (GTK_GRID (grid), GTK_WIDGET (vr->rw[i].label),
 335                         1, row, 1, 1);
 336
 337       gtk_widget_set_hexpand (GTK_WIDGET (vr->rw[i].label), TRUE);
 338
 339
 340       ++row;
 341
 342       if (l->fill)
 343         {
 344           GtkWidget *fill = l->fill (l, &vr->rw[i]);
 345
 346           gtk_widget_set_sensitive (fill, FALSE);
 347
 348           gtk_grid_attach (GTK_GRID (grid), fill, 1, row, 1, 1);
 349
 350           gtk_widget_set_hexpand (fill, TRUE);
 351
 352           ++row;
 353
 354           g_signal_connect (vr->rw[i].rb, "toggled", G_CALLBACK (set_sensitivity_from_toggle), fill);
 355         }
 356     }
 357
 358   gtk_frame_set_shadow_type (GTK_FRAME (vr), GTK_SHADOW_ETCHED_IN);
 359
 360   gtk_container_add (GTK_CONTAINER (vr), grid);
 361
 362   gtk_widget_show_all (grid);
 363 }
 364
 365 static void
 366 psppire_val_chooser_realize (GtkWidget *w)
 367 {
 368   PsppireValChooser *vr = PSPPIRE_VAL_CHOOSER (w);
 369
 370   gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(vr->rw[0].rb), TRUE);
 371   gtk_toggle_button_toggled (GTK_TOGGLE_BUTTON (vr->rw[0].rb));
 372
 373   /* Chain up to the parent class */
 374   GTK_WIDGET_CLASS (parent_class)->realize (w);
 375 }
 376
 377
 378 \f
 379
 380 /* A boxed type representing a value, or a range of values which may
 381    potentially be replaced by something */
 382
 383
 384 static struct old_value *
 385 old_value_copy (struct old_value *ov)
 386 {
 387   struct old_value *copy = g_memdup2 (ov, sizeof (*copy));
 388
 389   if (ov->type == OV_STRING)
 390     copy->v.s = g_strdup (ov->v.s);
 391
 392   return copy;
 393 }
 394
 395
 396 static void
 397 old_value_free (struct old_value *ov)
 398 {
 399   if (ov->type == OV_STRING)
 400     g_free (ov->v.s);
 401   g_free (ov);
 402 }
 403
 404 static void
 405 old_value_to_string (const GValue *src, GValue *dest)
 406 {
 407   const struct old_value *ov = g_value_get_boxed (src);
 408
 409   switch (ov->type)
 410     {
 411     case OV_NUMERIC:
 412       {
 413         gchar *text = g_strdup_printf ("%.*g", DBL_DIG + 1, ov->v.v);
 414         g_value_set_string (dest, text);
 415         g_free (text);
 416       }
 417       break;
 418     case OV_STRING:
 419       g_value_set_string (dest, ov->v.s);
 420       break;
 421     case OV_MISSING:
 422       g_value_set_string (dest, "MISSING");
 423       break;
 424     case OV_SYSMIS:
 425       g_value_set_string (dest, "SYSMIS");
 426       break;
 427     case OV_ELSE:
 428       g_value_set_string (dest, "ELSE");
 429       break;
 430     case OV_RANGE:
 431       {
 432         gchar *text;
 433         char en_dash[6] = {0,0,0,0,0,0};
 434
 435         g_unichar_to_utf8 (0x2013, en_dash);
 436
 437         text = g_strdup_printf ("%.*g %s %.*g",
 438                                 DBL_DIG + 1, ov->v.range[0],
 439                                 en_dash,
 440                                 DBL_DIG + 1, ov->v.range[1]);
 441         g_value_set_string (dest, text);
 442         g_free (text);
 443       }
 444       break;
 445     case OV_LOW_UP:
 446       {
 447         gchar *text;
 448         char en_dash[6] = {0,0,0,0,0,0};
 449
 450         g_unichar_to_utf8 (0x2013, en_dash);
 451
 452         text = g_strdup_printf ("LOWEST %s %.*g",
 453                                 en_dash,
 454                                 DBL_DIG + 1, ov->v.range[1]);
 455
 456         g_value_set_string (dest, text);
 457         g_free (text);
 458       }
 459       break;
 460     case OV_HIGH_DOWN:
 461       {
 462         gchar *text;
 463         char en_dash[6] = {0,0,0,0,0,0};
 464
 465         g_unichar_to_utf8 (0x2013, en_dash);
 466
 467         text = g_strdup_printf ("%.*g %s HIGHEST",
 468                                 DBL_DIG + 1, ov->v.range[0],
 469                                 en_dash);
 470
 471         g_value_set_string (dest, text);
 472         g_free (text);
 473       }
 474       break;
 475     default:
 476       g_warning ("Invalid type in old recode value");
 477       g_value_set_string (dest, "???");
 478       break;
 479     };
 480 }
 481
 482 GType
 483 old_value_get_type (void)
 484 {
 485   static GType t = 0;
 486
 487   if (t == 0)
 488     {
 489       t = g_boxed_type_register_static  ("psppire-recode-old-values",
 490                                          (GBoxedCopyFunc) old_value_copy,
 491                                          (GBoxedFreeFunc) old_value_free);
 492
 493       g_value_register_transform_func     (t, G_TYPE_STRING,
 494                                            old_value_to_string);
 495     }
 496
 497   return t;
 498 }
 499
 500 \f
 501
 502 /* Generate a syntax fragment for NV and append it to STR */
 503 void
 504 old_value_append_syntax (struct string *str, const struct old_value *ov)
 505 {
 506   switch (ov->type)
 507     {
 508     case OV_NUMERIC:
 509       ds_put_c_format (str, "%.*g", DBL_DIG + 1, ov->v.v);
 510       break;
 511     case OV_STRING:
 512       {
 513         struct string ds = DS_EMPTY_INITIALIZER;
 514         syntax_gen_string (&ds, ss_cstr (ov->v.s));
 515         ds_put_cstr (str, ds_cstr (&ds));
 516         ds_destroy (&ds);
 517       }
 518       break;
 519     case OV_MISSING:
 520       ds_put_cstr (str, "MISSING");
 521       break;
 522     case OV_SYSMIS:
 523       ds_put_cstr (str, "SYSMIS");
 524       break;
 525     case OV_ELSE:
 526       ds_put_cstr (str, "ELSE");
 527       break;
 528     case OV_RANGE:
 529       ds_put_c_format (str, "%.*g THRU %.*g",
 530                        DBL_DIG + 1, ov->v.range[0],
 531                        DBL_DIG + 1, ov->v.range[1]);
 532       break;
 533     case OV_LOW_UP:
 534       ds_put_c_format (str, "LOWEST THRU %.*g",
 535                        DBL_DIG + 1, ov->v.range[1]);
 536       break;
 537     case OV_HIGH_DOWN:
 538       ds_put_c_format (str, "%.*g THRU HIGHEST",
 539                        DBL_DIG + 1, ov->v.range[0]);
 540       break;
 541     default:
 542       g_warning ("Invalid type in old recode value");
 543       ds_put_cstr (str, "???");
 544       break;
 545     };
 546 }
 547
 548
 549
 550 /* Set OV according to the current state of VR */
 551 void
 552 psppire_val_chooser_get_status (PsppireValChooser *vr, struct old_value *ov)
 553 {
 554   int i;
 555
 556   for (i = 0; i < n_VAL_CHOOSER_BUTTONS; ++i)
 557     {
 558       if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (vr->rw[i].rb)))
 559         {
 560           range_opt[i].set (vr, ov, &vr->rw[i]);
 561           break;
 562         }
 563     }
 564 }
 565
 566 /* This might need to be changed to something less naive.
 567    In particular, what happends with dates, etc?
 568  */
 569 static gchar *
 570 num_to_string (gdouble x)
 571 {
 572   return g_strdup_printf ("%.*g", DBL_DIG + 1, x);
 573 }
 574
 575
 576 /* Set VR according to the value of OV */
 577 void
 578 psppire_val_chooser_set_status (PsppireValChooser *vr, const struct old_value *ov)
 579 {
 580   gint i;
 581   if (!ov)
 582     return;
 583
 584   for (i = 0; i < n_VAL_CHOOSER_BUTTONS; ++i)
 585     {
 586       if (vr->rw[i].e1)
 587         gtk_entry_set_text (vr->rw[i].e1, "");
 588
 589       if (vr->rw[i].e2)
 590         gtk_entry_set_text (vr->rw[i].e2, "");
 591     }
 592
 593   switch (ov->type)
 594     {
 595     case OV_STRING:
 596       gtk_toggle_button_set_active (vr->rw[0].rb, TRUE);
 597       gtk_entry_set_text (vr->rw[0].e1, ov->v.s);
 598       break;
 599
 600     case OV_NUMERIC:
 601       {
 602         gchar *str;
 603         gtk_toggle_button_set_active (vr->rw[0].rb, TRUE);
 604
 605         str = num_to_string (ov->v.v);
 606
 607         gtk_entry_set_text (vr->rw[0].e1, str);
 608         g_free (str);
 609       }
 610       break;
 611
 612       case OV_SYSMIS:
 613         gtk_toggle_button_set_active (vr->rw[VC_SYSMIS].rb, TRUE);
 614         break;
 615
 616       case OV_MISSING:
 617         gtk_toggle_button_set_active (vr->rw[VC_MISSING].rb, TRUE);
 618         break;
 619
 620       case OV_RANGE:
 621         {
 622           gchar *str = num_to_string (ov->v.range[0]);
 623           gtk_toggle_button_set_active (vr->rw[VC_RANGE].rb, TRUE);
 624           gtk_entry_set_text (vr->rw[VC_RANGE].e1, str);
 625
 626           g_free (str);
 627
 628           str = num_to_string (ov->v.range[1]);
 629           gtk_entry_set_text (vr->rw[VC_RANGE].e2, str);
 630           g_free (str);
 631         }
 632         break;
 633
 634       case OV_LOW_UP:
 635         {
 636           gchar *str = num_to_string (ov->v.range[1]);
 637
 638           gtk_toggle_button_set_active (vr->rw[VC_LOW_UP].rb, TRUE);
 639
 640           gtk_entry_set_text (vr->rw[VC_LOW_UP].e1, str);
 641
 642           g_free (str);
 643         }
 644         break;
 645
 646
 647       case OV_HIGH_DOWN:
 648         {
 649           gchar *str = num_to_string (ov->v.range[0]);
 650
 651           gtk_toggle_button_set_active (vr->rw[VC_HIGH_DOWN].rb, TRUE);
 652
 653           gtk_entry_set_text (vr->rw[VC_HIGH_DOWN].e1, str);
 654
 655           g_free (str);
 656         }
 657         break;
 658
 659       case OV_ELSE:
 660         gtk_toggle_button_set_active (vr->rw[VC_ELSE].rb, TRUE);
 661         break;
 662
 663     default:
 664       g_warning ("Unknown old value type");
 665       break;
 666     };
 667 }