Allow adding new variables in the var sheet
[pspp] / src / ui / gui / helper.c
1 /* PSPPIRE - a graphical user interface for PSPP.
2    Copyright (C) 2007, 2009, 2010, 2011, 2012, 2013  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
18 /* This file is a rubbish bin where stuff gets put when it doesn't seem to
19    belong anywhere else.
20 */
21 #include <config.h>
22
23 #include        <glib-object.h>
24
25 #include <glib.h>
26 #include "helper.h"
27 #include <data/format.h>
28 #include <data/data-in.h>
29 #include <data/data-out.h>
30 #include <data/dictionary.h>
31 #include <data/casereader-provider.h>
32 #include <libpspp/message.h>
33 #include "psppire-syntax-window.h"
34 #include <gtk/gtk.h>
35 #include <libpspp/i18n.h>
36
37 #include <ctype.h>
38 #include <string.h>
39 #include <stdlib.h>
40 #include <data/settings.h>
41
42 #include "psppire-data-store.h"
43
44 #include "gl/configmake.h"
45 #include "xalloc.h"
46
47 #include <gettext.h>
48
49 /* Returns a copy of IN with each underscore doubled.  The caller should free
50    the returned string (with free()) when it is no longer needed. */
51 char *
52 escape_underscores (const char *in)
53 {
54   char *out = xmalloc (2 * strlen (in) + 1);
55   char *p;
56
57   p = out;
58   for (; *in != '\0'; in++)
59     {
60       if (*in == '_')
61         *p++ = '_';
62       *p++ = *in;
63     }
64   *p = '\0';
65
66   return out;
67 }
68
69 /* Formats a value according to VAR's print format and strips white space
70    appropriately for VAR's type.  That is, if VAR is numeric, strips leading
71    white space (because numbers are right-justified within their fields), and
72    if VAR is string, strips trailing white space (because spaces pad out string
73    values on the right).
74
75    Returns an allocated string.  The returned string must be freed when no
76    longer required. */
77 gchar *
78 value_to_text (union value v, const struct variable *var)
79 {
80   return value_to_text__ (v, var_get_print_format (var),
81                           var_get_encoding (var));
82 }
83
84 /* Formats a value with format FORMAT and strips white space appropriately for
85    FORMATs' type.  That is, if FORMAT is numeric, strips leading white space
86    (because numbers are right-justified within their fields), and if FORMAT is
87    string, strips trailing white space (because spaces pad out string values on
88    the right).
89
90    Returns an allocated string.  The returned string must be freed when no
91    longer required. */
92 gchar *
93 value_to_text__ (union value v,
94                  const struct fmt_spec *format, const char *encoding)
95 {
96   gchar *s;
97
98   s = data_out_stretchy (&v, encoding, format, NULL);
99   if (fmt_is_numeric (format->type))
100     g_strchug (s);
101   else
102     g_strchomp (s);
103
104   return s;
105 }
106
107 /* Converts TEXT to a value.
108
109    VAL will be initialised and filled by this function.
110    It is the caller's responsibility to destroy VAL when no longer needed.
111    VAR must be the variable with which VAL is associated.
112
113    On success, VAL is returned, NULL otherwise.
114 */
115 union value *
116 text_to_value (const gchar *text,
117                const struct variable *var,
118                union value *val)
119 {
120   return text_to_value__ (text, var_get_print_format (var),
121                           var_get_encoding (var), val);
122 }
123
124 /* Converts TEXT, which contains a value in the given FORMAT encoding in
125    ENCODING, into a value.
126
127    VAL will be initialised and filled by this function.
128    It is the caller's responsibility to destroy VAL when no longer needed.
129
130    On success, VAL is returned, NULL otherwise.
131 */
132 union value *
133 text_to_value__ (const gchar *text,
134                  const struct fmt_spec *format,
135                  const gchar *encoding,
136                  union value *val)
137 {
138   int width = fmt_var_width (format);
139
140   if ( format->type != FMT_A)
141     {
142       if ( ! text ) return NULL;
143
144       {
145         const gchar *s = text;
146         while (*s)
147           {
148             if ( !isspace (*s))
149               break;
150             s++;
151           }
152
153         if ( !*s) return NULL;
154       }
155     }
156
157   value_init (val, width);
158   free (data_in (ss_cstr (text), UTF8, format->type, val, width, encoding));
159
160   return val;
161 }
162
163
164 /* This function must be used whenever a filename generated by glib,
165    (eg, from gtk_file_chooser_get_filename) and passed to the C library,
166    (eg through a pspp syntax string).
167 */
168 gchar *
169 convert_glib_filename_to_system_filename (const gchar *fname, GError **err)
170 {
171   gchar *output_name;
172
173 #ifdef G_OS_WIN32
174   const gchar *target_encoding;
175   gchar *utf8_name = NULL;
176
177   g_get_charset (&target_encoding);
178
179   output_name = g_convert (fname, -1, target_encoding,
180                         "UTF-8", NULL, NULL, err);
181 #else
182   output_name = xstrdup (fname);
183 #endif
184
185   return output_name;
186 }
187
188
189
190 #define _(msgid) gettext (msgid)
191 #define N_(msgid) msgid
192
193
194 static void
195 give_help (void)
196 {
197   GtkWidget *dialog;
198
199   dialog = gtk_message_dialog_new (NULL,
200                                    GTK_DIALOG_MODAL,
201                                    GTK_MESSAGE_INFO,
202                                    GTK_BUTTONS_CLOSE,
203                                    _("Sorry. The help system hasn't yet "
204                                      "been implemented."));
205   gtk_dialog_run (GTK_DIALOG (dialog));
206   gtk_widget_destroy (dialog);
207 }
208
209 void
210 connect_help (GtkBuilder *xml)
211 {
212   GSList *helps = gtk_builder_get_objects (xml);
213
214   GSList *i;
215   for ( i = helps; i ; i = g_slist_next (i))
216     {
217       GObject *o = i->data;
218       if ( GTK_IS_WIDGET (o) )
219         {
220           const gchar *name = gtk_buildable_get_name (GTK_BUILDABLE (o));
221           gchar s[12] = {0};
222
223           if ( name)
224             strncpy (s, name, 11);
225           s[11] = '\0';
226
227
228           if ( 0 == strcmp ("help_button", s))
229             {
230             g_signal_connect (o, "clicked", give_help, 0);
231             }
232         }
233     }
234
235   g_slist_free (helps);
236 }
237
238
239 /* Create a deep copy of SRC */
240 GtkListStore *
241 clone_list_store (const GtkListStore *src)
242 {
243   GtkTreeIter src_iter;
244   gboolean ok;
245   gint i;
246   const gint n_cols =  gtk_tree_model_get_n_columns (GTK_TREE_MODEL (src));
247   GType *types = g_malloc (sizeof (*types) *  n_cols);
248
249   int row = 0;
250   GtkListStore *dest;
251
252   for (i = 0 ; i < n_cols; ++i )
253     types[i] = gtk_tree_model_get_column_type (GTK_TREE_MODEL (src), i);
254
255   dest = gtk_list_store_newv (n_cols, types);
256
257   for (ok = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (src),
258                                            &src_iter);
259        ok;
260        ok = gtk_tree_model_iter_next (GTK_TREE_MODEL (src), &src_iter))
261     {
262       GtkTreeIter dest_iter;
263       gtk_list_store_append  (dest, &dest_iter);
264
265       for (i = 0 ; i < n_cols; ++i )
266         {
267           GValue val = {0};
268
269           gtk_tree_model_get_value (GTK_TREE_MODEL (src), &src_iter, i, &val);
270           gtk_list_store_set_value (dest, &dest_iter, i, &val);
271
272           g_value_unset (&val);
273         }
274       row++;
275     }
276
277   g_free (types);
278
279   return dest;
280 }
281
282
283
284
285 static gboolean 
286 on_delete (GtkWindow *window, GdkEvent *e, GtkWindow **addr)
287 {
288   *addr = NULL;
289
290   return FALSE;
291 }
292
293 char *
294 paste_syntax_to_window (gchar *syntax)
295 {
296   static GtkWidget *the_syntax_pasteboard = NULL;
297
298   GtkTextBuffer *buffer = NULL;
299
300   if ( NULL == the_syntax_pasteboard)
301     {
302       the_syntax_pasteboard = psppire_syntax_window_new (NULL);
303       g_signal_connect (the_syntax_pasteboard, "delete-event", G_CALLBACK (on_delete),
304                         &the_syntax_pasteboard);
305     }
306
307   buffer = GTK_TEXT_BUFFER (PSPPIRE_SYNTAX_WINDOW (the_syntax_pasteboard)->buffer);
308
309   gtk_text_buffer_begin_user_action (buffer);
310   gtk_text_buffer_insert_at_cursor (buffer, syntax, -1);
311   gtk_text_buffer_insert_at_cursor (buffer, "\n", 1);
312   gtk_text_buffer_end_user_action (buffer);
313
314   gtk_widget_show (the_syntax_pasteboard);
315
316   return syntax;
317 }
318
319
320 /* gtk_box_pack_start_defaults is deprecated.
321    Therefore we roll our own until a better solution is found */
322 void
323 psppire_box_pack_start_defaults (GtkBox *box, GtkWidget *widget)
324 {
325   gtk_box_pack_start (box, widget, TRUE, TRUE, 0);
326 }