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   g_object_set (G_OBJECT (label),
 308                 "valign", GTK_ALIGN_CENTER,
 309                 "halign", GTK_ALIGN_START,
 310                 NULL);
 311
 312
 313   g_signal_connect (vbox, "notify::sensitive", G_CALLBACK (focus_follows_sensitivity), entrylo);
 314
 315   gtk_box_pack_start (GTK_BOX (vbox), entrylo, TRUE, TRUE, 0);
 316   gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, TRUE, 0);
 317   gtk_box_pack_start (GTK_BOX (vbox), entryhi, TRUE, TRUE, 0);
 318   return vbox;
 319 }
 320
 321 static GtkWidget * simple_entry (struct layout *l, struct range_widgets *rw)
 322 {
 323   GtkWidget *entry = gtk_entry_new ();
 324
 325   rw->e1 = GTK_ENTRY (entry);
 326
 327   g_signal_connect (entry, "notify::sensitive", G_CALLBACK (focus_follows_sensitivity), entry);
 328   return entry;
 329 }
 330
 331
 332 static struct layout range_opt[n_VAL_CHOOSER_BUTTONS]=
 333   {
 334     {N_("_Value:"),                    simple_entry, simple_set },
 335     {N_("_System Missing"),            NULL,         sysmis_set },
 336     {N_("System _or User Missing"),    NULL,         missing_set},
 337     {N_("_Range:"),                    range_entry,  range_set  },
 338     {N_("Range, _LOWEST thru value"),  simple_entry, lo_up_set  },
 339     {N_("Range, value thru _HIGHEST"), simple_entry, hi_down_set},
 340     {N_("_All other values"),          NULL,         else_set   }
 341   };
 342
 343 static void
 344 psppire_val_chooser_init (PsppireValChooser *vr)
 345 {
 346   gint i;
 347   GtkWidget *grid = gtk_grid_new ();
 348   GSList *group = NULL;
 349   gint row = 0;
 350
 351   g_object_set (G_OBJECT (grid),
 352                 "margin-start", 5,
 353                 "margin-end", 5,
 354                 NULL);
 355
 356   vr->input_var_is_string = FALSE;
 357
 358   for (i = 0; i < n_VAL_CHOOSER_BUTTONS; ++i)
 359     {
 360       struct layout *l = &range_opt[i];
 361       vr->rw[i].label = GTK_LABEL (gtk_label_new (gettext (l->label)));
 362       gtk_label_set_use_underline (vr->rw[i].label, TRUE);
 363       vr->rw[i].rb = GTK_TOGGLE_BUTTON (gtk_radio_button_new (group));
 364       gtk_label_set_mnemonic_widget (vr->rw[i].label, GTK_WIDGET (vr->rw[i].rb));
 365
 366       g_object_set (G_OBJECT (vr->rw[i].label),
 367                     "valign", GTK_ALIGN_CENTER,
 368                     "halign", GTK_ALIGN_START,
 369                     NULL);
 370
 371       group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (vr->rw[i].rb));
 372
 373       /* Attach the buttons */
 374       gtk_grid_attach (GTK_GRID (grid), GTK_WIDGET (vr->rw[i].rb),
 375                        0, row, 1, 1);
 376
 377       gtk_widget_set_hexpand (GTK_WIDGET (vr->rw[i].rb), FALSE);
 378
 379       /* Attach the labels */
 380       gtk_grid_attach (GTK_GRID (grid), GTK_WIDGET (vr->rw[i].label),
 381                         1, row, 1, 1);
 382
 383       gtk_widget_set_hexpand (GTK_WIDGET (vr->rw[i].label), TRUE);
 384
 385
 386       ++row;
 387
 388       if (l->fill)
 389         {
 390           GtkWidget *fill = l->fill (l, &vr->rw[i]);
 391
 392           gtk_widget_set_sensitive (fill, FALSE);
 393
 394           gtk_grid_attach (GTK_GRID (grid), fill, 1, row, 1, 1);
 395
 396           gtk_widget_set_hexpand (fill, TRUE);
 397
 398           ++row;
 399
 400           g_signal_connect (vr->rw[i].rb, "toggled", G_CALLBACK (set_sensitivity_from_toggle), fill);
 401         }
 402     }
 403
 404   gtk_frame_set_shadow_type (GTK_FRAME (vr), GTK_SHADOW_ETCHED_IN);
 405
 406   gtk_container_add (GTK_CONTAINER (vr), grid);
 407
 408   gtk_widget_show_all (grid);
 409 }
 410
 411
 412 GtkWidget*
 413 psppire_val_chooser_new (void)
 414 {
 415   return GTK_WIDGET (g_object_new (psppire_val_chooser_get_type (), NULL));
 416 }
 417
 418
 419
 420 static void
 421 psppire_val_chooser_realize (GtkWidget *w)
 422 {
 423   PsppireValChooser *vr = PSPPIRE_VAL_CHOOSER (w);
 424
 425   gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(vr->rw[0].rb), TRUE);
 426   gtk_toggle_button_toggled (GTK_TOGGLE_BUTTON (vr->rw[0].rb));
 427
 428   /* Chain up to the parent class */
 429   GTK_WIDGET_CLASS (parent_class)->realize (w);
 430 }
 431
 432
 433 \f
 434
 435 /* A boxed type representing a value, or a range of values which may
 436    potentially be replaced by something */
 437
 438
 439 static struct old_value *
 440 old_value_copy (struct old_value *ov)
 441 {
 442   struct old_value *copy = g_memdup (ov, sizeof (*copy));
 443
 444   if ( ov->type == OV_STRING )
 445     copy->v.s = g_strdup (ov->v.s);
 446
 447   return copy;
 448 }
 449
 450
 451 static void
 452 old_value_free (struct old_value *ov)
 453 {
 454   if (ov->type == OV_STRING)
 455     g_free (ov->v.s);
 456   g_free (ov);
 457 }
 458
 459 static void
 460 old_value_to_string (const GValue *src, GValue *dest)
 461 {
 462   const struct old_value *ov = g_value_get_boxed (src);
 463
 464   switch (ov->type)
 465     {
 466     case OV_NUMERIC:
 467       {
 468         gchar *text = g_strdup_printf ("%.*g", DBL_DIG + 1, ov->v.v);
 469         g_value_set_string (dest, text);
 470         g_free (text);
 471       }
 472       break;
 473     case OV_STRING:
 474       g_value_set_string (dest, ov->v.s);
 475       break;
 476     case OV_MISSING:
 477       g_value_set_string (dest, "MISSING");
 478       break;
 479     case OV_SYSMIS:
 480       g_value_set_string (dest, "SYSMIS");
 481       break;
 482     case OV_ELSE:
 483       g_value_set_string (dest, "ELSE");
 484       break;
 485     case OV_RANGE:
 486       {
 487         gchar *text;
 488         char en_dash[6] = {0,0,0,0,0,0};
 489
 490         g_unichar_to_utf8 (0x2013, en_dash);
 491
 492         text = g_strdup_printf ("%.*g %s %.*g",
 493                                 DBL_DIG + 1, ov->v.range[0],
 494                                 en_dash,
 495                                 DBL_DIG + 1, ov->v.range[1]);
 496         g_value_set_string (dest, text);
 497         g_free (text);
 498       }
 499       break;
 500     case OV_LOW_UP:
 501       {
 502         gchar *text;
 503         char en_dash[6] = {0,0,0,0,0,0};
 504
 505         g_unichar_to_utf8 (0x2013, en_dash);
 506
 507         text = g_strdup_printf ("LOWEST %s %.*g",
 508                                 en_dash,
 509                                 DBL_DIG + 1, ov->v.range[1]);
 510
 511         g_value_set_string (dest, text);
 512         g_free (text);
 513       }
 514       break;
 515     case OV_HIGH_DOWN:
 516       {
 517         gchar *text;
 518         char en_dash[6] = {0,0,0,0,0,0};
 519
 520         g_unichar_to_utf8 (0x2013, en_dash);
 521
 522         text = g_strdup_printf ("%.*g %s HIGHEST",
 523                                 DBL_DIG + 1, ov->v.range[0],
 524                                 en_dash);
 525
 526         g_value_set_string (dest, text);
 527         g_free (text);
 528       }
 529       break;
 530     default:
 531       g_warning ("Invalid type in old recode value");
 532       g_value_set_string (dest, "???");
 533       break;
 534     };
 535 }
 536
 537 GType
 538 old_value_get_type (void)
 539 {
 540   static GType t = 0;
 541
 542   if (t == 0 )
 543     {
 544       t = g_boxed_type_register_static  ("psppire-recode-old-values",
 545                                          (GBoxedCopyFunc) old_value_copy,
 546                                          (GBoxedFreeFunc) old_value_free);
 547
 548       g_value_register_transform_func     (t, G_TYPE_STRING,
 549                                            old_value_to_string);
 550     }
 551
 552   return t;
 553 }
 554
 555 \f
 556
 557 /* Generate a syntax fragment for NV and append it to STR */
 558 void
 559 old_value_append_syntax (struct string *str, const struct old_value *ov)
 560 {
 561   switch (ov->type)
 562     {
 563     case OV_NUMERIC:
 564       ds_put_c_format (str, "%.*g", DBL_DIG + 1, ov->v.v);
 565       break;
 566     case OV_STRING:
 567       {
 568         struct string ds = DS_EMPTY_INITIALIZER;
 569         syntax_gen_string (&ds, ss_cstr (ov->v.s));
 570         ds_put_cstr (str, ds_cstr (&ds));
 571         ds_destroy (&ds);
 572       }
 573       break;
 574     case OV_MISSING:
 575       ds_put_cstr (str, "MISSING");
 576       break;
 577     case OV_SYSMIS:
 578       ds_put_cstr (str, "SYSMIS");
 579       break;
 580     case OV_ELSE:
 581       ds_put_cstr (str, "ELSE");
 582       break;
 583     case OV_RANGE:
 584       ds_put_c_format (str, "%.*g THRU %.*g",
 585                        DBL_DIG + 1, ov->v.range[0],
 586                        DBL_DIG + 1, ov->v.range[1]);
 587       break;
 588     case OV_LOW_UP:
 589       ds_put_c_format (str, "LOWEST THRU %.*g",
 590                        DBL_DIG + 1, ov->v.range[1]);
 591       break;
 592     case OV_HIGH_DOWN:
 593       ds_put_c_format (str, "%.*g THRU HIGHEST",
 594                        DBL_DIG + 1, ov->v.range[0]);
 595       break;
 596     default:
 597       g_warning ("Invalid type in old recode value");
 598       ds_put_cstr (str, "???");
 599       break;
 600     };
 601 }
 602
 603
 604
 605 /* Set OV according to the current state of VR */
 606 void
 607 psppire_val_chooser_get_status (PsppireValChooser *vr, struct old_value *ov)
 608 {
 609   int i;
 610
 611   for (i = 0; i < n_VAL_CHOOSER_BUTTONS; ++i)
 612     {
 613       if ( gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (vr->rw[i].rb)))
 614         {
 615           range_opt[i].set (vr, ov, &vr->rw[i]);
 616           break;
 617         }
 618     }
 619 }
 620
 621 /* This might need to be changed to something less naive.
 622    In particular, what happends with dates, etc?
 623  */
 624 static gchar *
 625 num_to_string (gdouble x)
 626 {
 627   return g_strdup_printf ("%.*g", DBL_DIG + 1, x);
 628 }
 629
 630
 631 /* Set VR according to the value of OV */
 632 void
 633 psppire_val_chooser_set_status (PsppireValChooser *vr, const struct old_value *ov)
 634 {
 635   gint i;
 636   if ( !ov )
 637     return;
 638
 639   for (i = 0; i < n_VAL_CHOOSER_BUTTONS; ++i)
 640     {
 641       if (vr->rw[i].e1)
 642         gtk_entry_set_text (vr->rw[i].e1, "");
 643
 644       if (vr->rw[i].e2)
 645         gtk_entry_set_text (vr->rw[i].e2, "");
 646     }
 647
 648   switch (ov->type)
 649     {
 650     case OV_STRING:
 651       gtk_toggle_button_set_active (vr->rw[0].rb, TRUE);
 652       gtk_entry_set_text (vr->rw[0].e1, ov->v.s);
 653       break;
 654
 655     case OV_NUMERIC:
 656       {
 657         gchar *str;
 658         gtk_toggle_button_set_active (vr->rw[0].rb, TRUE);
 659
 660         str = num_to_string (ov->v.v);
 661
 662         gtk_entry_set_text (vr->rw[0].e1, str);
 663         g_free (str);
 664       }
 665       break;
 666
 667       case OV_SYSMIS:
 668         gtk_toggle_button_set_active (vr->rw[VC_SYSMIS].rb, TRUE);
 669         break;
 670
 671       case OV_MISSING:
 672         gtk_toggle_button_set_active (vr->rw[VC_MISSING].rb, TRUE);
 673         break;
 674
 675       case OV_RANGE:
 676         {
 677           gchar *str = num_to_string (ov->v.range[0]);
 678           gtk_toggle_button_set_active (vr->rw[VC_RANGE].rb, TRUE);
 679           gtk_entry_set_text (vr->rw[VC_RANGE].e1, str);
 680
 681           g_free (str);
 682
 683           str = num_to_string (ov->v.range[1]);
 684           gtk_entry_set_text (vr->rw[VC_RANGE].e2, str);
 685           g_free (str);
 686         }
 687         break;
 688
 689       case OV_LOW_UP:
 690         {
 691           gchar *str = num_to_string (ov->v.range[1]);
 692
 693           gtk_toggle_button_set_active (vr->rw[VC_LOW_UP].rb, TRUE);
 694
 695           gtk_entry_set_text (vr->rw[VC_LOW_UP].e1, str);
 696
 697           g_free (str);
 698         }
 699         break;
 700
 701
 702       case OV_HIGH_DOWN:
 703         {
 704           gchar *str = num_to_string (ov->v.range[0]);
 705
 706           gtk_toggle_button_set_active (vr->rw[VC_HIGH_DOWN].rb, TRUE);
 707
 708           gtk_entry_set_text (vr->rw[VC_HIGH_DOWN].e1, str);
 709
 710           g_free (str);
 711         }
 712         break;
 713
 714       case OV_ELSE:
 715         gtk_toggle_button_set_active (vr->rw[VC_ELSE].rb, TRUE);
 716         break;
 717
 718     default:
 719       g_warning ("Unknown old value type");
 720       break;
 721     };
 722 }