1 /* PSPPIRE - a graphical user interface for PSPP.
2 Copyright (C) 2007 Free Software Foundation
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.
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.
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/>. */
17 /* This module implements the RECODE dialog.
19 It has two forms. One for recoding values into the same variable.
20 The second for recoding into different variables.
25 #include "recode-dialog.h"
29 #include <language/syntax-string-source.h>
30 #include <ui/gui/data-editor.h>
31 #include <ui/gui/dialog-common.h>
32 #include <ui/gui/dict-display.h>
33 #include <ui/gui/helper.h>
34 #include <ui/gui/psppire-dialog.h>
35 #include <ui/gui/psppire-var-store.h>
36 #include <ui/gui/syntax-editor.h>
37 #include <ui/syntax-gen.h>
39 #include "psppire-acr.h"
42 #define _(msgid) gettext (msgid)
43 #define N_(msgid) msgid
46 /* Define a boxed type to represent a value which is a candidate
47 to replace an existing value */
60 enum new_value_type type;
68 static struct new_value *
69 new_value_copy (struct new_value *nv)
71 struct new_value *copy = g_memdup (nv, sizeof (*copy));
73 if ( nv->type == NV_STRING )
74 copy->v.s = strdup (nv->v.s);
81 new_value_free (struct new_value *nv)
83 if ( nv->type == NV_STRING )
91 new_value_to_string (const GValue *src, GValue *dest)
93 const struct new_value *nv = g_value_get_boxed (src);
101 gchar *text = g_strdup_printf ("%g", nv->v.v);
102 g_value_set_string (dest, text);
107 g_value_set_string (dest, nv->v.s);
110 g_value_set_string (dest, "COPY");
113 g_value_set_string (dest, "SYSMIS");
116 /* Shouldn't ever happen */
117 g_warning ("Invalid type in new recode value");
118 g_value_set_string (dest, "???");
124 new_value_get_type (void)
130 t = g_boxed_type_register_static ("psppire-recode-new-values",
131 (GBoxedCopyFunc) new_value_copy,
132 (GBoxedFreeFunc) new_value_free);
134 g_value_register_transform_func (t, G_TYPE_STRING,
135 new_value_to_string);
145 /* A boxed type representing a value, or a range of values which may
146 potentially be replaced by something */
162 enum old_value_type type;
171 static struct old_value *
172 old_value_copy (struct old_value *ov)
174 struct old_value *copy = g_memdup (ov, sizeof (*copy));
176 if ( ov->type == OV_STRING )
177 copy->v.s = g_strdup (ov->v.s);
184 old_value_free (struct old_value *ov)
186 if (ov->type == OV_STRING)
192 old_value_to_string (const GValue *src, GValue *dest)
194 const struct old_value *ov = g_value_get_boxed (src);
200 gchar *text = g_strdup_printf ("%g", ov->v.v);
201 g_value_set_string (dest, text);
206 g_value_set_string (dest, ov->v.s);
209 g_value_set_string (dest, "MISSING");
212 g_value_set_string (dest, "SYSMIS");
215 g_value_set_string (dest, "ELSE");
220 char en_dash[6] = {0,0,0,0,0,0};
222 g_unichar_to_utf8 (0x2013, en_dash);
224 text = g_strdup_printf ("%g %s %g",
228 g_value_set_string (dest, text);
235 char en_dash[6] = {0,0,0,0,0,0};
237 g_unichar_to_utf8 (0x2013, en_dash);
239 text = g_strdup_printf ("LOWEST %s %g",
243 g_value_set_string (dest, text);
250 char en_dash[6] = {0,0,0,0,0,0};
252 g_unichar_to_utf8 (0x2013, en_dash);
254 text = g_strdup_printf ("%g %s HIGHEST",
258 g_value_set_string (dest, text);
263 g_warning ("Invalid type in old recode value");
264 g_value_set_string (dest, "???");
270 old_value_get_type (void)
276 t = g_boxed_type_register_static ("psppire-recode-old-values",
277 (GBoxedCopyFunc) old_value_copy,
278 (GBoxedFreeFunc) old_value_free);
280 g_value_register_transform_func (t, G_TYPE_STRING,
281 old_value_to_string);
299 BUTTON_OLD_HIGH_DOWN,
309 PsppireDialog *old_and_new_dialog;
311 GtkWidget *dict_treeview;
312 GtkWidget *variable_treeview;
313 GtkWidget *toggle[n_BUTTONS];
315 GtkWidget *strings_box;
316 GtkWidget *convert_button;
317 GtkWidget *new_copy_label;
319 GtkWidget *ov_value_entry;
320 GtkWidget *new_value_entry;
322 GtkWidget *ov_range_lower_entry;
323 GtkWidget *ov_range_upper_entry;
324 GtkWidget *ov_low_up_entry;
325 GtkWidget *ov_high_down_entry;
327 GtkListStore *value_map;
329 /* Indicates that the INTO {new variables} form of the dialog
335 gboolean input_var_is_string;
337 GtkListStore *var_map;
338 GtkWidget *new_name_entry;
339 GtkWidget *new_label_entry;
340 GtkWidget *change_button;
342 GtkWidget *string_button;
343 GtkWidget *width_entry;
347 static void run_old_and_new_dialog (struct recode_dialog *rd);
350 refresh (PsppireDialog *dialog, struct recode_dialog *rd)
352 gtk_widget_set_sensitive (rd->change_button, FALSE);
353 gtk_widget_set_sensitive (rd->new_name_entry, FALSE);
354 gtk_widget_set_sensitive (rd->new_label_entry, FALSE);
358 gtk_list_store_clear (GTK_LIST_STORE (rd->var_map));
362 gtk_tree_view_get_model (GTK_TREE_VIEW (rd->variable_treeview));
364 gtk_list_store_clear (GTK_LIST_STORE (vars));
367 gtk_list_store_clear (GTK_LIST_STORE (rd->value_map));
370 static char * generate_syntax (const struct recode_dialog *rd);
385 /* Dialog is valid iff at least one variable has been selected,
386 AND the list of mappings is not empty.
389 dialog_state_valid (gpointer data)
391 GtkTreeIter not_used;
392 struct recode_dialog *rd = data;
394 if ( ! rd->value_map )
397 if ( ! gtk_tree_model_get_iter_first (GTK_TREE_MODEL (rd->value_map),
407 for (ok = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (rd->var_map),
410 ok = gtk_tree_model_iter_next (GTK_TREE_MODEL (rd->var_map),
415 gtk_tree_model_get (GTK_TREE_MODEL (rd->var_map), &iter,
416 COL_NEW_NAME, &name, -1);
427 gtk_tree_view_get_model (GTK_TREE_VIEW (rd->variable_treeview));
429 if ( !gtk_tree_model_get_iter_first (vars, ¬_used))
438 on_old_new_show (struct recode_dialog *rd)
440 gtk_toggle_button_set_active
441 (GTK_TOGGLE_BUTTON (rd->toggle[BUTTON_OLD_VALUE]), TRUE);
443 g_signal_emit_by_name (rd->toggle[BUTTON_OLD_VALUE], "toggled");
445 gtk_toggle_button_set_active
446 (GTK_TOGGLE_BUTTON (rd->toggle[BUTTON_NEW_VALUE]), TRUE);
448 g_signal_emit_by_name (rd->toggle[BUTTON_NEW_VALUE], "toggled");
450 g_object_set (rd->toggle[BUTTON_NEW_COPY],
451 "visible", rd->different, NULL);
453 g_object_set (rd->new_copy_label,
454 "visible", rd->different, NULL);
456 g_object_set (rd->strings_box,
457 "visible", rd->different, NULL);
460 /* Sets the sensitivity of TARGET dependent upon the active status
463 toggle_sensitivity (GtkToggleButton *button, GtkWidget *target)
465 gboolean state = gtk_toggle_button_get_active (button);
467 /* g_print ("%s Setting %p (%s) to %d because of %p\n",
468 __FUNCTION__, target, gtk_widget_get_name (target), state, button); */
470 gtk_widget_set_sensitive (target, state);
473 static void recode_dialog (struct data_editor *de, gboolean diff);
476 /* Pops up the Recode Same version of the dialog box */
478 recode_same_dialog (GObject *o, gpointer data)
480 struct data_editor *de = data;
482 recode_dialog (de, FALSE);
485 /* Pops up the Recode Different version of the dialog box */
487 recode_different_dialog (GObject *o, gpointer data)
489 struct data_editor *de = data;
491 recode_dialog (de, TRUE);
495 render_new_var_name (GtkTreeViewColumn *tree_column,
496 GtkCellRenderer *cell,
497 GtkTreeModel *tree_model,
501 gchar *new_var_name = NULL;
503 gtk_tree_model_get (tree_model, iter, COL_NEW_NAME, &new_var_name, -1);
505 g_object_set (cell, "text", new_var_name, NULL);
507 g_free (new_var_name);
511 /* This might need to be changed to something less naive.
512 In particular, what happends with dates, etc?
515 num_to_string (gdouble x)
517 return g_strdup_printf ("%g", x);
520 /* Callback which gets called when a new row is selected
521 in the acr's variable treeview.
522 We use if to set the togglebuttons and entries to correspond to the
526 on_acr_selection_change (GtkTreeSelection *selection, gpointer data)
528 struct recode_dialog *rd = data;
529 GtkTreeModel *model = NULL;
532 GValue ov_value = {0};
533 GValue nv_value = {0};
534 struct old_value *ov = NULL;
535 struct new_value *nv = NULL;
537 if ( ! gtk_tree_selection_get_selected (selection, &model, &iter) )
541 gtk_tree_model_get_value (GTK_TREE_MODEL (model), &iter,
542 COL_VALUE_OLD, &ov_value);
544 gtk_tree_model_get_value (GTK_TREE_MODEL (model), &iter,
545 COL_VALUE_NEW, &nv_value);
547 ov = g_value_get_boxed (&ov_value);
548 nv = g_value_get_boxed (&nv_value);
556 gchar *str = num_to_string (nv->v.v);
558 gtk_toggle_button_set_active
559 (GTK_TOGGLE_BUTTON (rd->toggle [BUTTON_NEW_VALUE]), TRUE);
561 gtk_entry_set_text (GTK_ENTRY (rd->new_value_entry), str);
566 gtk_toggle_button_set_active
567 (GTK_TOGGLE_BUTTON (rd->toggle [BUTTON_NEW_VALUE]), TRUE);
569 gtk_entry_set_text (GTK_ENTRY (rd->new_value_entry), nv->v.s);
572 gtk_toggle_button_set_active
573 (GTK_TOGGLE_BUTTON (rd->toggle [BUTTON_NEW_SYSMIS]), TRUE);
577 gtk_toggle_button_set_active
578 (GTK_TOGGLE_BUTTON (rd->toggle [BUTTON_NEW_COPY]), TRUE);
582 g_warning ("Invalid new value type");
586 g_value_unset (&nv_value);
594 gtk_toggle_button_set_active
595 (GTK_TOGGLE_BUTTON (rd->toggle [BUTTON_OLD_VALUE]), TRUE);
597 gtk_entry_set_text (GTK_ENTRY (rd->ov_value_entry), ov->v.s);
604 gtk_toggle_button_set_active
605 (GTK_TOGGLE_BUTTON (rd->toggle [BUTTON_OLD_VALUE]), TRUE);
607 str = num_to_string (ov->v.v);
609 gtk_entry_set_text (GTK_ENTRY (rd->ov_value_entry), str);
616 gtk_toggle_button_set_active
617 (GTK_TOGGLE_BUTTON (rd->toggle [BUTTON_OLD_SYSMIS]), TRUE);
621 gtk_toggle_button_set_active
622 (GTK_TOGGLE_BUTTON (rd->toggle [BUTTON_OLD_MISSING]), TRUE);
629 gtk_toggle_button_set_active
630 (GTK_TOGGLE_BUTTON (rd->toggle [BUTTON_OLD_RANGE]), TRUE);
632 str = num_to_string (ov->v.range[0]);
634 gtk_entry_set_text (GTK_ENTRY (rd->ov_range_lower_entry), str);
639 str = num_to_string (ov->v.range[1]);
641 gtk_entry_set_text (GTK_ENTRY (rd->ov_range_upper_entry), str);
649 gchar *str = num_to_string (ov->v.range[1]);
651 gtk_toggle_button_set_active
652 (GTK_TOGGLE_BUTTON (rd->toggle [BUTTON_OLD_LOW_UP]), TRUE);
654 gtk_entry_set_text (GTK_ENTRY (rd->ov_low_up_entry), str);
662 gchar *str = num_to_string (ov->v.range[0]);
664 gtk_toggle_button_set_active
665 (GTK_TOGGLE_BUTTON (rd->toggle [BUTTON_OLD_HIGH_DOWN]), TRUE);
667 gtk_entry_set_text (GTK_ENTRY (rd->ov_high_down_entry), str);
674 gtk_toggle_button_set_active
675 (GTK_TOGGLE_BUTTON (rd->toggle [BUTTON_OLD_ELSE]), TRUE);
679 g_warning ("Unknown old value type");
682 g_value_unset (&ov_value);
686 /* Callback which gets called when a new row is selected
687 in the variable treeview.
688 It sets the name and label entry widgets to reflect the
689 currently selected row.
692 on_selection_change (GtkTreeSelection *selection, gpointer data)
694 struct recode_dialog *rd = data;
695 GtkTreeModel *model = GTK_TREE_MODEL (rd->var_map);
697 GList *rows = gtk_tree_selection_get_selected_rows (selection, &model);
699 if ( rows && !rows->next)
701 /* Exactly one row is selected */
708 gtk_widget_set_sensitive (rd->change_button, TRUE);
709 gtk_widget_set_sensitive (rd->new_name_entry, TRUE);
710 gtk_widget_set_sensitive (rd->new_label_entry, TRUE);
712 ok = gtk_tree_model_get_iter (model, &iter, (GtkTreePath*) rows->data);
714 gtk_tree_model_get (GTK_TREE_MODEL (rd->var_map), &iter,
716 COL_NEW_LABEL, &label,
719 gtk_entry_set_text (GTK_ENTRY (rd->new_name_entry), name ? name : "");
720 gtk_entry_set_text (GTK_ENTRY (rd->new_label_entry), label ? label : "");
727 gtk_widget_set_sensitive (rd->change_button, FALSE);
728 gtk_widget_set_sensitive (rd->new_name_entry, FALSE);
729 gtk_widget_set_sensitive (rd->new_label_entry, FALSE);
731 gtk_entry_set_text (GTK_ENTRY (rd->new_name_entry), "");
732 gtk_entry_set_text (GTK_ENTRY (rd->new_label_entry), "");
735 g_list_foreach (rows, (GFunc) gtk_tree_path_free, NULL);
740 on_string_toggled (GtkToggleButton *b, struct recode_dialog *rd)
743 if (! rd->input_var_is_string )
746 active = gtk_toggle_button_get_active (b);
747 gtk_widget_set_sensitive (rd->convert_button, !active);
752 on_convert_toggled (GtkToggleButton *b, struct recode_dialog *rd)
756 g_return_if_fail (rd->input_var_is_string);
758 active = gtk_toggle_button_get_active (b);
759 gtk_widget_set_sensitive (rd->string_button, !active);
764 on_change_clicked (GObject *obj, gpointer data)
766 struct recode_dialog *rd = data;
767 GtkTreeModel *model = GTK_TREE_MODEL (rd->var_map);
769 GtkTreeSelection *selection =
770 gtk_tree_view_get_selection (GTK_TREE_VIEW (rd->variable_treeview));
772 GList *rows = gtk_tree_selection_get_selected_rows (selection, &model);
774 const gchar *dest_var_name =
775 gtk_entry_get_text (GTK_ENTRY (rd->new_name_entry));
777 const gchar *dest_var_label =
778 gtk_entry_get_text (GTK_ENTRY (rd->new_label_entry));
783 gtk_tree_model_get_iter (model, &iter, rows->data);
785 gtk_list_store_set (rd->var_map, &iter,
786 COL_NEW_NAME, dest_var_name,
787 COL_NEW_LABEL, dest_var_label,
790 g_list_foreach (rows, (GFunc) gtk_tree_path_free, NULL);
795 /* If there's nothing selected in the variable treeview,
796 then automatically select the first item */
798 select_something (GtkTreeModel *treemodel,
803 struct recode_dialog *rd = data;
804 GtkTreeSelection *sel;
806 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (rd->variable_treeview));
808 if ( gtk_tree_selection_count_selected_rows (sel) < 1)
812 gtk_tree_model_get_iter_first (treemodel, &iter);
814 gtk_tree_selection_select_iter (sel, &iter);
819 /* Callback for the new_value_entry and new_value_togglebutton widgets.
820 It's used to enable/disable the acr. */
822 set_acr (struct recode_dialog *rd)
826 if ( !gtk_toggle_button_get_active
827 (GTK_TOGGLE_BUTTON (rd->toggle[BUTTON_NEW_VALUE])))
829 psppire_acr_set_enabled (rd->acr, TRUE);
833 text = gtk_entry_get_text (GTK_ENTRY (rd->new_value_entry));
835 psppire_acr_set_enabled (rd->acr, !g_str_equal (text, ""));
839 recode_dialog (struct data_editor *de, gboolean diff)
843 struct recode_dialog rd;
845 GladeXML *xml = XML_NEW ("recode.glade");
848 GtkWidget *selector = get_widget_assert (xml, "psppire-selector1");
850 GtkWidget *oldandnew = get_widget_assert (xml, "button1");
853 GtkWidget *output_variable_box = get_widget_assert (xml,"frame4");
856 PsppireVarStore *vs = NULL;
858 g_object_get (de->data_editor, "var-store", &vs, NULL);
860 rd.change_button = get_widget_assert (xml, "change-button");
862 rd.dialog = get_widget_assert (xml, "recode-dialog");
863 rd.dict_treeview = get_widget_assert (xml, "treeview1");
864 rd.variable_treeview = get_widget_assert (xml, "treeview2");
865 rd.new_name_entry = get_widget_assert (xml, "dest-name-entry");
866 rd.new_label_entry = get_widget_assert (xml, "dest-label-entry");
870 rd.value_map = gtk_list_store_new (2,
871 old_value_get_type (),
872 new_value_get_type ()
875 g_object_set (output_variable_box, "visible", diff, NULL);
878 gtk_window_set_title (GTK_WINDOW (rd.dialog),
879 _("Recode into Different Variables"));
881 gtk_window_set_title (GTK_WINDOW (rd.dialog),
882 _("Recode into Same Variables"));
886 gtk_window_set_transient_for (GTK_WINDOW (rd.dialog), de->parent.window);
889 attach_dictionary_to_treeview (GTK_TREE_VIEW (rd.dict_treeview),
891 GTK_SELECTION_MULTIPLE, NULL);
894 if ( ! rd.different )
896 set_dest_model (GTK_TREE_VIEW (rd.variable_treeview), vs->dict);
900 GtkTreeSelection *sel;
901 GtkTreeViewColumn *col;
902 GtkCellRenderer *renderer = gtk_cell_renderer_text_new ();
904 rd.var_map = gtk_list_store_new (n_COL_VARS, G_TYPE_INT,
910 gtk_tree_view_set_model (GTK_TREE_VIEW (rd.variable_treeview),
911 GTK_TREE_MODEL (rd.var_map));
913 col = gtk_tree_view_column_new_with_attributes (_("Old"),
918 gtk_tree_view_column_set_cell_data_func (col, renderer,
923 gtk_tree_view_append_column (GTK_TREE_VIEW (rd.variable_treeview), col);
926 renderer = gtk_cell_renderer_text_new ();
928 col = gtk_tree_view_column_new_with_attributes (_("New"),
933 gtk_tree_view_column_set_cell_data_func (col, renderer,
938 gtk_tree_view_append_column (GTK_TREE_VIEW (rd.variable_treeview), col);
940 g_object_set (rd.variable_treeview, "headers-visible", TRUE, NULL);
942 g_signal_connect (rd.change_button, "clicked",
943 G_CALLBACK (on_change_clicked), &rd);
945 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (rd.variable_treeview));
946 g_signal_connect (sel, "changed",
947 G_CALLBACK (on_selection_change), &rd);
949 g_signal_connect (rd.var_map, "row-inserted",
950 G_CALLBACK (select_something), &rd);
955 psppire_selector_set_subjects (PSPPIRE_SELECTOR (selector),
957 rd.variable_treeview,
958 insert_source_row_into_tree_view,
962 psppire_selector_set_allow (PSPPIRE_SELECTOR (selector), homogeneous_types);
964 /* Set up the Old & New Values subdialog */
966 rd.string_button = get_widget_assert (xml, "checkbutton1");
967 rd.width_entry = get_widget_assert (xml, "spinbutton1");
969 rd.convert_button = get_widget_assert (xml, "checkbutton2");
971 rd.ov_range_lower_entry = get_widget_assert (xml, "entry5");
972 rd.ov_range_upper_entry = get_widget_assert (xml, "entry3");
973 rd.ov_low_up_entry = get_widget_assert (xml, "entry6");
974 rd.ov_high_down_entry = get_widget_assert (xml, "entry7");
976 rd.new_value_entry = get_widget_assert (xml, "entry1");
977 rd.ov_value_entry = get_widget_assert (xml, "entry2");
979 rd.toggle[BUTTON_NEW_VALUE] = get_widget_assert (xml, "radiobutton1");
980 rd.toggle[BUTTON_NEW_SYSMIS] = get_widget_assert (xml, "radiobutton2");
981 rd.toggle[BUTTON_NEW_COPY] = get_widget_assert (xml, "radiobutton3");
982 rd.toggle[BUTTON_OLD_VALUE] = get_widget_assert (xml, "radiobutton4");
983 rd.toggle[BUTTON_OLD_SYSMIS] = get_widget_assert (xml, "radiobutton6");
984 rd.toggle[BUTTON_OLD_MISSING]= get_widget_assert (xml, "radiobutton7");
985 rd.toggle[BUTTON_OLD_RANGE] = get_widget_assert (xml, "radiobutton8");
986 rd.toggle[BUTTON_OLD_LOW_UP] = get_widget_assert (xml, "radiobutton10");
987 rd.toggle[BUTTON_OLD_HIGH_DOWN] = get_widget_assert (xml, "radiobutton5");
988 rd.toggle[BUTTON_OLD_ELSE] = get_widget_assert (xml, "radiobutton11");
990 rd.new_copy_label = get_widget_assert (xml, "label3");
991 rd.strings_box = get_widget_assert (xml, "table3");
993 rd.old_and_new_dialog =
994 PSPPIRE_DIALOG (get_widget_assert (xml, "old-new-values-dialog"));
996 gtk_window_set_transient_for (GTK_WINDOW (rd.old_and_new_dialog),
999 rd.acr = PSPPIRE_ACR (get_widget_assert (xml, "psppire-acr1"));
1001 g_signal_connect_swapped (rd.toggle[BUTTON_NEW_VALUE], "toggled",
1002 G_CALLBACK (set_acr), &rd);
1004 g_signal_connect_swapped (rd.new_value_entry, "changed",
1005 G_CALLBACK (set_acr), &rd);
1008 GtkTreeSelection *sel;
1009 /* Remove the ACR's default column. We don't like it */
1010 GtkTreeViewColumn *column = gtk_tree_view_get_column (rd.acr->tv, 0);
1011 gtk_tree_view_remove_column (rd.acr->tv, column);
1015 gtk_tree_view_column_new_with_attributes (_("Old"),
1016 gtk_cell_renderer_text_new (),
1020 gtk_tree_view_append_column (rd.acr->tv, column);
1023 gtk_tree_view_column_new_with_attributes (_("New"),
1024 gtk_cell_renderer_text_new (),
1028 gtk_tree_view_append_column (rd.acr->tv, column);
1029 g_object_set (rd.acr->tv, "headers-visible", TRUE, NULL);
1032 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (rd.acr->tv));
1033 g_signal_connect (sel, "changed",
1034 G_CALLBACK (on_acr_selection_change), &rd);
1038 g_signal_connect_swapped (oldandnew, "clicked",
1039 G_CALLBACK (run_old_and_new_dialog), &rd);
1042 g_signal_connect (rd.toggle[BUTTON_NEW_VALUE], "toggled",
1043 G_CALLBACK (toggle_sensitivity), rd.new_value_entry);
1045 g_signal_connect (rd.toggle[BUTTON_OLD_VALUE], "toggled",
1046 G_CALLBACK (toggle_sensitivity), rd.ov_value_entry);
1048 g_signal_connect (rd.toggle[BUTTON_OLD_RANGE], "toggled",
1049 G_CALLBACK (toggle_sensitivity),
1050 get_widget_assert (xml, "entry3"));
1052 g_signal_connect (rd.toggle[BUTTON_OLD_RANGE], "toggled",
1053 G_CALLBACK (toggle_sensitivity),
1054 get_widget_assert (xml, "entry5"));
1056 g_signal_connect (rd.toggle[BUTTON_OLD_LOW_UP], "toggled",
1057 G_CALLBACK (toggle_sensitivity), rd.ov_low_up_entry);
1059 g_signal_connect (rd.toggle[BUTTON_OLD_HIGH_DOWN], "toggled",
1060 G_CALLBACK (toggle_sensitivity), rd.ov_high_down_entry);
1062 g_signal_connect (rd.string_button, "toggled",
1063 G_CALLBACK (toggle_sensitivity), rd.width_entry);
1065 g_signal_connect (rd.string_button, "toggled",
1066 G_CALLBACK (on_string_toggled), &rd);
1068 g_signal_connect (rd.convert_button, "toggled",
1069 G_CALLBACK (on_convert_toggled), &rd);
1071 g_signal_connect_swapped (rd.old_and_new_dialog, "show",
1072 G_CALLBACK (on_old_new_show), &rd);
1075 g_signal_connect (rd.dialog, "refresh", G_CALLBACK (refresh), &rd);
1078 psppire_dialog_set_valid_predicate (PSPPIRE_DIALOG (rd.dialog),
1079 dialog_state_valid, &rd);
1081 response = psppire_dialog_run (PSPPIRE_DIALOG (rd.dialog));
1085 case GTK_RESPONSE_OK:
1087 gchar *syntax = generate_syntax (&rd);
1088 struct getl_interface *sss = create_syntax_string_source (syntax);
1089 execute_syntax (sss);
1094 case PSPPIRE_RESPONSE_PASTE:
1096 gchar *syntax = generate_syntax (&rd);
1098 struct syntax_editor *se =
1099 (struct syntax_editor *) window_create (WINDOW_SYNTAX, NULL);
1101 gtk_text_buffer_insert_at_cursor (se->buffer, syntax, -1);
1111 gtk_list_store_clear (GTK_LIST_STORE (rd.value_map));
1112 g_object_unref (rd.value_map);
1114 g_object_unref (xml);
1117 /* Initialise VAL to reflect the current status of RD */
1119 set_old_value (GValue *val, const struct recode_dialog *rd)
1121 const gchar *text = NULL;
1122 struct old_value ov;
1123 if ( gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON
1124 (rd->toggle [BUTTON_OLD_VALUE])))
1126 text = gtk_entry_get_text (GTK_ENTRY (rd->ov_value_entry));
1127 if ( rd->input_var_is_string )
1129 ov.type = OV_STRING;
1130 ov.v.s = g_strdup (text);
1134 ov.type = OV_NUMERIC;
1135 ov.v.v = g_strtod (text, 0);
1138 else if ( gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON
1139 (rd->toggle [BUTTON_OLD_MISSING])))
1141 ov.type = OV_MISSING;
1143 else if ( gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON
1144 (rd->toggle [BUTTON_OLD_SYSMIS])))
1146 ov.type = OV_SYSMIS;
1148 else if ( gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON
1149 (rd->toggle [BUTTON_OLD_ELSE])))
1153 else if ( gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON
1154 (rd->toggle [BUTTON_OLD_RANGE])))
1157 text = gtk_entry_get_text (GTK_ENTRY (rd->ov_range_lower_entry));
1160 ov.v.range[0] = g_strtod (text, 0);
1162 text = gtk_entry_get_text (GTK_ENTRY (rd->ov_range_upper_entry));
1163 ov.v.range[1] = g_strtod (text, 0);
1165 else if ( gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON
1166 (rd->toggle [BUTTON_OLD_LOW_UP])))
1169 gtk_entry_get_text (GTK_ENTRY (rd->ov_low_up_entry));
1171 ov.type = OV_LOW_UP;
1172 ov.v.range[1] = g_strtod (text, 0);
1174 else if ( gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON
1175 (rd->toggle [BUTTON_OLD_HIGH_DOWN])))
1178 gtk_entry_get_text (GTK_ENTRY (rd->ov_high_down_entry));
1180 ov.type = OV_HIGH_DOWN;
1181 ov.v.range[0] = g_strtod (text, 0);
1186 g_value_init (val, old_value_get_type ());
1187 g_value_set_boxed (val, &ov);
1193 /* Initialse VAL to reflect the current status of RD */
1195 set_new_value (GValue *val, const struct recode_dialog *rd)
1197 const gchar *text = NULL;
1198 struct new_value nv;
1200 if ( gtk_toggle_button_get_active
1201 (GTK_TOGGLE_BUTTON (rd->toggle [BUTTON_NEW_VALUE])))
1203 text = gtk_entry_get_text (GTK_ENTRY (rd->new_value_entry));
1205 nv.type = NV_NUMERIC;
1207 (! rd->different && rd->input_var_is_string) ||
1209 gtk_toggle_button_get_active
1210 (GTK_TOGGLE_BUTTON (rd->string_button)))
1213 nv.type = NV_STRING;
1216 if ( nv.type == NV_STRING )
1217 nv.v.s = g_strdup (text);
1219 nv.v.v = g_strtod (text, 0);
1221 else if ( gtk_toggle_button_get_active
1222 (GTK_TOGGLE_BUTTON (rd->toggle [BUTTON_NEW_COPY])))
1227 else if ( gtk_toggle_button_get_active
1228 (GTK_TOGGLE_BUTTON (rd->toggle [BUTTON_NEW_SYSMIS])))
1230 nv.type = NV_SYSMIS;
1235 g_value_init (val, new_value_get_type ());
1236 g_value_set_boxed (val, &nv);
1242 /* A function to set a value in a column in the ACR */
1244 set_value (gint col, GValue *val, gpointer data)
1246 struct recode_dialog *rd = data;
1251 set_old_value (val, rd);
1254 set_new_value (val, rd);
1264 run_old_and_new_dialog (struct recode_dialog *rd)
1267 GtkListStore *local_store = clone_list_store (rd->value_map);
1269 psppire_acr_set_model (rd->acr, local_store);
1270 psppire_acr_set_get_value_func (rd->acr, set_value, rd);
1272 gtk_window_set_title (GTK_WINDOW (rd->old_and_new_dialog),
1274 ? _("Recode into Different Variables: Old and New Values ")
1275 : _("Recode into Same Variables: Old and New Values")
1280 /* Find the type of the first variable (it's invariant that
1281 all variables are of the same type) */
1282 const struct variable *v;
1285 GtkTreeModel *model =
1286 gtk_tree_view_get_model (GTK_TREE_VIEW (rd->variable_treeview));
1288 gboolean not_empty = gtk_tree_model_get_iter_first (model, &iter);
1290 g_return_if_fail (not_empty);
1292 gtk_tree_model_get (model, &iter, 0, &idx, -1);
1294 v = psppire_dict_get_variable (rd->dict, idx);
1296 rd->input_var_is_string = var_is_alpha (v);
1298 gtk_widget_set_sensitive (rd->toggle [BUTTON_OLD_SYSMIS],
1299 var_is_numeric (v));
1300 gtk_widget_set_sensitive (rd->toggle [BUTTON_OLD_RANGE],
1301 var_is_numeric (v));
1302 gtk_widget_set_sensitive (rd->toggle [BUTTON_OLD_LOW_UP],
1303 var_is_numeric (v));
1304 gtk_widget_set_sensitive (rd->toggle [BUTTON_OLD_HIGH_DOWN],
1305 var_is_numeric (v));
1306 gtk_widget_set_sensitive (rd->toggle [BUTTON_NEW_SYSMIS],
1307 var_is_numeric (v));
1309 gtk_widget_set_sensitive (rd->convert_button, var_is_alpha (v));
1313 response = psppire_dialog_run (rd->old_and_new_dialog);
1314 psppire_acr_set_model (rd->acr, NULL);
1317 if ( response == PSPPIRE_RESPONSE_CONTINUE )
1319 g_object_unref (rd->value_map);
1320 rd->value_map = clone_list_store (local_store);
1323 g_object_unref (local_store);
1326 psppire_dialog_notify_change (PSPPIRE_DIALOG (rd->dialog));
1330 /* Generate a syntax fragment for NV and append it to STR */
1332 new_value_append_syntax (GString *str, const struct new_value *nv)
1337 g_string_append_printf (str, "%g", nv->v.v);
1341 struct string ds = DS_EMPTY_INITIALIZER;
1342 syntax_gen_string (&ds, ss_cstr (nv->v.s));
1343 g_string_append (str, ds_cstr (&ds));
1348 g_string_append (str, "COPY");
1351 g_string_append (str, "SYSMIS");
1354 /* Shouldn't ever happen */
1355 g_warning ("Invalid type in new recode value");
1356 g_string_append (str, "???");
1362 /* Generate a syntax fragment for NV and append it to STR */
1364 old_value_append_syntax (GString *str, const struct old_value *ov)
1369 g_string_append_printf (str, "%g", ov->v.v);
1373 struct string ds = DS_EMPTY_INITIALIZER;
1374 syntax_gen_string (&ds, ss_cstr (ov->v.s));
1375 g_string_append (str, ds_cstr (&ds));
1380 g_string_append (str, "MISSING");
1383 g_string_append (str, "SYSMIS");
1386 g_string_append (str, "ELSE");
1389 g_string_append_printf (str, "%g THRU %g",
1394 g_string_append_printf (str, "LOWEST THRU %g",
1398 g_string_append_printf (str, "%g THRU HIGHEST",
1402 g_warning ("Invalid type in old recode value");
1403 g_string_append (str, "???");
1411 generate_syntax (const struct recode_dialog *rd)
1417 GString *str = g_string_sized_new (100);
1419 /* Declare new string variables if applicable */
1420 if ( rd->different &&
1421 gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (rd->string_button)))
1426 for (ok = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (rd->var_map),
1429 ok = gtk_tree_model_iter_next (GTK_TREE_MODEL (rd->var_map), &iter))
1433 gtk_tree_model_get (GTK_TREE_MODEL (rd->var_map), &iter,
1434 COL_NEW_NAME, &name, -1);
1436 g_string_append (str, "\nSTRING ");
1437 g_string_append (str, name);
1438 g_string_append_printf (str, " (A%d).",
1440 gtk_spin_button_get_value (GTK_SPIN_BUTTON (rd->width_entry) )
1447 g_string_append (str, "\nRECODE ");
1449 append_variable_names (str, rd->dict, GTK_TREE_VIEW (rd->variable_treeview), 0);
1451 g_string_append (str, "\n\t");
1453 if ( gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (rd->convert_button)))
1455 g_string_append (str, "(CONVERT) ");
1458 for (ok = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (rd->value_map),
1461 ok = gtk_tree_model_iter_next (GTK_TREE_MODEL (rd->value_map), &iter))
1463 GValue ov_value = {0};
1464 GValue nv_value = {0};
1465 struct old_value *ov;
1466 struct new_value *nv;
1467 gtk_tree_model_get_value (GTK_TREE_MODEL (rd->value_map), &iter,
1468 COL_VALUE_OLD, &ov_value);
1470 gtk_tree_model_get_value (GTK_TREE_MODEL (rd->value_map), &iter,
1471 COL_VALUE_NEW, &nv_value);
1473 ov = g_value_get_boxed (&ov_value);
1474 nv = g_value_get_boxed (&nv_value);
1476 g_string_append (str, "(");
1478 old_value_append_syntax (str, ov);
1479 g_string_append (str, " = ");
1480 new_value_append_syntax (str, nv);
1482 g_string_append (str, ") ");
1483 g_value_unset (&ov_value);
1484 g_value_unset (&nv_value);
1488 if ( rd->different )
1491 g_string_append (str, "\n\tINTO ");
1493 for (ok = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (rd->var_map),
1496 ok = gtk_tree_model_iter_next (GTK_TREE_MODEL (rd->var_map), &iter))
1500 gtk_tree_model_get (GTK_TREE_MODEL (rd->var_map), &iter,
1501 COL_NEW_NAME, &name, -1);
1503 g_string_append (str, name);
1504 g_string_append (str, " ");
1510 g_string_append (str, ".");
1513 /* If applicable, set labels for the new variables. */
1514 if ( rd->different )
1518 for (ok = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (rd->var_map),
1521 ok = gtk_tree_model_iter_next (GTK_TREE_MODEL (rd->var_map), &iter))
1524 gchar *label = NULL;
1527 gtk_tree_model_get (GTK_TREE_MODEL (rd->var_map), &iter,
1528 COL_NEW_NAME, &name,
1529 COL_NEW_LABEL, &label, -1);
1531 if ( 0 == strcmp (label, "") )
1538 ds_init_empty (&ls);
1539 syntax_gen_string (&ls, ss_cstr (label));
1542 g_string_append_printf (str, "\nVARIABLE LABELS %s %s.",
1543 name, ds_cstr (&ls));
1551 g_string_append (str, "\nEXECUTE.\n");
1556 g_string_free (str, FALSE);