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