src/ui/gui/recode-dialog.c

   1 /* PSPPIRE - a graphical user interface for PSPP.
   2    Copyright (C) 2007, 2009, 2010, 2011  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 implements the RECODE dialog.
  18
  19    It has two forms.  One for recoding values into the same variable.
  20    The second for recoding into different variables.
  21 */
  22
  23 #include <config.h>
  24
  25 #include "recode-dialog.h"
  26
  27 #include "executor.h"
  28
  29 #include "psppire-var-view.h"
  30
  31 #include <gtk/gtk.h>
  32
  33 #include <xalloc.h>
  34 #include <ui/gui/psppire-data-window.h>
  35 #include <ui/gui/dialog-common.h>
  36 #include <ui/gui/dict-display.h>
  37 #include <ui/gui/helper.h>
  38 #include <ui/gui/psppire-dialog.h>
  39 #include <ui/gui/psppire-var-store.h>
  40
  41 #include "psppire-val-chooser.h"
  42
  43 #include <ui/syntax-gen.h>
  44
  45 #include "psppire-acr.h"
  46
  47 #include "gettext.h"
  48 #define _(msgid) gettext (msgid)
  49 #define N_(msgid) msgid
  50
  51
  52 /* Define a boxed type to represent a value which is a candidate
  53    to replace an existing value */
  54
  55 enum new_value_type
  56  {
  57    NV_NUMERIC,
  58    NV_STRING,
  59    NV_SYSMIS,
  60    NV_COPY
  61  };
  62
  63
  64 struct new_value
  65 {
  66   enum new_value_type type;
  67   union {
  68     double v;
  69     gchar *s;
  70   } v;
  71 };
  72
  73
  74 static struct new_value *
  75 new_value_copy (struct new_value *nv)
  76 {
  77   struct new_value *copy = g_memdup (nv, sizeof (*copy));
  78
  79   if ( nv->type == NV_STRING )
  80     copy->v.s = xstrdup (nv->v.s);
  81
  82   return copy;
  83 }
  84
  85
  86 static void
  87 new_value_free (struct new_value *nv)
  88 {
  89   if ( nv->type == NV_STRING )
  90     g_free (nv->v.s);
  91
  92   g_free (nv);
  93 }
  94
  95
  96 static void
  97 new_value_to_string (const GValue *src, GValue *dest)
  98 {
  99   const struct new_value *nv = g_value_get_boxed (src);
 100
 101   g_assert (nv);
 102
 103   switch (nv->type)
 104     {
 105     case NV_NUMERIC:
 106       {
 107         gchar *text = g_strdup_printf ("%g", nv->v.v);
 108         g_value_set_string (dest, text);
 109         g_free (text);
 110       }
 111       break;
 112     case NV_STRING:
 113       g_value_set_string (dest, nv->v.s);
 114       break;
 115     case NV_COPY:
 116       g_value_set_string (dest, "COPY");
 117       break;
 118     case NV_SYSMIS:
 119       g_value_set_string (dest, "SYSMIS");
 120       break;
 121     default:
 122       /* Shouldn't ever happen */
 123       g_warning ("Invalid type in new recode value");
 124       g_value_set_string (dest, "???");
 125       break;
 126     }
 127 }
 128
 129 static GType
 130 new_value_get_type (void)
 131 {
 132   static GType t = 0;
 133
 134   if (t == 0 )
 135     {
 136       t = g_boxed_type_register_static  ("psppire-recode-new-values",
 137                                          (GBoxedCopyFunc) new_value_copy,
 138                                          (GBoxedFreeFunc) new_value_free);
 139
 140       g_value_register_transform_func (t, G_TYPE_STRING,
 141                                        new_value_to_string);
 142     }
 143
 144   return t;
 145 }
 146
 147
 148 \f
 149
 150 enum
 151   {
 152     BUTTON_NEW_VALUE,
 153     BUTTON_NEW_COPY,
 154     BUTTON_NEW_SYSMIS,
 155     n_BUTTONS
 156   };
 157
 158 struct recode_dialog
 159 {
 160   PsppireDict *dict;
 161
 162   GtkWidget *dialog;
 163   PsppireDialog *old_and_new_dialog;
 164
 165   GtkWidget *dict_treeview;
 166   GtkWidget *variable_treeview;
 167   GtkWidget *toggle[n_BUTTONS];
 168
 169   GtkWidget *strings_box;
 170   GtkWidget *convert_button;
 171   GtkWidget *new_copy_label;
 172
 173   GtkWidget *new_value_entry;
 174
 175   GtkWidget *old_value_chooser;
 176
 177   GtkListStore *value_map;
 178
 179   /* Indicates that the INTO {new variables} form of the dialog
 180      is being used */
 181   gboolean different;
 182
 183   PsppireAcr *acr;
 184
 185   gboolean input_var_is_string;
 186
 187   GtkWidget *new_name_entry;
 188   GtkWidget *new_label_entry;
 189   GtkWidget *change_button;
 190
 191   GtkWidget *string_button;
 192   GtkWidget *width_entry;
 193
 194   /* A hash table of struct nlp's indexed by variable */
 195   GHashTable *varmap;
 196 };
 197
 198
 199 static void run_old_and_new_dialog (struct recode_dialog *rd);
 200
 201 static void
 202 refresh (PsppireDialog *dialog, struct recode_dialog *rd)
 203 {
 204   GtkTreeModel *vars =
 205     gtk_tree_view_get_model (GTK_TREE_VIEW (rd->variable_treeview));
 206
 207   gtk_list_store_clear (GTK_LIST_STORE (vars));
 208
 209   gtk_widget_set_sensitive (rd->change_button, FALSE);
 210   gtk_widget_set_sensitive (rd->new_name_entry, FALSE);
 211   gtk_widget_set_sensitive (rd->new_label_entry, FALSE);
 212
 213   if ( rd->different && rd->varmap )
 214     g_hash_table_remove_all (rd->varmap);
 215
 216   gtk_list_store_clear (GTK_LIST_STORE (rd->value_map));
 217 }
 218
 219 static char * generate_syntax (const struct recode_dialog *rd);
 220
 221 enum {
 222   COL_VALUE_OLD,
 223   COL_VALUE_NEW,
 224   n_COL_VALUES
 225 };
 226
 227 /* Dialog is valid iff at least one variable has been selected,
 228    AND the list of mappings is not empty.
 229  */
 230 static gboolean
 231 dialog_state_valid (gpointer data)
 232 {
 233   GtkTreeIter not_used;
 234   struct recode_dialog *rd = data;
 235
 236   if ( ! rd->value_map )
 237     return FALSE;
 238
 239   if ( ! gtk_tree_model_get_iter_first (GTK_TREE_MODEL (rd->value_map),
 240                                         &not_used) )
 241     return FALSE;
 242
 243   if ( rd->different )
 244     {
 245       GtkTreeModel *model = GTK_TREE_MODEL (PSPPIRE_VAR_VIEW (rd->variable_treeview)->list);
 246
 247       if (g_hash_table_size (rd->varmap) != gtk_tree_model_iter_n_children (model, NULL) )
 248         return FALSE;
 249     }
 250   else
 251     {
 252       GtkTreeModel *vars =
 253         gtk_tree_view_get_model (GTK_TREE_VIEW (rd->variable_treeview));
 254
 255       if ( !gtk_tree_model_get_iter_first (vars, &not_used))
 256         return FALSE;
 257     }
 258
 259   return TRUE;
 260 }
 261
 262 static void
 263 on_old_new_show (struct recode_dialog *rd)
 264 {
 265   gtk_toggle_button_set_active
 266     (GTK_TOGGLE_BUTTON (rd->toggle[BUTTON_NEW_VALUE]), TRUE);
 267
 268   g_signal_emit_by_name (rd->toggle[BUTTON_NEW_VALUE], "toggled");
 269
 270   g_object_set (rd->toggle[BUTTON_NEW_COPY],
 271                 "visible", rd->different, NULL);
 272
 273   g_object_set (rd->new_copy_label,
 274                 "visible", rd->different, NULL);
 275
 276   g_object_set (rd->strings_box,
 277                 "visible", rd->different, NULL);
 278 }
 279
 280 /* Sets the sensitivity of TARGET dependent upon the active status
 281    of BUTTON */
 282 static void
 283 toggle_sensitivity (GtkToggleButton *button, GtkWidget *target)
 284 {
 285   gboolean state = gtk_toggle_button_get_active (button);
 286
 287   /*  g_print ("%s Setting %p (%s) to %d because of %p\n",
 288       __FUNCTION__, target, gtk_widget_get_name (target), state, button); */
 289
 290   gtk_widget_set_sensitive (target, state);
 291 }
 292
 293 static void recode_dialog (PsppireDataWindow *de, gboolean diff);
 294
 295
 296 /* Pops up the Recode Same version of the dialog box */
 297 void
 298 recode_same_dialog (PsppireDataWindow *de)
 299 {
 300   recode_dialog (de, FALSE);
 301 }
 302
 303 /* Pops up the Recode Different version of the dialog box */
 304 void
 305 recode_different_dialog (PsppireDataWindow *de)
 306 {
 307   recode_dialog (de, TRUE);
 308 }
 309
 310
 311 /* This might need to be changed to something less naive.
 312    In particular, what happends with dates, etc?
 313  */
 314 static gchar *
 315 num_to_string (gdouble x)
 316 {
 317   return g_strdup_printf ("%g", x);
 318 }
 319
 320 /* Callback which gets called when a new row is selected
 321    in the acr's variable treeview.
 322    We use if to set the togglebuttons and entries to correspond to the
 323    selected row.
 324 */
 325 static void
 326 on_acr_selection_change (GtkTreeSelection *selection, gpointer data)
 327 {
 328   struct recode_dialog *rd = data;
 329   GtkTreeModel *model = NULL;
 330   GtkTreeIter iter;
 331
 332   GValue ov_value = {0};
 333   GValue nv_value = {0};
 334   struct old_value *ov = NULL;
 335   struct new_value *nv = NULL;
 336
 337   if ( ! gtk_tree_selection_get_selected (selection, &model, &iter) )
 338     return;
 339
 340
 341   gtk_tree_model_get_value (GTK_TREE_MODEL (model), &iter,
 342                             COL_VALUE_OLD, &ov_value);
 343
 344   gtk_tree_model_get_value (GTK_TREE_MODEL (model), &iter,
 345                             COL_VALUE_NEW, &nv_value);
 346
 347   ov = g_value_get_boxed (&ov_value);
 348   nv = g_value_get_boxed (&nv_value);
 349
 350   if (nv)
 351     {
 352       switch (nv->type)
 353         {
 354         case NV_NUMERIC:
 355           {
 356             gchar *str = num_to_string (nv->v.v);
 357
 358             gtk_toggle_button_set_active
 359               (GTK_TOGGLE_BUTTON (rd->toggle [BUTTON_NEW_VALUE]), TRUE);
 360
 361             gtk_entry_set_text (GTK_ENTRY (rd->new_value_entry), str);
 362             g_free (str);
 363           }
 364           break;
 365         case NV_STRING:
 366           gtk_toggle_button_set_active
 367             (GTK_TOGGLE_BUTTON (rd->toggle [BUTTON_NEW_VALUE]), TRUE);
 368
 369           gtk_entry_set_text (GTK_ENTRY (rd->new_value_entry), nv->v.s);
 370           break;
 371         case NV_SYSMIS:
 372           gtk_toggle_button_set_active
 373             (GTK_TOGGLE_BUTTON (rd->toggle [BUTTON_NEW_SYSMIS]), TRUE);
 374
 375           break;
 376         case NV_COPY:
 377           gtk_toggle_button_set_active
 378             (GTK_TOGGLE_BUTTON (rd->toggle [BUTTON_NEW_COPY]), TRUE);
 379
 380           break;
 381         default:
 382           g_warning ("Invalid new value type");
 383           break;
 384         }
 385
 386       g_value_unset (&nv_value);
 387     }
 388
 389   psppire_val_chooser_set_status (PSPPIRE_VAL_CHOOSER (rd->old_value_chooser), ov);
 390 }
 391
 392 /* Name-Label pair */
 393 struct nlp
 394 {
 395   char *name;
 396   char *label;
 397 };
 398
 399 static struct nlp *
 400 nlp_create (const char *name, const char *label)
 401 {
 402   struct nlp *nlp = xmalloc (sizeof *nlp);
 403
 404   nlp->name = g_strdup (name);
 405
 406   nlp->label = NULL;
 407
 408   if ( 0 != strcmp ("", label))
 409     nlp->label = g_strdup (label);
 410
 411   return nlp;
 412 }
 413
 414 static void
 415 nlp_destroy (gpointer data)
 416 {
 417   struct nlp *nlp = data ;
 418   if ( ! nlp )
 419     return;
 420
 421   g_free (nlp->name);
 422   g_free (nlp->label);
 423   g_free (nlp);
 424 }
 425
 426
 427 /* Callback which gets called when a new row is selected
 428    in the variable treeview.
 429    It sets the name and label entry widgets to reflect the
 430    currently selected row.
 431  */
 432 static void
 433 on_selection_change (GtkTreeSelection *selection, gpointer data)
 434 {
 435   struct recode_dialog *rd = data;
 436
 437   GtkTreeModel *model = GTK_TREE_MODEL (PSPPIRE_VAR_VIEW (rd->variable_treeview)->list);
 438
 439   GList *rows = gtk_tree_selection_get_selected_rows (selection, &model);
 440
 441   if ( rows && !rows->next)
 442     {
 443       /* Exactly one row is selected */
 444       struct nlp *nlp;
 445       struct variable *var;
 446       gboolean ok;
 447       GtkTreeIter iter;
 448
 449       gtk_widget_set_sensitive  (rd->change_button, TRUE);
 450       gtk_widget_set_sensitive  (rd->new_name_entry, TRUE);
 451       gtk_widget_set_sensitive  (rd->new_label_entry, TRUE);
 452
 453       ok = gtk_tree_model_get_iter (model, &iter, (GtkTreePath*) rows->data);
 454
 455       gtk_tree_model_get (model, &iter,
 456                           0, &var,
 457                           -1);
 458
 459       nlp = g_hash_table_lookup (rd->varmap, var);
 460
 461       if (nlp)
 462         {
 463           gtk_entry_set_text (GTK_ENTRY (rd->new_name_entry), nlp->name ? nlp->name : "");
 464           gtk_entry_set_text (GTK_ENTRY (rd->new_label_entry), nlp->label ? nlp->label : "");
 465         }
 466       else
 467         {
 468           gtk_entry_set_text (GTK_ENTRY (rd->new_name_entry), "");
 469           gtk_entry_set_text (GTK_ENTRY (rd->new_label_entry), "");
 470         }
 471     }
 472   else
 473     {
 474       gtk_widget_set_sensitive  (rd->change_button, FALSE);
 475       gtk_widget_set_sensitive  (rd->new_name_entry, FALSE);
 476       gtk_widget_set_sensitive  (rd->new_label_entry, FALSE);
 477
 478       gtk_entry_set_text (GTK_ENTRY (rd->new_name_entry), "");
 479       gtk_entry_set_text (GTK_ENTRY (rd->new_label_entry), "");
 480     }
 481
 482
 483   g_list_foreach (rows, (GFunc) gtk_tree_path_free, NULL);
 484   g_list_free (rows);
 485 }
 486
 487 static void
 488 on_string_toggled (GtkToggleButton *b, struct recode_dialog *rd)
 489 {
 490   gboolean active;
 491   if (! rd->input_var_is_string )
 492     return ;
 493
 494   active = gtk_toggle_button_get_active (b);
 495   gtk_widget_set_sensitive (rd->convert_button, !active);
 496 }
 497
 498
 499 static void
 500 on_convert_toggled (GtkToggleButton *b, struct recode_dialog *rd)
 501 {
 502   gboolean active;
 503
 504   g_return_if_fail (rd->input_var_is_string);
 505
 506   active = gtk_toggle_button_get_active (b);
 507   gtk_widget_set_sensitive (rd->string_button, !active);
 508 }
 509
 510 static void
 511 on_change_clicked (GObject *obj, gpointer data)
 512 {
 513   struct recode_dialog *rd = data;
 514   struct variable *var = NULL;
 515   struct nlp *nlp;
 516   GtkTreeModel *model = GTK_TREE_MODEL (PSPPIRE_VAR_VIEW (rd->variable_treeview)->list);
 517   GtkTreeIter iter;
 518   GtkTreeSelection *selection =
 519     gtk_tree_view_get_selection (GTK_TREE_VIEW (rd->variable_treeview));
 520
 521   GList *rows = gtk_tree_selection_get_selected_rows (selection, &model);
 522
 523   const gchar *dest_var_name =
 524     gtk_entry_get_text (GTK_ENTRY (rd->new_name_entry));
 525
 526   const gchar *dest_var_label =
 527     gtk_entry_get_text (GTK_ENTRY (rd->new_label_entry));
 528
 529   if ( NULL == rows || rows->next != NULL)
 530     goto finish;
 531
 532   gtk_tree_model_get_iter (model, &iter, rows->data);
 533
 534   gtk_tree_model_get (model, &iter, 0, &var, -1);
 535
 536   g_hash_table_remove (rd->varmap, var);
 537
 538   nlp = nlp_create (dest_var_name, dest_var_label);
 539
 540   g_hash_table_insert (rd->varmap, var, nlp);
 541
 542   gtk_tree_model_row_changed (model, rows->data, &iter);
 543
 544  finish:
 545   g_list_foreach (rows, (GFunc) gtk_tree_path_free, NULL);
 546   g_list_free (rows);
 547 }
 548
 549
 550 /* Callback for the new_value_entry and new_value_togglebutton widgets.
 551    It's used to enable/disable the acr. */
 552 static void
 553 set_acr (struct recode_dialog *rd)
 554 {
 555   const gchar *text;
 556
 557   if ( !gtk_toggle_button_get_active
 558        (GTK_TOGGLE_BUTTON (rd->toggle[BUTTON_NEW_VALUE])))
 559     {
 560       psppire_acr_set_enabled (rd->acr, TRUE);
 561       return;
 562     }
 563
 564   text = gtk_entry_get_text (GTK_ENTRY (rd->new_value_entry));
 565
 566   psppire_acr_set_enabled (rd->acr, !g_str_equal (text, ""));
 567 }
 568
 569 static void
 570 render_new_var_name (GtkTreeViewColumn *tree_column,
 571                      GtkCellRenderer *cell,
 572                      GtkTreeModel *tree_model,
 573                      GtkTreeIter *iter,
 574                      gpointer data)
 575 {
 576   struct nlp *nlp = NULL;
 577   struct recode_dialog *rd = data;
 578
 579   struct variable *var = NULL;
 580
 581   gtk_tree_model_get (tree_model, iter,
 582                       0, &var,
 583                       -1);
 584
 585   nlp = g_hash_table_lookup (rd->varmap, var);
 586
 587   if ( nlp )
 588     g_object_set (cell, "text", nlp->name, NULL);
 589   else
 590     g_object_set (cell, "text", "", NULL);
 591 }
 592
 593
 594
 595 static void
 596 recode_dialog (PsppireDataWindow *de, gboolean diff)
 597 {
 598   gint response;
 599
 600   struct recode_dialog rd;
 601
 602   GtkBuilder *builder = builder_new ("recode.ui");
 603
 604   GtkWidget *selector = get_widget_assert (builder, "psppire-selector1");
 605
 606   GtkWidget *oldandnew = get_widget_assert (builder, "button1");
 607
 608
 609   GtkWidget *output_variable_box = get_widget_assert (builder,"frame4");
 610
 611   PsppireVarStore *vs = NULL;
 612   g_object_get (de->data_editor, "var-store", &vs, NULL);
 613
 614   rd.change_button = get_widget_assert (builder, "change-button");
 615   rd.varmap = NULL;
 616   rd.dialog = get_widget_assert   (builder, "recode-dialog");
 617   rd.dict_treeview = get_widget_assert (builder, "treeview1");
 618   rd.variable_treeview =   get_widget_assert (builder, "treeview2");
 619   rd.new_name_entry = get_widget_assert (builder, "dest-name-entry");
 620   rd.new_label_entry = get_widget_assert (builder, "dest-label-entry");
 621
 622   g_object_get (vs, "dictionary", &rd.dict, NULL);
 623
 624   rd.value_map = gtk_list_store_new (2,
 625                                      old_value_get_type (),
 626                                      new_value_get_type ()
 627                                      );
 628
 629   g_object_set (output_variable_box, "visible", diff, NULL);
 630
 631   if ( diff )
 632     gtk_window_set_title (GTK_WINDOW (rd.dialog),
 633                           _("Recode into Different Variables"));
 634   else
 635     gtk_window_set_title (GTK_WINDOW (rd.dialog),
 636                           _("Recode into Same Variables"));
 637
 638   rd.different = diff;
 639
 640   gtk_window_set_transient_for (GTK_WINDOW (rd.dialog), GTK_WINDOW (de));
 641
 642   g_object_set (rd.dict_treeview, "model", rd.dict, NULL);
 643
 644   if (rd.different)
 645     {
 646       GtkTreeSelection *sel;
 647
 648       GtkCellRenderer *renderer = gtk_cell_renderer_text_new ();
 649
 650       GtkTreeViewColumn *col = gtk_tree_view_column_new_with_attributes (_("New"),
 651                                                                          renderer,
 652                                                                          "text", NULL,
 653                                                                          NULL);
 654
 655       gtk_tree_view_column_set_cell_data_func (col, renderer,
 656                                                render_new_var_name,
 657                                                &rd, NULL);
 658
 659
 660       gtk_tree_view_append_column (GTK_TREE_VIEW (rd.variable_treeview), col);
 661
 662
 663       col = gtk_tree_view_get_column (GTK_TREE_VIEW (rd.variable_treeview), 0);
 664
 665       g_object_set (col, "title", _("Old"), NULL);
 666
 667       g_object_set (rd.variable_treeview, "headers-visible", TRUE, NULL);
 668
 669       rd.varmap = g_hash_table_new_full (g_direct_hash, g_direct_equal, NULL, nlp_destroy);
 670
 671       sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (rd.variable_treeview));
 672
 673       g_signal_connect (sel, "changed",
 674                         G_CALLBACK (on_selection_change), &rd);
 675
 676       g_signal_connect (rd.change_button, "clicked",
 677                         G_CALLBACK (on_change_clicked),  &rd);
 678
 679     }
 680
 681   psppire_selector_set_allow (PSPPIRE_SELECTOR (selector), homogeneous_types);
 682
 683   /* Set up the Old & New Values subdialog */
 684   {
 685     rd.string_button = get_widget_assert (builder, "checkbutton1");
 686     rd.width_entry   = get_widget_assert (builder, "spinbutton1");
 687
 688     rd.convert_button           = get_widget_assert (builder, "checkbutton2");
 689
 690     rd.old_value_chooser = get_widget_assert (builder, "val-chooser");
 691
 692     rd.new_value_entry = get_widget_assert (builder, "entry1");
 693
 694
 695     rd.toggle[BUTTON_NEW_VALUE]  = get_widget_assert (builder, "radiobutton1");
 696     rd.toggle[BUTTON_NEW_SYSMIS] = get_widget_assert (builder, "radiobutton2");
 697     rd.toggle[BUTTON_NEW_COPY]   = get_widget_assert (builder, "radiobutton3");
 698
 699     rd.new_copy_label = get_widget_assert (builder, "label3");
 700     rd.strings_box    = get_widget_assert (builder, "table3");
 701
 702     rd.old_and_new_dialog =
 703       PSPPIRE_DIALOG (get_widget_assert (builder, "old-new-values-dialog"));
 704
 705     gtk_window_set_transient_for (GTK_WINDOW (rd.old_and_new_dialog),
 706                                   GTK_WINDOW (de));
 707
 708     rd.acr = PSPPIRE_ACR (get_widget_assert (builder, "psppire-acr1"));
 709
 710     g_signal_connect_swapped (rd.toggle[BUTTON_NEW_VALUE], "toggled",
 711                       G_CALLBACK (set_acr), &rd);
 712
 713     g_signal_connect_swapped (rd.new_value_entry, "changed",
 714                       G_CALLBACK (set_acr), &rd);
 715
 716     {
 717       GtkTreeSelection *sel;
 718       /* Remove the ACR's default column.  We don't like it */
 719       GtkTreeViewColumn *column = gtk_tree_view_get_column (rd.acr->tv, 0);
 720       gtk_tree_view_remove_column (rd.acr->tv, column);
 721
 722
 723       column =
 724         gtk_tree_view_column_new_with_attributes (_("Old"),
 725                                                   gtk_cell_renderer_text_new (),
 726                                                   "text", 0,
 727                                                   NULL);
 728
 729       gtk_tree_view_append_column (rd.acr->tv, column);
 730
 731       column =
 732         gtk_tree_view_column_new_with_attributes (_("New"),
 733                                                   gtk_cell_renderer_text_new (),
 734                                                   "text", 1,
 735                                                   NULL);
 736
 737       gtk_tree_view_append_column (rd.acr->tv, column);
 738       g_object_set (rd.acr->tv, "headers-visible", TRUE, NULL);
 739
 740
 741       sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (rd.acr->tv));
 742       g_signal_connect (sel, "changed",
 743                         G_CALLBACK (on_acr_selection_change), &rd);
 744     }
 745
 746
 747     g_signal_connect_swapped (oldandnew, "clicked",
 748                               G_CALLBACK (run_old_and_new_dialog), &rd);
 749
 750
 751     g_signal_connect (rd.toggle[BUTTON_NEW_VALUE], "toggled",
 752                       G_CALLBACK (toggle_sensitivity), rd.new_value_entry);
 753
 754     g_signal_connect (rd.string_button, "toggled",
 755                       G_CALLBACK (toggle_sensitivity), rd.width_entry);
 756
 757     g_signal_connect (rd.string_button, "toggled",
 758                       G_CALLBACK (on_string_toggled), &rd);
 759
 760     g_signal_connect (rd.convert_button, "toggled",
 761                       G_CALLBACK (on_convert_toggled), &rd);
 762
 763     g_signal_connect_swapped (rd.old_and_new_dialog, "show",
 764                               G_CALLBACK (on_old_new_show), &rd);
 765   }
 766
 767   g_signal_connect (rd.dialog, "refresh", G_CALLBACK (refresh),  &rd);
 768
 769
 770   psppire_dialog_set_valid_predicate (PSPPIRE_DIALOG (rd.dialog),
 771                                       dialog_state_valid, &rd);
 772
 773   response = psppire_dialog_run (PSPPIRE_DIALOG (rd.dialog));
 774
 775   switch (response)
 776     {
 777     case GTK_RESPONSE_OK:
 778       g_free (execute_syntax_string (de, generate_syntax (&rd)));
 779       break;
 780     case PSPPIRE_RESPONSE_PASTE:
 781       g_free (paste_syntax_to_window (generate_syntax (&rd)));
 782       break;
 783     default:
 784       break;
 785     }
 786
 787   if (rd.varmap)
 788     g_hash_table_destroy (rd.varmap);
 789
 790   gtk_list_store_clear (GTK_LIST_STORE (rd.value_map));
 791   g_object_unref (rd.value_map);
 792
 793   g_object_unref (builder);
 794 }
 795
 796 /* Initialise VAL to reflect the current status of RD */
 797 static gboolean
 798 set_old_value (GValue *val, const struct recode_dialog *rd)
 799 {
 800   PsppireValChooser *vc = PSPPIRE_VAL_CHOOSER (rd->old_value_chooser);
 801
 802   struct old_value ov;
 803
 804   psppire_val_chooser_get_status (vc, &ov);
 805
 806   g_value_init (val, old_value_get_type ());
 807   g_value_set_boxed (val, &ov);
 808
 809   return TRUE;
 810 }
 811
 812
 813 /* Initialse VAL to reflect the current status of RD */
 814 static gboolean
 815 set_new_value (GValue *val, const struct recode_dialog *rd)
 816 {
 817   const gchar *text = NULL;
 818   struct new_value nv;
 819
 820   if ( gtk_toggle_button_get_active
 821        (GTK_TOGGLE_BUTTON (rd->toggle [BUTTON_NEW_VALUE])))
 822     {
 823       text = gtk_entry_get_text (GTK_ENTRY (rd->new_value_entry));
 824
 825       nv.type = NV_NUMERIC;
 826       if (
 827           (! rd->different && rd->input_var_is_string) ||
 828           ( rd->different &&
 829             gtk_toggle_button_get_active
 830                (GTK_TOGGLE_BUTTON (rd->string_button)))
 831           )
 832         {
 833           nv.type = NV_STRING;
 834         }
 835
 836       if ( nv.type == NV_STRING )
 837         nv.v.s = g_strdup (text);
 838       else
 839         nv.v.v = g_strtod (text, 0);
 840     }
 841   else if ( gtk_toggle_button_get_active
 842             (GTK_TOGGLE_BUTTON (rd->toggle [BUTTON_NEW_COPY])))
 843     {
 844       nv.type = NV_COPY;
 845     }
 846
 847   else if ( gtk_toggle_button_get_active
 848             (GTK_TOGGLE_BUTTON (rd->toggle [BUTTON_NEW_SYSMIS])))
 849     {
 850       nv.type = NV_SYSMIS;
 851     }
 852   else
 853     return FALSE;
 854
 855   g_value_init (val, new_value_get_type ());
 856   g_value_set_boxed (val, &nv);
 857
 858   return TRUE;
 859 }
 860
 861
 862 /* A function to set a value in a column in the ACR */
 863 static gboolean
 864 set_value (gint col, GValue  *val, gpointer data)
 865 {
 866   struct recode_dialog *rd = data;
 867
 868   switch ( col )
 869     {
 870     case COL_VALUE_OLD:
 871       set_old_value (val, rd);
 872       break;
 873     case COL_VALUE_NEW:
 874       set_new_value (val, rd);
 875       break;
 876     default:
 877       return FALSE;
 878     }
 879
 880   return TRUE;
 881 }
 882
 883 static void
 884 run_old_and_new_dialog (struct recode_dialog *rd)
 885 {
 886   gint response;
 887   GtkListStore *local_store = clone_list_store (rd->value_map);
 888
 889   psppire_acr_set_model (rd->acr, local_store);
 890   psppire_acr_set_get_value_func (rd->acr, set_value, rd);
 891
 892   gtk_window_set_title (GTK_WINDOW (rd->old_and_new_dialog),
 893                         rd->different
 894                         ? _("Recode into Different Variables: Old and New Values ")
 895                         : _("Recode into Same Variables: Old and New Values")
 896                         );
 897
 898
 899   {
 900     /* Find the type of the first variable (it's invariant that
 901        all variables are of the same type) */
 902     const struct variable *v;
 903     GtkTreeIter iter;
 904     GtkTreeModel *model =
 905       gtk_tree_view_get_model (GTK_TREE_VIEW (rd->variable_treeview));
 906
 907     gboolean not_empty = gtk_tree_model_get_iter_first (model, &iter);
 908
 909     g_return_if_fail (not_empty);
 910
 911     gtk_tree_model_get (model, &iter, 0, &v, -1);
 912
 913     rd->input_var_is_string = var_is_alpha (v);
 914
 915     g_object_set (rd->old_value_chooser, "is-string", rd->input_var_is_string, NULL);
 916
 917     gtk_widget_set_sensitive (rd->toggle [BUTTON_NEW_SYSMIS],
 918                               var_is_numeric (v));
 919
 920     gtk_widget_set_sensitive (rd->convert_button, var_is_alpha (v));
 921   }
 922
 923
 924   response = psppire_dialog_run (rd->old_and_new_dialog);
 925   psppire_acr_set_model (rd->acr, NULL);
 926
 927
 928   if ( response == PSPPIRE_RESPONSE_CONTINUE )
 929     {
 930       g_object_unref (rd->value_map);
 931       rd->value_map = clone_list_store (local_store);
 932     }
 933   else
 934     g_object_unref (local_store);
 935
 936
 937   psppire_dialog_notify_change (PSPPIRE_DIALOG (rd->dialog));
 938 }
 939
 940
 941 /* Generate a syntax fragment for NV and append it to STR */
 942 static void
 943 new_value_append_syntax (GString *str, const struct new_value *nv)
 944 {
 945   switch (nv->type)
 946     {
 947     case NV_NUMERIC:
 948       g_string_append_printf (str, "%g", nv->v.v);
 949       break;
 950     case NV_STRING:
 951       {
 952         struct string ds = DS_EMPTY_INITIALIZER;
 953         syntax_gen_string (&ds, ss_cstr (nv->v.s));
 954         g_string_append (str, ds_cstr (&ds));
 955         ds_destroy (&ds);
 956       }
 957       break;
 958     case NV_COPY:
 959       g_string_append (str, "COPY");
 960       break;
 961     case NV_SYSMIS:
 962       g_string_append (str, "SYSMIS");
 963       break;
 964     default:
 965       /* Shouldn't ever happen */
 966       g_warning ("Invalid type in new recode value");
 967       g_string_append (str, "???");
 968       break;
 969     }
 970 }
 971
 972
 973 static char *
 974 generate_syntax (const struct recode_dialog *rd)
 975 {
 976   gboolean ok;
 977   GtkTreeIter iter;
 978   gchar *text;
 979
 980   GString *str = g_string_sized_new (100);
 981
 982   /* Declare new string variables if applicable */
 983   if ( rd->different &&
 984        gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (rd->string_button)))
 985     {
 986       GHashTableIter iter;
 987
 988       struct variable *var = NULL;
 989       struct nlp *nlp = NULL;
 990
 991       g_hash_table_iter_init (&iter, rd->varmap);
 992       while (g_hash_table_iter_next (&iter, (void**) &var, (void**) &nlp))
 993         {
 994           g_string_append (str, "\nSTRING ");
 995           g_string_append (str, nlp->name);
 996           g_string_append_printf (str, " (A%d).",
 997                                   (int)
 998                                   gtk_spin_button_get_value (GTK_SPIN_BUTTON (rd->width_entry) )
 999                                   );
1000         }
1001     }
1002
1003   g_string_append (str, "\nRECODE ");
1004
1005   psppire_var_view_append_names (PSPPIRE_VAR_VIEW (rd->variable_treeview), 0, str);
1006
1007   g_string_append (str, "\n\t");
1008
1009   if ( gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (rd->convert_button)))
1010     {
1011       g_string_append (str, "(CONVERT) ");
1012     }
1013
1014   for (ok = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (rd->value_map),
1015                                            &iter);
1016        ok;
1017        ok = gtk_tree_model_iter_next (GTK_TREE_MODEL (rd->value_map), &iter))
1018     {
1019       GValue ov_value = {0};
1020       GValue nv_value = {0};
1021       struct old_value *ov;
1022       struct new_value *nv;
1023       gtk_tree_model_get_value (GTK_TREE_MODEL (rd->value_map), &iter,
1024                                 COL_VALUE_OLD, &ov_value);
1025
1026       gtk_tree_model_get_value (GTK_TREE_MODEL (rd->value_map), &iter,
1027                                 COL_VALUE_NEW, &nv_value);
1028
1029       ov = g_value_get_boxed (&ov_value);
1030       nv = g_value_get_boxed (&nv_value);
1031
1032       g_string_append (str, "(");
1033
1034       old_value_append_syntax (str, ov);
1035       g_string_append (str, " = ");
1036       new_value_append_syntax (str, nv);
1037
1038       g_string_append (str, ") ");
1039       g_value_unset (&ov_value);
1040       g_value_unset (&nv_value);
1041     }
1042
1043
1044   if ( rd->different )
1045     {
1046
1047       GtkTreeIter iter;
1048       g_string_append (str, "\n\tINTO ");
1049
1050       for (ok = psppire_var_view_get_iter_first (PSPPIRE_VAR_VIEW (rd->variable_treeview), &iter);
1051            ok;
1052            ok = psppire_var_view_get_iter_next (PSPPIRE_VAR_VIEW (rd->variable_treeview), &iter))
1053           {
1054             struct nlp *nlp = NULL;
1055             const struct variable *var = psppire_var_view_get_variable (PSPPIRE_VAR_VIEW (rd->variable_treeview), 0, &iter);
1056
1057             nlp = g_hash_table_lookup (rd->varmap, var);
1058
1059             g_string_append (str, nlp->name);
1060             g_string_append (str, " ");
1061           }
1062     }
1063
1064   g_string_append (str, ".");
1065
1066   /* If applicable, set labels for the new variables. */
1067   if ( rd->different )
1068     {
1069       GHashTableIter iter;
1070
1071       struct variable *var = NULL;
1072       struct nlp *nlp = NULL;
1073
1074       g_hash_table_iter_init (&iter, rd->varmap);
1075       while (g_hash_table_iter_next (&iter, (void**) &var, (void**) &nlp))
1076         {
1077           if (nlp->label)
1078             g_string_append_printf (str, "\nVARIABLE LABELS %s %s.",
1079                                     nlp->name, nlp->label);
1080         }
1081     }
1082
1083   g_string_append (str, "\nEXECUTE.\n");
1084
1085
1086   text = str->str;
1087
1088   g_string_free (str, FALSE);
1089
1090   return text;
1091 }