find-dialog.c: Replace exp10 with our own integer version
[pspp] / src / ui / gui / psppire-var-view.c
1 /* PSPPIRE - a graphical user interface for PSPP.
2    Copyright (C) 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 #include <config.h>
18
19 #include <gtk/gtk.h>
20 #include "psppire-var-view.h"
21 #include "psppire-var-ptr.h"
22 #include "psppire-select-dest.h"
23
24 #include <libpspp/cast.h>
25 #include <libpspp/str.h>
26 #include <data/variable.h>
27
28 #include <gettext.h>
29 #define _(msgid) gettext (msgid)
30 #define N_(msgid) msgid
31
32 static void psppire_var_view_base_finalize (PsppireVarViewClass *, gpointer);
33 static void psppire_var_view_base_init     (PsppireVarViewClass *class);
34 static void psppire_var_view_class_init    (PsppireVarViewClass *class);
35 static void psppire_var_view_init          (PsppireVarView      *var_view);
36
37 /* Returns TRUE iff VV contains the item V.
38    V must be an initialised value containing a
39    PSPPIRE_VAR_PTR_TYPE.
40 */
41 static gboolean
42 var_view_contains_var (PsppireSelectDestWidget *sdm, const GValue *v)
43 {
44   gboolean ok;
45   GtkTreeIter iter;
46   PsppireVarView *vv = PSPPIRE_VAR_VIEW (sdm);
47   g_return_val_if_fail (G_VALUE_HOLDS (v, PSPPIRE_VAR_PTR_TYPE), FALSE);
48
49   for (ok = psppire_var_view_get_iter_first (vv, &iter);
50        ok;
51        ok = psppire_var_view_get_iter_next (vv, &iter))
52     {
53       const struct variable *var = psppire_var_view_get_variable (vv, 0, &iter);
54       if (var == g_value_get_boxed (v))
55         return TRUE;
56     }
57
58   return FALSE;
59 }
60
61 static void
62 model_init (PsppireSelectDestWidgetIface *iface)
63 {
64   iface->contains_var = var_view_contains_var;
65 }
66
67 GType
68 psppire_var_view_get_type (void)
69 {
70   static GType psppire_var_view_type = 0;
71
72   if (!psppire_var_view_type)
73     {
74       static const GTypeInfo psppire_var_view_info =
75       {
76         sizeof (PsppireVarViewClass),
77         (GBaseInitFunc) psppire_var_view_base_init,
78         (GBaseFinalizeFunc) psppire_var_view_base_finalize,
79         (GClassInitFunc)psppire_var_view_class_init,
80         (GClassFinalizeFunc) NULL,
81         NULL,
82         sizeof (PsppireVarView),
83         0,
84         (GInstanceInitFunc) psppire_var_view_init,
85       };
86
87       static const GInterfaceInfo var_view_model_info = {
88         (GInterfaceInitFunc) model_init, /* Fill this in */
89         NULL,
90         NULL
91       };
92
93       psppire_var_view_type =
94         g_type_register_static (GTK_TYPE_TREE_VIEW, "PsppireVarView",
95                                 &psppire_var_view_info, 0);
96
97       g_type_add_interface_static (psppire_var_view_type,
98                                    PSPPIRE_TYPE_SELECT_DEST_WIDGET,
99                                    &var_view_model_info);
100     }
101
102   return psppire_var_view_type;
103 }
104
105 void
106 psppire_var_view_clear (PsppireVarView *vv)
107 {
108   GtkListStore *l = gtk_list_store_newv  (vv->n_cols, vv->cols);
109
110   gtk_tree_view_set_model (GTK_TREE_VIEW (vv), GTK_TREE_MODEL (l));
111 }
112
113
114 static void
115 psppire_var_view_finalize (GObject *object)
116 {
117   PsppireVarView *var_view = PSPPIRE_VAR_VIEW (object);
118   g_free (var_view->nums);
119   g_free (var_view->cols);
120 }
121
122
123
124 /* Properties */
125 enum
126 {
127   PROP_0,
128   PROP_N_COLS
129 };
130
131 /* A (*GtkTreeCellDataFunc) function.
132    This function expects TREEMODEL to hold PSPPIRE_VAR_PTR_TYPE.
133    It renders the name of the variable into CELL.
134 */
135 static void
136 display_cell_var_name (GtkTreeViewColumn *tree_column,
137                        GtkCellRenderer *cell,
138                        GtkTreeModel *treemodel,
139                        GtkTreeIter *iter,
140                        gpointer data)
141 {
142   struct variable *var;
143   GValue value = {0};
144   gint *col = data;
145
146   GtkTreePath *path = gtk_tree_model_get_path (treemodel, iter);
147
148   gtk_tree_model_get_value (treemodel, iter, *col, &value);
149
150   gtk_tree_path_free (path);
151
152   var = g_value_get_boxed (&value);
153
154   g_value_unset (&value);
155
156   g_object_set (cell, "text", var ? var_get_name (var) : "", NULL);
157 }
158
159
160 static void
161 psppire_var_view_get_property (GObject         *object,
162                                guint            prop_id,
163                                GValue          *value,
164                                GParamSpec      *pspec)
165 {
166   PsppireVarView *var_view = PSPPIRE_VAR_VIEW (object);
167
168   switch (prop_id)
169     {
170     case PROP_N_COLS:
171       g_value_set_int (value,  var_view->n_cols);
172       break;
173     default:
174       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
175       break;
176     };
177 }
178
179 static void
180 set_renderers (PsppireVarView *var_view)
181 {
182   gint c;
183   var_view->nums = g_malloc (sizeof *var_view->nums * var_view->n_cols);
184
185   for (c = 0 ; c < var_view->n_cols; ++c)
186     {
187       GtkCellRenderer *renderer = gtk_cell_renderer_text_new ();
188       GtkTreeViewColumn *col = gtk_tree_view_column_new ();
189
190       gchar *label = g_strdup_printf (_("Var%d"), c + 1);
191
192       gtk_tree_view_column_set_min_width (col, 100);
193       gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_FIXED);
194       gtk_tree_view_column_set_resizable (col, TRUE);
195       gtk_tree_view_column_set_title (col, label);
196
197       g_free (label);
198
199       var_view->nums[c] = c;
200
201       gtk_tree_view_column_pack_start (col, renderer, TRUE);
202       gtk_tree_view_column_set_cell_data_func (col, renderer,
203                                                display_cell_var_name,
204                                                &var_view->nums[c], 0);
205
206       gtk_tree_view_append_column (GTK_TREE_VIEW (var_view), col);
207     }
208 }
209
210
211 GtkTreeModel *
212 psppire_var_view_get_current_model (PsppireVarView *vv)
213 {
214   return gtk_tree_view_get_model (GTK_TREE_VIEW (vv));
215 }
216
217 static void
218 psppire_var_view_set_property (GObject         *object,
219                                guint            prop_id,
220                                const GValue    *value,
221                                GParamSpec      *pspec)
222 {
223   PsppireVarView *var_view = PSPPIRE_VAR_VIEW (object);
224
225   switch (prop_id)
226     {
227     case PROP_N_COLS:
228       {
229         gint c;
230         var_view->n_cols = g_value_get_int (value);
231
232         var_view->cols = xrealloc (var_view->cols, sizeof (GType) *  var_view->n_cols);
233
234         for (c = 0 ; c < var_view->n_cols; ++c)
235           var_view->cols[c] = PSPPIRE_VAR_PTR_TYPE;
236
237         set_renderers (var_view);
238
239         psppire_var_view_clear (var_view);
240       }
241       break;
242     default:
243       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
244       break;
245     };
246 }
247
248 static void
249 psppire_var_view_class_init (PsppireVarViewClass *class)
250 {
251   GObjectClass *object_class = G_OBJECT_CLASS (class);
252
253   GParamSpec *n_cols_spec =
254     g_param_spec_int ("n-cols",
255                       "Number of columns",
256                       "The Number of Columns in the Variable View",
257                       1, 20,
258                       1,
259                       G_PARAM_CONSTRUCT_ONLY | G_PARAM_READABLE | G_PARAM_WRITABLE);
260
261
262   object_class->set_property = psppire_var_view_set_property;
263   object_class->get_property = psppire_var_view_get_property;
264
265   g_object_class_install_property (object_class,
266                                    PROP_N_COLS,
267                                    n_cols_spec);
268 }
269
270
271 static void
272 psppire_var_view_base_init (PsppireVarViewClass *class)
273 {
274
275   GObjectClass *object_class = G_OBJECT_CLASS (class);
276
277   object_class->finalize = psppire_var_view_finalize;
278 }
279
280
281
282 static void
283 psppire_var_view_base_finalize (PsppireVarViewClass *class,
284                                  gpointer class_data)
285 {
286 }
287
288
289
290 static void
291 psppire_var_view_init (PsppireVarView *vv)
292 {
293   GtkTreeSelection* selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (vv));
294   vv->cols = 0;
295
296   gtk_tree_selection_set_mode (selection, GTK_SELECTION_MULTIPLE);
297 }
298
299
300 GtkWidget*
301 psppire_var_view_new (void)
302 {
303   return GTK_WIDGET (g_object_new (psppire_var_view_get_type (), NULL));
304 }
305
306
307 gboolean
308 psppire_var_view_get_iter_first (PsppireVarView *vv, GtkTreeIter *iter)
309 {
310   GtkTreeIter dummy;
311   GtkTreeModel *model = gtk_tree_view_get_model (GTK_TREE_VIEW (vv));
312   return gtk_tree_model_get_iter_first (model, iter ? iter : &dummy);
313 }
314
315 gboolean
316 psppire_var_view_get_iter_next (PsppireVarView *vv, GtkTreeIter *iter)
317 {
318   GtkTreeModel *model = gtk_tree_view_get_model (GTK_TREE_VIEW (vv));
319   return gtk_tree_model_iter_next (model, iter);
320 }
321
322 const struct variable *
323 psppire_var_view_get_var_from_model (GtkTreeModel *model, gint column, GtkTreeIter *iter)
324 {
325   const struct variable *var = NULL;
326   GValue value = {0};
327   gtk_tree_model_get_value (model, iter, column, &value);
328
329   if (G_VALUE_TYPE (&value) == PSPPIRE_VAR_PTR_TYPE)
330     var = g_value_get_boxed (&value);
331   else
332     g_critical ("Unsupported type `%s', in variable name treeview.",
333                 G_VALUE_TYPE_NAME (&value));
334
335   g_value_unset (&value);
336
337   return var;
338 }
339
340 const struct variable *
341 psppire_var_view_get_variable (PsppireVarView *vv, gint column, GtkTreeIter *iter)
342 {
343   GtkTreeModel *model = gtk_tree_view_get_model (GTK_TREE_VIEW (vv));
344   return psppire_var_view_get_var_from_model (model, column, iter);
345 }
346
347
348
349 /*
350   Append the names of selected variables to STRING.
351   Returns the number of variables appended.
352 */
353 gint
354 psppire_var_view_append_names (PsppireVarView *vv, gint column, GString *string)
355 {
356   gint n_vars = 0;
357   GtkTreeIter iter;
358
359   if (psppire_var_view_get_iter_first (vv, &iter))
360     {
361       do
362         {
363           const struct variable *var = psppire_var_view_get_variable (vv, column, &iter);
364           g_string_append (string, " ");
365           g_string_append (string, var_get_name (var));
366
367           n_vars++;
368         }
369       while (psppire_var_view_get_iter_next (vv, &iter));
370     }
371
372   return n_vars;
373 }
374
375 /* Return a linked list of struct variables which are
376    contained in VV.
377    The caller is responsible for freeing the returned list.
378    The variables however are owned by their dictionary
379    and should not be freed.
380   */
381 GSList *
382 psppire_var_view_list_names (PsppireVarView *vv, gint column)
383 {
384   GtkTreeIter iter;
385   GSList *list = NULL;
386
387   if (psppire_var_view_get_iter_first (vv, &iter))
388     {
389       do
390         {
391           const struct variable *var = psppire_var_view_get_variable (vv, column, &iter);
392           list = g_slist_prepend (list, CONST_CAST (struct variable *, var));
393         }
394       while (psppire_var_view_get_iter_next (vv, &iter));
395     }
396
397   return list;
398 }
399
400
401 /*
402   Append the names of selected variables to STR
403   Returns the number of variables appended.
404 */
405 gint
406 psppire_var_view_append_names_str (PsppireVarView *vv, gint column, struct string *str)
407 {
408   gint n_vars = 0;
409   GtkTreeIter iter;
410
411   if (psppire_var_view_get_iter_first (vv, &iter))
412     {
413       do
414         {
415           const struct variable *var = psppire_var_view_get_variable (vv, column, &iter);
416           ds_put_cstr (str, " ");
417           ds_put_cstr (str, var_get_name (var));
418
419           n_vars++;
420         }
421       while (psppire_var_view_get_iter_next (vv, &iter));
422     }
423
424   return n_vars;
425 }
426
427
428