find-dialog.c: Replace exp10 with our own integer version
[pspp] / src / ui / gui / psppire-dictview.c
1 /* PSPPIRE - a graphical user interface for PSPP.
2    Copyright (C) 2009, 2010, 2011, 2012, 2013, 2017  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-dictview.h"
21 #include "psppire-dict.h"
22 #include "dict-display.h"
23 #include "psppire-conf.h"
24 #include "options-dialog.h"
25 #include <data/format.h>
26 #include <libpspp/i18n.h>
27 #include "helper.h"
28
29 #include <gettext.h>
30 #define _(msgid) gettext (msgid)
31 #define N_(msgid) msgid
32
33 static void psppire_dict_view_base_finalize (PsppireDictViewClass *, gpointer);
34 static void psppire_dict_view_base_init     (PsppireDictViewClass *class);
35 static void psppire_dict_view_class_init    (PsppireDictViewClass *class);
36 static void psppire_dict_view_init          (PsppireDictView      *dict_view);
37
38 GType
39 psppire_dict_view_get_type (void)
40 {
41   static GType psppire_dict_view_type = 0;
42
43   if (!psppire_dict_view_type)
44     {
45       static const GTypeInfo psppire_dict_view_info =
46       {
47         sizeof (PsppireDictViewClass),
48         (GBaseInitFunc) psppire_dict_view_base_init,
49         (GBaseFinalizeFunc) psppire_dict_view_base_finalize,
50         (GClassInitFunc)psppire_dict_view_class_init,
51         (GClassFinalizeFunc) NULL,
52         NULL,
53         sizeof (PsppireDictView),
54         0,
55         (GInstanceInitFunc) psppire_dict_view_init,
56       };
57
58       psppire_dict_view_type =
59         g_type_register_static (GTK_TYPE_TREE_VIEW, "PsppireDictView",
60                                 &psppire_dict_view_info, 0);
61     }
62
63   return psppire_dict_view_type;
64 }
65
66
67 static void
68 psppire_dict_view_finalize (GObject *object)
69 {
70   PsppireDictView *dict_view = PSPPIRE_DICT_VIEW (object);
71
72   gtk_widget_destroy (dict_view->menu);
73 }
74
75 /* Properties */
76 enum
77 {
78   PROP_0,
79   PROP_DICTIONARY,
80   PROP_PREDICATE,
81   PROP_SELECTION_MODE
82 };
83
84
85
86 /* A GtkTreeModelFilterVisibleFunc to filter lines in the treeview */
87 static gboolean
88 filter_variables (GtkTreeModel *tmodel, GtkTreeIter *titer, gpointer data)
89 {
90   var_predicate_func *predicate = data;
91   struct variable *var;
92   GtkTreeModel *model = NULL;
93   GtkTreeIter iter ;
94   PsppireDict *dict ;
95   GtkTreePath *path ;
96   gint *idx;
97
98   get_base_model (tmodel, titer, &model, &iter);
99
100   dict = PSPPIRE_DICT (model);
101   path = gtk_tree_model_get_path (model, &iter);
102   idx = gtk_tree_path_get_indices (path);
103   var =  psppire_dict_get_variable (dict, *idx);
104
105   gtk_tree_path_free (path);
106
107   return predicate (var);
108 }
109
110 static gint
111 unsorted (GtkTreeModel *model,
112      GtkTreeIter *a,
113      GtkTreeIter *b,
114      gpointer user_data)
115 {
116   const struct variable *var_a;
117   const struct variable *var_b;
118
119
120   gtk_tree_model_get (model, a, DICT_TVM_COL_VAR,  &var_a, -1);
121   gtk_tree_model_get (model, b, DICT_TVM_COL_VAR,  &var_b, -1);
122
123   return compare_var_ptrs_by_dict_index (&var_a, &var_b, NULL);
124 }
125
126 static gint
127 sort_by_name (GtkTreeModel *model,
128      GtkTreeIter *a,
129      GtkTreeIter *b,
130      gpointer user_data)
131 {
132   const struct variable *var_a;
133   const struct variable *var_b;
134
135   gtk_tree_model_get (model, a, DICT_TVM_COL_VAR,  &var_a, -1);
136   gtk_tree_model_get (model, b, DICT_TVM_COL_VAR,  &var_b, -1);
137
138   return g_strcmp0 (var_get_name (var_a), var_get_name (var_b));
139 }
140
141
142 static gint
143 sort_by_label (GtkTreeModel *model,
144      GtkTreeIter *a,
145      GtkTreeIter *b,
146      gpointer user_data)
147 {
148   const struct variable *var_a;
149   const struct variable *var_b;
150
151   gtk_tree_model_get (model, a, DICT_TVM_COL_VAR,  &var_a, -1);
152   gtk_tree_model_get (model, b, DICT_TVM_COL_VAR,  &var_b, -1);
153
154   return g_strcmp0 (var_get_label (var_a), var_get_label (var_b));
155 }
156
157
158 static gint
159 default_sort (GtkTreeModel *model,
160      GtkTreeIter *a,
161      GtkTreeIter *b,
162      gpointer user_data)
163 {
164   int what = -1;
165   psppire_conf_get_enum (psppire_conf_new (), "VariableLists", "sort-order",
166                          PSPP_TYPE_OPTIONS_VAR_ORDER, &what);
167
168   switch (what)
169     {
170     default:
171       return unsorted (model, a, b, user_data);
172       break;
173     case PSPP_OPTIONS_VAR_ORDER_NAME:
174       return sort_by_name (model, a, b, user_data);
175       break;
176     case PSPP_OPTIONS_VAR_ORDER_LABEL:
177       return sort_by_label (model, a, b, user_data);
178       break;
179     }
180
181   g_assert_not_reached ();
182 }
183
184
185
186
187 static void
188 set_model (PsppireDictView *dict_view)
189 {
190   GtkTreeModel *model = NULL;
191
192   if (dict_view->dict == NULL)
193     return;
194
195   dict_view->sorted_model = gtk_tree_model_sort_new_with_model (GTK_TREE_MODEL (dict_view->dict));
196   gtk_tree_sortable_set_default_sort_func (GTK_TREE_SORTABLE (dict_view->sorted_model), default_sort, dict_view, 0);
197   gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (dict_view->sorted_model),
198                                         GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, GTK_SORT_ASCENDING);
199
200    if (dict_view->predicate)
201     {
202       model = gtk_tree_model_filter_new (dict_view->sorted_model,        NULL);
203
204       gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER (model),
205                                               filter_variables,
206                                               dict_view->predicate,
207                                               NULL);
208     }
209   else
210     {
211       model = dict_view->sorted_model;
212       g_object_ref (model);
213     }
214
215   gtk_tree_view_set_model (GTK_TREE_VIEW (dict_view), model);
216   g_object_unref (model);
217 }
218
219 static void
220 psppire_dict_view_set_property (GObject         *object,
221                                guint            prop_id,
222                                const GValue    *value,
223                                GParamSpec      *pspec)
224 {
225   PsppireDictView *dict_view = PSPPIRE_DICT_VIEW (object);
226
227   switch (prop_id)
228     {
229     case PROP_DICTIONARY:
230       dict_view->dict = g_value_get_object (value);
231       break;
232     case PROP_PREDICATE:
233       dict_view->predicate = g_value_get_pointer (value);
234       break;
235     case PROP_SELECTION_MODE:
236       {
237         GtkTreeSelection *selection =
238           gtk_tree_view_get_selection (GTK_TREE_VIEW (dict_view));
239
240         GtkSelectionMode mode = g_value_get_enum (value);
241
242         gtk_tree_selection_set_mode (selection, mode);
243       }
244       break;
245     default:
246       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
247       break;
248     };
249
250
251   set_model (dict_view);
252 }
253
254
255 static void
256 psppire_dict_view_get_property (GObject         *object,
257                                guint            prop_id,
258                                GValue          *value,
259                                GParamSpec      *pspec)
260 {
261   PsppireDictView *dict_view = PSPPIRE_DICT_VIEW (object);
262
263   switch (prop_id)
264     {
265     case PROP_DICTIONARY:
266       g_value_set_object (value, dict_view->dict);
267       break;
268     case PROP_PREDICATE:
269       g_value_set_pointer (value, dict_view->predicate);
270       break;
271     case PROP_SELECTION_MODE:
272       {
273         GtkTreeSelection *selection =
274           gtk_tree_view_get_selection (GTK_TREE_VIEW (dict_view));
275
276         g_value_set_enum (value, gtk_tree_selection_get_mode (selection));
277       }
278     default:
279       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
280       break;
281     };
282 }
283
284
285
286 static void
287 psppire_dict_view_class_init (PsppireDictViewClass *class)
288 {
289   GObjectClass *object_class = G_OBJECT_CLASS (class);
290
291   GParamSpec *predicate_spec =
292     g_param_spec_pointer ("predicate",
293                           "Predicate",
294                           "A predicate function",
295                           G_PARAM_READABLE | G_PARAM_WRITABLE);
296
297
298   GParamSpec *selection_mode_spec =
299     g_param_spec_enum ("selection-mode",
300                        "Selection Mode",
301                        "How many things can be selected",
302                        GTK_TYPE_SELECTION_MODE,
303                        GTK_SELECTION_MULTIPLE,
304                        G_PARAM_CONSTRUCT | G_PARAM_READABLE | G_PARAM_WRITABLE);
305
306   object_class->set_property = psppire_dict_view_set_property;
307   object_class->get_property = psppire_dict_view_get_property;
308
309   g_object_class_override_property (object_class,
310                                     PROP_DICTIONARY,
311                                     "model");
312
313   g_object_class_install_property (object_class,
314                                    PROP_PREDICATE,
315                                    predicate_spec);
316
317   g_object_class_install_property (object_class,
318                                    PROP_SELECTION_MODE,
319                                    selection_mode_spec);
320 }
321
322
323 static void
324 psppire_dict_view_base_init (PsppireDictViewClass *class)
325 {
326   GObjectClass *object_class = G_OBJECT_CLASS (class);
327
328   object_class->finalize = psppire_dict_view_finalize;
329 }
330
331
332
333 static void
334 psppire_dict_view_base_finalize (PsppireDictViewClass *class,
335                                  gpointer class_data)
336 {
337
338 }
339
340 static gboolean
341 use_labels (PsppireDictView *dv)
342 {
343   gboolean disp_labels = TRUE;
344
345   if (gtk_check_menu_item_get_inconsistent (GTK_CHECK_MENU_ITEM
346                                             (dv->override_button)))
347     {
348       psppire_conf_get_boolean (psppire_conf_new (),
349                                 "VariableLists", "display-labels", &disp_labels);
350     }
351   else
352     {
353       disp_labels = gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM
354                                                     (dv->override_button));
355     }
356   return disp_labels;
357 }
358
359
360 /* A GtkTreeCellDataFunc which renders the name and/or label of the
361    variable */
362 static void
363 var_description_cell_data_func (GtkTreeViewColumn *col,
364                                 GtkCellRenderer *cell,
365                                 GtkTreeModel *top_model,
366                                 GtkTreeIter *top_iter,
367                                 gpointer data)
368 {
369   PsppireDictView *dv = PSPPIRE_DICT_VIEW (data);
370   struct variable *var;
371   GtkTreeIter iter;
372   GtkTreeModel *model;
373
374   get_base_model (top_model, top_iter, &model, &iter);
375
376   gtk_tree_model_get (model,
377                       &iter, DICT_TVM_COL_VAR, &var, -1);
378
379   if (var_has_label (var) && use_labels (dv))
380     {
381       gchar *text = g_markup_printf_escaped (
382                                      "<span stretch=\"condensed\">%s</span>",
383                                      var_get_label (var));
384
385       g_object_set (cell, "markup", text, NULL);
386       g_free (text);
387     }
388   else
389     {
390       g_object_set (cell, "text", var_get_name (var), NULL);
391     }
392 }
393
394
395
396 /* A GtkTreeCellDataFunc which sets the icon appropriate to the type
397    of variable */
398 static void
399 var_icon_cell_data_func (GtkTreeViewColumn *col,
400                        GtkCellRenderer *cell,
401                        GtkTreeModel *model,
402                        GtkTreeIter *iter,
403                        gpointer data)
404 {
405   struct variable *var;
406
407   gtk_tree_model_get (model, iter, DICT_TVM_COL_VAR, &var, -1);
408
409   g_object_set (cell,
410                 "stock-size", GTK_ICON_SIZE_MENU,
411                 "icon-name", get_var_measurement_stock_id (var_get_print_format (var)->type,
412                                                            var_get_measure (var)),
413                 NULL);
414 }
415
416 const char *
417 get_var_measurement_stock_id (enum fmt_type type, enum measure measure)
418 {
419   switch (fmt_get_category (type))
420     {
421     case FMT_CAT_STRING:
422       switch (measure)
423         {
424         case MEASURE_NOMINAL: return "measure-string-nominal";
425         case MEASURE_ORDINAL: return "measure-string-ordinal";
426         case MEASURE_SCALE:   return "role-none";
427         case n_MEASURES: break;
428         }
429       break;
430
431     case FMT_CAT_DATE:
432     case FMT_CAT_TIME:
433       switch (measure)
434         {
435         case MEASURE_NOMINAL: return "measure-date-nominal";
436         case MEASURE_ORDINAL: return "measure-date-ordinal";
437         case MEASURE_SCALE:   return "measure-date-scale";
438         case n_MEASURES: break;
439         }
440       break;
441
442     default:
443       switch (measure)
444         {
445         case MEASURE_NOMINAL: return "measure-nominal";
446         case MEASURE_ORDINAL: return "measure-ordinal";
447         case MEASURE_SCALE:   return "measure-scale";
448         case n_MEASURES: break;
449         }
450       break;
451     }
452
453   g_return_val_if_reached ("");
454 }
455
456
457
458 /* Sets the tooltip to be the name of the variable under the cursor */
459 static gboolean
460 set_tooltip_for_variable (GtkTreeView  *treeview,
461                           gint        x,
462                           gint        y,
463                           gboolean    keyboard_mode,
464                           GtkTooltip *tooltip,
465                           gpointer    user_data)
466 {
467   gint bx, by;
468   GtkTreeIter iter;
469   GtkTreePath *path;
470   GtkTreeModel *tree_model;
471   struct variable *var = NULL;
472   gboolean ok;
473
474   gtk_tree_view_convert_widget_to_bin_window_coords (treeview,
475                                                      x, y, &bx, &by);
476
477   if (!gtk_tree_view_get_path_at_pos (treeview, bx, by,
478                                       &path, NULL, NULL, NULL))
479     return FALSE;
480
481   tree_model = gtk_tree_view_get_model (treeview);
482
483   gtk_tree_view_set_tooltip_row (treeview, tooltip, path);
484
485   ok = gtk_tree_model_get_iter (tree_model, &iter, path);
486
487   gtk_tree_path_free (path);
488   if (!ok)
489     return FALSE;
490
491
492   gtk_tree_model_get (tree_model, &iter, DICT_TVM_COL_VAR,  &var, -1);
493
494   if (! var_has_label (var))
495     return FALSE;
496
497   {
498     const gchar *tip ;
499     GtkTreeModel *m;
500
501     get_base_model (tree_model, NULL, &m, NULL);
502
503     if (use_labels (PSPPIRE_DICT_VIEW (treeview)))
504       tip = var_get_name (var);
505     else
506       tip = var_get_label (var);
507
508     gtk_tooltip_set_text (tooltip, tip);
509   }
510
511   return TRUE;
512 }
513
514 static gboolean
515 show_menu (PsppireDictView *dv, GdkEvent *event, gpointer data)
516 {
517   if (((GdkEventButton *) event)->button != 3)
518     return FALSE;
519
520   gtk_menu_popup_at_pointer (GTK_MENU (dv->menu), event);
521
522   return TRUE;
523 }
524
525 static void
526 toggle_label_preference (GtkCheckMenuItem *checkbox, gpointer data)
527 {
528   PsppireDictView *dv = PSPPIRE_DICT_VIEW (data);
529
530   gboolean global_setting = TRUE;
531   psppire_conf_get_boolean (psppire_conf_new (),
532                             "VariableLists", "display-labels", &global_setting);
533
534   if (gtk_check_menu_item_get_inconsistent (checkbox))
535     gtk_check_menu_item_set_active (checkbox, !global_setting);
536
537   gtk_check_menu_item_set_inconsistent (checkbox, FALSE);
538
539   gtk_widget_queue_draw (GTK_WIDGET (dv));
540 }
541
542
543 static void
544 set_sort_criteria (GtkCheckMenuItem *checkbox, PsppireDictView *dv, GtkTreeIterCompareFunc func)
545 {
546   if (!gtk_check_menu_item_get_active (checkbox))
547     {
548       gtk_widget_queue_draw (GTK_WIDGET (dv));
549       return;
550     }
551
552
553   gtk_tree_sortable_set_default_sort_func (GTK_TREE_SORTABLE (dv->sorted_model), func, 0, 0);
554
555
556   gtk_widget_queue_draw (GTK_WIDGET (dv));
557 }
558
559 static void
560 set_sort_criteria_default (GtkCheckMenuItem *checkbox, gpointer data)
561 {
562   PsppireDictView *dv = PSPPIRE_DICT_VIEW (data);
563   set_sort_criteria (checkbox, dv, default_sort);
564 }
565
566
567 static void
568 set_sort_criteria_name (GtkCheckMenuItem *checkbox, gpointer data)
569 {
570   PsppireDictView *dv = PSPPIRE_DICT_VIEW (data);
571   set_sort_criteria (checkbox, dv, sort_by_name);
572 }
573
574
575 static void
576 set_sort_criteria_label (GtkCheckMenuItem *checkbox, gpointer data)
577 {
578   PsppireDictView *dv = PSPPIRE_DICT_VIEW (data);
579   set_sort_criteria (checkbox, dv, sort_by_label);
580 }
581
582
583 static void
584 set_sort_criteria_unsorted (GtkCheckMenuItem *checkbox, gpointer data)
585 {
586   PsppireDictView *dv = PSPPIRE_DICT_VIEW (data);
587   set_sort_criteria (checkbox, dv, unsorted);
588 }
589
590
591
592 static void
593 psppire_dict_view_init (PsppireDictView *dict_view)
594 {
595   GtkTreeViewColumn *col = gtk_tree_view_column_new ();
596
597   GtkCellRenderer *renderer = gtk_cell_renderer_pixbuf_new ();
598
599   dict_view->prefer_labels_override = FALSE;
600   dict_view->sorted_model = NULL;
601
602   gtk_tree_view_column_set_title (col, _("Variable"));
603
604   gtk_tree_view_column_pack_start (col, renderer, FALSE);
605
606   gtk_tree_view_column_set_cell_data_func (col, renderer,
607                                            var_icon_cell_data_func,
608                                            NULL, NULL);
609
610   renderer = gtk_cell_renderer_text_new ();
611   gtk_tree_view_column_pack_start (col, renderer, TRUE);
612   gtk_tree_view_column_set_cell_data_func (col, renderer,
613                                            var_description_cell_data_func,
614                                            dict_view, NULL);
615
616   g_object_set (renderer, "ellipsize-set", TRUE, NULL);
617   g_object_set (renderer, "ellipsize", PANGO_ELLIPSIZE_MIDDLE, NULL);
618
619   gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_FIXED);
620
621   /* FIXME: make this a value in terms of character widths */
622   gtk_tree_view_column_set_min_width (col, 150);
623
624   gtk_tree_view_append_column (GTK_TREE_VIEW (dict_view), col);
625
626   g_object_set (dict_view,
627                 "has-tooltip", TRUE,
628                 "headers-visible", FALSE,
629                 NULL);
630
631   g_signal_connect (dict_view, "query-tooltip",
632                     G_CALLBACK (set_tooltip_for_variable), NULL);
633
634   dict_view->menu = gtk_menu_new ();
635
636   {
637     GSList *group = NULL;
638     GtkWidget *item =
639       gtk_check_menu_item_new_with_label  (_("Prefer variable labels"));
640
641     dict_view->override_button = item;
642     gtk_check_menu_item_set_inconsistent (GTK_CHECK_MENU_ITEM (item),
643                                           TRUE);
644
645     g_signal_connect (item, "toggled",
646                       G_CALLBACK (toggle_label_preference), dict_view);
647
648     gtk_menu_shell_append (GTK_MENU_SHELL (dict_view->menu), item);
649
650     item = gtk_separator_menu_item_new ();
651     gtk_menu_shell_append (GTK_MENU_SHELL (dict_view->menu), item);
652
653     item = gtk_radio_menu_item_new_with_label (group, _("Default sort order"));
654     group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (item));
655     gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (item), TRUE);
656     gtk_menu_shell_append (GTK_MENU_SHELL (dict_view->menu), item);
657     g_signal_connect (item, "toggled", G_CALLBACK (set_sort_criteria_default), dict_view);
658
659     item = gtk_radio_menu_item_new_with_label (group, _("Unsorted (dictionary order)"));
660     group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (item));
661     gtk_menu_shell_append (GTK_MENU_SHELL (dict_view->menu), item);
662     g_signal_connect (item, "toggled", G_CALLBACK (set_sort_criteria_unsorted), dict_view);
663
664     item = gtk_radio_menu_item_new_with_label (group, _("Sort by name"));
665     group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (item));
666     gtk_menu_shell_append (GTK_MENU_SHELL (dict_view->menu), item);
667     g_signal_connect (item, "toggled", G_CALLBACK (set_sort_criteria_name), dict_view);
668
669     item = gtk_radio_menu_item_new_with_label (group, _("Sort by label"));
670     group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (item));
671     gtk_menu_shell_append (GTK_MENU_SHELL (dict_view->menu), item);
672     g_signal_connect (item, "toggled", G_CALLBACK (set_sort_criteria_label), dict_view);
673   }
674
675   gtk_widget_show_all (dict_view->menu);
676
677   g_signal_connect (dict_view, "button-press-event",
678                     G_CALLBACK (show_menu), NULL);
679 }
680
681
682 GtkWidget*
683 psppire_dict_view_new (void)
684 {
685   return GTK_WIDGET (g_object_new (psppire_dict_view_get_type (), NULL));
686 }
687
688 static struct variable *
689 psppire_dict_view_iter_to_var (PsppireDictView *dict_view,
690                                GtkTreeIter *top_iter)
691 {
692   GtkTreeView *treeview = GTK_TREE_VIEW (dict_view);
693   GtkTreeModel *top_model = gtk_tree_view_get_model (treeview);
694
695   struct variable *var;
696   GtkTreeModel *model;
697   GtkTreeIter iter;
698
699   get_base_model (top_model, top_iter, &model, &iter);
700
701   g_assert (PSPPIRE_IS_DICT (model));
702
703   gtk_tree_model_get (model,
704                       &iter, DICT_TVM_COL_VAR, &var, -1);
705
706   return var;
707 }
708
709 struct get_vars_aux
710   {
711     PsppireDictView *dict_view;
712     struct variable **vars;
713     size_t idx;
714   };
715
716 static void
717 get_vars_cb (GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter,
718              gpointer data)
719 {
720   struct get_vars_aux *aux = data;
721   struct variable *var = psppire_dict_view_iter_to_var (aux->dict_view, iter);
722
723   g_return_if_fail (var != NULL);
724   aux->vars[aux->idx++] = var;
725 }
726
727 void
728 psppire_dict_view_get_selected_variables (PsppireDictView *dict_view,
729                                           struct variable ***vars,
730                                           size_t *n_varsp)
731 {
732   GtkTreeView *tree_view = GTK_TREE_VIEW (dict_view);
733   GtkTreeSelection *selection = gtk_tree_view_get_selection (tree_view);
734   gint n_vars = gtk_tree_selection_count_selected_rows (selection);
735   struct get_vars_aux aux;
736
737   *vars = g_malloc_n (n_vars, sizeof **vars);
738
739   aux.dict_view = dict_view;
740   aux.vars = *vars;
741   aux.idx = 0;
742   gtk_tree_selection_selected_foreach (selection, get_vars_cb, &aux);
743
744   *n_varsp = aux.idx;
745   g_return_if_fail (aux.idx >= n_vars);
746 }
747
748 struct variable *
749 psppire_dict_view_get_selected_variable (PsppireDictView *dict_view)
750 {
751   GtkTreeView *tree_view = GTK_TREE_VIEW (dict_view);
752   GtkTreeSelection *selection = gtk_tree_view_get_selection (tree_view);
753   GtkTreeIter iter;
754
755   if (gtk_tree_selection_get_selected (selection, NULL, &iter))
756     return psppire_dict_view_iter_to_var (dict_view, &iter);
757   else
758     return NULL;
759 }
760
761