Merge 'master' into 'gtk3'.
[pspp] / src / ui / gui / psppire-value-entry.c
1 /* PSPPIRE - a graphical user interface for PSPP.
2    Copyright (C) 2012 Free Software Foundation, Inc.
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 #include "psppire-value-entry.h"
19 #include "data/data-in.h"
20 #include "data/value-labels.h"
21 #include "data/variable.h"
22 #include "libpspp/cast.h"
23 #include "libpspp/i18n.h"
24 #include "ui/gui/helper.h"
25 #include "ui/gui/psppire-format.h"
26
27 static void psppire_value_entry_finalize (GObject *);
28
29 G_DEFINE_TYPE (PsppireValueEntry,
30                psppire_value_entry,
31                GTK_TYPE_COMBO_BOX);
32
33 enum
34   {
35     COL_LABEL,                  /* Value label string. */
36     COL_VALUE,                  /* union value *. */
37     N_COLUMNS
38   };
39
40 enum
41   {
42     PROP_0,
43     PROP_SHOW_VALUE_LABEL,
44     PROP_VARIABLE,
45     PROP_VALUE_LABELS,
46     PROP_FORMAT,
47     PROP_ENCODING,
48     PROP_WIDTH
49   };
50
51 static void
52 psppire_value_entry_set_property (GObject      *object,
53                                   guint         prop_id,
54                                   const GValue *value,
55                                   GParamSpec   *pspec)
56 {
57   PsppireValueEntry *obj = PSPPIRE_VALUE_ENTRY (object);
58
59   switch (prop_id)
60     {
61     case PROP_SHOW_VALUE_LABEL:
62       psppire_value_entry_set_show_value_label (obj,
63                                                 g_value_get_boolean (value));
64       break;
65
66     case PROP_VARIABLE:
67       psppire_value_entry_set_variable (obj, g_value_get_pointer (value));
68       break;
69
70     case PROP_VALUE_LABELS:
71       psppire_value_entry_set_value_labels (obj, g_value_get_pointer (value));
72       break;
73
74     case PROP_FORMAT:
75       psppire_value_entry_set_format (obj, g_value_get_boxed (value));
76       break;
77
78     case PROP_ENCODING:
79       psppire_value_entry_set_encoding (obj, g_value_get_string (value));
80       break;
81
82     case PROP_WIDTH:
83       psppire_value_entry_set_width (obj, g_value_get_int (value));
84       break;
85
86     default:
87       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
88       break;
89     }
90 }
91
92 static void
93 psppire_value_entry_get_property (GObject      *object,
94                                   guint         prop_id,
95                                   GValue       *value,
96                                   GParamSpec   *pspec)
97 {
98   PsppireValueEntry *obj = PSPPIRE_VALUE_ENTRY (object);
99
100   switch (prop_id)
101     {
102     case PROP_SHOW_VALUE_LABEL:
103       g_value_set_boolean (value,
104                            psppire_value_entry_get_show_value_label (obj));
105       break;
106
107     case PROP_VARIABLE:
108       g_return_if_reached ();
109
110     case PROP_VALUE_LABELS:
111       g_value_set_pointer (value, obj->val_labs);
112       break;
113
114     case PROP_FORMAT:
115       g_value_set_boxed (value, &obj->format);
116       break;
117
118     case PROP_ENCODING:
119       g_value_set_string (value, psppire_value_entry_get_encoding (obj));
120       break;
121
122     case PROP_WIDTH:
123       g_value_set_int (value, psppire_value_entry_get_width (obj));
124       break;
125
126     default:
127       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
128       break;
129     }
130 }
131
132 static void
133 psppire_value_entry_text_changed (GtkEntryBuffer *buffer,
134                                   GParamSpec *pspec,
135                                   PsppireValueEntry *obj)
136 {
137   obj->cur_value = NULL;
138 }
139
140
141 static void
142 on_realize (GtkWidget *w)
143 {
144   GtkEntry *entry = GTK_ENTRY (gtk_bin_get_child (GTK_BIN (w)));
145   GtkEntryBuffer *buffer = gtk_entry_get_buffer (entry);
146
147   gtk_combo_box_set_entry_text_column (GTK_COMBO_BOX (w), COL_LABEL);
148   
149   g_signal_connect (buffer, "notify::text",
150                     G_CALLBACK (psppire_value_entry_text_changed), w);
151
152   GTK_WIDGET_CLASS (psppire_value_entry_parent_class)->realize (w);
153 }
154
155 static void
156 psppire_value_entry_class_init (PsppireValueEntryClass *class)
157 {
158   GObjectClass *gobject_class = G_OBJECT_CLASS (class);
159   GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (class);
160
161
162   gobject_class->finalize = psppire_value_entry_finalize;
163   gobject_class->set_property = psppire_value_entry_set_property;
164   gobject_class->get_property = psppire_value_entry_get_property;
165   widget_class->realize = on_realize;
166
167   g_object_class_install_property (
168     gobject_class, PROP_SHOW_VALUE_LABEL,
169     g_param_spec_boolean ("show-value-label",
170                           "Show Value Label",
171                           "If true, a value that has a value label is shown "
172                           "as the label.  If false, all values are shown "
173                           "literally.",
174                           TRUE,
175                           G_PARAM_WRITABLE | G_PARAM_READABLE));
176
177   g_object_class_install_property (
178     gobject_class, PROP_VARIABLE,
179     g_param_spec_pointer ("variable",
180                           "Variable",
181                           "Set to configure the PsppireValueEntry according "
182                           "to the specified variable's value labels, format, "
183                           "width, and encoding.",
184                           G_PARAM_WRITABLE));
185
186   g_object_class_install_property (
187     gobject_class, PROP_VALUE_LABELS,
188     g_param_spec_pointer ("value-labels",
189                           "Value Labels",
190                           "The set of value labels from which the user may "
191                           "choose and which is used to display the value (if "
192                           "value labels are to be displayed)",
193                           G_PARAM_READABLE | G_PARAM_WRITABLE));
194
195   g_object_class_install_property (
196     gobject_class, PROP_FORMAT,
197     g_param_spec_boxed ("format",
198                         "Format",
199                         "The format used to display values (that are not "
200                         "displayed as value labels) and to interpret values "
201                         "entered.",
202                         PSPPIRE_TYPE_FORMAT,
203                         G_PARAM_READABLE | G_PARAM_WRITABLE));
204
205   g_object_class_install_property (
206     gobject_class, PROP_ENCODING,
207     g_param_spec_string ("encoding",
208                          "Encoding",
209                          "The encoding (e.g. \"UTF-8\") for string values.  "
210                          "For numeric values this setting has no effect.",
211                          "UTF-8",
212                          G_PARAM_READABLE | G_PARAM_WRITABLE));
213
214   g_object_class_install_property (
215     gobject_class, PROP_WIDTH,
216     g_param_spec_int ("width",
217                       "Width",
218                       "Width of the value, either 0 for a numeric value or "
219                       "a positive integer count of bytes for string values.",
220                       0, MAX_STRING,
221                       0,
222                       G_PARAM_READABLE | G_PARAM_WRITABLE));
223 }
224
225 static void
226 psppire_value_entry_init (PsppireValueEntry *obj)
227 {
228   obj->show_value_label = true;
229   obj->val_labs = NULL;
230   obj->format = F_8_0;
231   obj->encoding = NULL;
232   obj->cur_value = NULL;
233 }
234
235 static void
236 psppire_value_entry_finalize (GObject *gobject)
237 {
238   PsppireValueEntry *obj = PSPPIRE_VALUE_ENTRY (gobject);
239
240   val_labs_destroy (obj->val_labs);
241   g_free (obj->encoding);
242
243   G_OBJECT_CLASS (psppire_value_entry_parent_class)->finalize (gobject);
244 }
245
246 GtkWidget *
247 psppire_value_entry_new (void)
248 {
249   return GTK_WIDGET (g_object_new (PSPPIRE_TYPE_VALUE_ENTRY, "has-entry", TRUE, NULL));
250 }
251
252 static void
253 psppire_value_entry_refresh_model (PsppireValueEntry *obj)
254 {
255   GtkTreeModel *model;
256   GtkTreeModel *old_model;
257
258   if (val_labs_count (obj->val_labs) > 0)
259     {
260       const struct val_lab **vls = val_labs_sorted (obj->val_labs);
261       size_t n_vls = val_labs_count (obj->val_labs);
262
263       GtkListStore *list_store;
264       size_t i;
265
266       list_store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_POINTER);
267       model = GTK_TREE_MODEL (list_store);
268       for (i = 0; i < n_vls; i++)
269         {
270           const struct val_lab *vl = vls[i];
271           GtkTreeIter iter;
272
273           gtk_list_store_append (list_store, &iter);
274           gtk_list_store_set (list_store, &iter,
275                               COL_LABEL, val_lab_get_label (vl),
276                               COL_VALUE, val_lab_get_value (vl),
277                               -1);
278         }
279       free (vls);
280     }
281   else
282     model = NULL;
283
284   old_model = gtk_combo_box_get_model (GTK_COMBO_BOX (obj));
285
286   if (old_model != model)
287     {
288       GtkEntry *entry = GTK_ENTRY (gtk_bin_get_child (GTK_BIN (obj)));
289       gtk_entry_set_text (entry, "");
290     }
291
292   gtk_combo_box_set_model (GTK_COMBO_BOX (obj), model);
293   if (model != NULL)
294     g_object_unref (model);
295 }
296
297 void
298 psppire_value_entry_set_show_value_label (PsppireValueEntry *obj,
299                                           gboolean show_value_label)
300 {
301   if (obj->show_value_label != show_value_label)
302     {
303       obj->show_value_label = show_value_label;
304       g_object_notify (G_OBJECT (obj), "show-value-label");
305     }
306 }
307
308 gboolean
309 psppire_value_entry_get_show_value_label (const PsppireValueEntry *obj)
310 {
311   return obj->show_value_label;
312 }
313
314 void
315 psppire_value_entry_set_variable (PsppireValueEntry *obj,
316                                   const struct variable *var)
317 {
318   if (var != NULL)
319     {
320       psppire_value_entry_set_value_labels (obj, var_get_value_labels (var));
321       obj->format = *var_get_print_format (var);
322       psppire_value_entry_set_encoding (obj, var_get_encoding (var));
323     }
324   else
325     psppire_value_entry_set_value_labels (obj, NULL);
326 }
327
328 void
329 psppire_value_entry_set_value_labels (PsppireValueEntry *obj,
330                                       const struct val_labs *val_labs)
331 {
332   if (!val_labs_equal (obj->val_labs, val_labs))
333     {
334       obj->cur_value = NULL;
335
336       val_labs_destroy (obj->val_labs);
337       obj->val_labs = val_labs_clone (val_labs);
338
339       if (val_labs != NULL)
340         {
341           int width = val_labs_get_width (val_labs);
342           if (width != fmt_var_width (&obj->format))
343             obj->format = fmt_default_for_width (width);
344         }
345
346       psppire_value_entry_refresh_model (obj);
347
348       g_object_notify (G_OBJECT (obj), "value-labels");
349     }
350 }
351
352 const struct val_labs *
353 psppire_value_entry_get_value_labels (const PsppireValueEntry *obj)
354 {
355   return obj->val_labs;
356 }
357
358 void
359 psppire_value_entry_set_format (PsppireValueEntry *obj,
360                                 const struct fmt_spec *format)
361 {
362   if (!fmt_equal (format, &obj->format))
363     {
364       obj->cur_value = NULL;
365       obj->format = *format;
366
367       if (obj->val_labs
368           && val_labs_get_width (obj->val_labs) != fmt_var_width (format))
369         psppire_value_entry_set_value_labels (obj, NULL);
370
371       g_object_notify (G_OBJECT (obj), "format");
372     }
373 }
374
375 const struct fmt_spec *
376 psppire_value_entry_get_format (const PsppireValueEntry *obj)
377 {
378   return &obj->format;
379 }
380
381 void
382 psppire_value_entry_set_encoding (PsppireValueEntry *obj,
383                                   const gchar *encoding)
384 {
385   g_free (obj->encoding);
386   obj->encoding = encoding != NULL ? g_strdup (encoding) : NULL;
387
388   g_object_notify (G_OBJECT (obj), "encoding");
389 }
390
391 const gchar *
392 psppire_value_entry_get_encoding (const PsppireValueEntry *obj)
393 {
394   return obj->encoding ? obj->encoding : UTF8;
395 }
396
397 void
398 psppire_value_entry_set_width (PsppireValueEntry *obj, int width)
399 {
400   if (width != fmt_var_width (&obj->format))
401     {
402       struct fmt_spec format = fmt_default_for_width (width);
403       psppire_value_entry_set_format (obj, &format);
404     }
405 }
406
407 int
408 psppire_value_entry_get_width (const PsppireValueEntry *obj)
409 {
410   return fmt_var_width (&obj->format);
411 }
412
413 void
414 psppire_value_entry_set_value (PsppireValueEntry *obj,
415                                const union value *value,
416                                int width)
417 {
418   GtkEntry *entry = GTK_ENTRY (gtk_bin_get_child (GTK_BIN (obj)));
419   gchar *string;
420
421   obj->cur_value = NULL;
422   if (obj->show_value_label)
423     {
424       struct val_lab *vl = val_labs_lookup (obj->val_labs, value);
425       if (vl != NULL)
426         {
427           gtk_entry_set_text (entry, val_lab_get_label (vl));
428           obj->cur_value = val_lab_get_value (vl);
429           return;
430         }
431     }
432
433   string = value_to_text__ (*value, &obj->format, obj->encoding);
434   gtk_entry_set_text (entry, string);
435   g_free (string);
436 }
437
438 gboolean
439 psppire_value_entry_get_value (PsppireValueEntry *obj,
440                                union value *value,
441                                int width)
442 {
443   GtkEntry *entry = GTK_ENTRY (gtk_bin_get_child (GTK_BIN (obj)));
444   GtkTreeIter iter;
445
446   g_return_val_if_fail (fmt_var_width (&obj->format) == width, FALSE);
447
448   if (obj->cur_value)
449     {
450       value_copy (value, obj->cur_value, width);
451       return TRUE;
452     }
453   else if (gtk_combo_box_get_active_iter (GTK_COMBO_BOX (obj), &iter))
454     {
455       union value *v;
456
457       gtk_tree_model_get (gtk_combo_box_get_model (GTK_COMBO_BOX (obj)), &iter,
458                           COL_VALUE, &v,
459                           -1);
460       value_copy (value, v, width);
461       return TRUE;
462     }
463   else
464     {
465       const gchar *new_text;
466
467       new_text = gtk_entry_get_text (entry);
468       return data_in_msg (ss_cstr (new_text), UTF8,
469                           obj->format.type,
470                           value, width, obj->encoding);
471     }
472 }