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