d665edd62be1872f5cede3a2515f791344145e1f
[pspp-builds.git] / src / ui / gui / dict-display.c
1 /* PSPPIRE - a graphical user interface for PSPP.
2    Copyright (C) 2007  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 #include <config.h>
19 #include <gettext.h>
20 #include <gtk/gtk.h>
21
22 #include "dict-display.h"
23
24 #include "psppire-dict.h"
25 #include "helper.h"
26 #include <data/variable.h>
27
28 #define _(msgid) gettext (msgid)
29 #define N_(msgid) msgid
30
31
32 /* A GtkTreeModelFilterVisibleFunc to filter lines in the treeview */
33 static gboolean
34 filter_variables (GtkTreeModel *model, GtkTreeIter *iter, gpointer data)
35 {
36   var_predicate_func *predicate = data;
37   struct variable *var;
38   PsppireDict *dict = PSPPIRE_DICT (model);
39
40   GtkTreePath *path = gtk_tree_model_get_path (model, iter);
41
42   gint *idx = gtk_tree_path_get_indices (path);
43
44   var =  psppire_dict_get_variable (dict, *idx);
45
46   gtk_tree_path_free (path);
47
48   return predicate (var);
49 }
50
51 /* A GtkTreeCellDataFunc which sets the icon appropriate to the type
52    of variable */
53 static void
54 var_icon_cell_data_func (GtkTreeViewColumn *col,
55                        GtkCellRenderer *cell,
56                        GtkTreeModel *model,
57                        GtkTreeIter *iter,
58                        gpointer data)
59 {
60   struct variable *var;
61   gtk_tree_model_get (model, iter, DICT_TVM_COL_VAR, &var, -1);
62
63   if ( var_is_alpha (var))
64     {
65       g_object_set (cell, "stock-id", "var-string", NULL);
66     }
67   else
68     {
69       const struct fmt_spec *fs = var_get_write_format (var);
70       int cat = fmt_get_category (fs->type);
71       switch ( var_get_measure (var))
72         {
73         case MEASURE_NOMINAL:
74           g_object_set (cell, "stock-id", "var-nominal", NULL);
75           break;
76         case MEASURE_ORDINAL:
77           g_object_set (cell, "stock-id", "var-ordinal", NULL);
78           break;
79         case MEASURE_SCALE:
80           if ( ( FMT_CAT_DATE | FMT_CAT_TIME ) & cat )
81             g_object_set (cell, "stock-id", "var-date-scale", NULL);
82           else
83             g_object_set (cell, "stock-id", "var-scale", NULL);
84           break;
85         default:
86           g_assert_not_reached ();
87         };
88     }
89 }
90
91
92 void
93 get_base_model (GtkTreeModel *top_model, GtkTreeIter *top_iter,
94                 GtkTreeModel **model, GtkTreeIter *iter
95                 )
96 {
97   *model = top_model;
98   *iter = *top_iter;
99   while (GTK_IS_TREE_MODEL_FILTER (*model))
100     {
101       GtkTreeIter parent_iter = *iter;
102       GtkTreeModelFilter *parent_model = GTK_TREE_MODEL_FILTER (*model);
103
104       *model = gtk_tree_model_filter_get_model (parent_model);
105
106       gtk_tree_model_filter_convert_iter_to_child_iter (parent_model,
107                                                         iter,
108                                                         &parent_iter);
109     }
110
111   g_assert (PSPPIRE_IS_DICT (*model));
112 }
113
114 /* A GtkTreeCellDataFunc which renders the name and/or label of the
115    variable */
116 static void
117 var_description_cell_data_func (GtkTreeViewColumn *col,
118                                 GtkCellRenderer *cell,
119                                 GtkTreeModel *top_model,
120                                 GtkTreeIter *top_iter,
121                                 gpointer data)
122 {
123   struct variable *var;
124   GtkTreeIter iter;
125   GtkTreeModel *model;
126
127
128   get_base_model (top_model, top_iter, &model, &iter);
129
130   g_assert (PSPPIRE_IS_DICT (model));
131
132
133   gtk_tree_model_get (model,
134                       &iter, DICT_TVM_COL_VAR, &var, -1);
135
136   if ( var_has_label (var))
137     {
138       gchar *text = g_strdup_printf (
139                                      "<span stretch=\"condensed\">%s</span>",
140                                      var_get_label (var));
141
142
143       char *utf8 = pspp_locale_to_utf8 (text, -1, NULL);
144
145       g_free (text);
146       g_object_set (cell, "markup", utf8, NULL);
147       g_free (utf8);
148     }
149   else
150     {
151       g_object_set (cell, "text", var_get_name (var), NULL);
152     }
153 }
154
155
156 /* Sets the tooltip to be the name of the variable under the cursor */
157 static gboolean
158 set_tooltip_for_variable (GtkTreeView  *treeview,
159                           gint        x,
160                           gint        y,
161                           gboolean    keyboard_mode,
162                           GtkTooltip *tooltip,
163                           gpointer    user_data)
164
165 {
166   gint bx, by;
167   GtkTreeIter iter;
168   GtkTreePath *path;
169   GtkTreeModel *tree_model;
170   struct variable *var = NULL;
171   gboolean ok;
172
173   gtk_tree_view_convert_widget_to_bin_window_coords (treeview,
174                                                      x, y, &bx, &by);
175
176   if (!gtk_tree_view_get_path_at_pos (treeview, bx, by,
177                                       &path, NULL, NULL, NULL))
178     return FALSE;
179
180   tree_model = gtk_tree_view_get_model (treeview);
181
182
183   gtk_tree_view_set_tooltip_row (treeview, tooltip, path);
184
185   ok = gtk_tree_model_get_iter (tree_model, &iter, path);
186
187   gtk_tree_path_free (path);
188   if (!ok)
189     return FALSE;
190
191
192   gtk_tree_model_get (tree_model, &iter, DICT_TVM_COL_VAR,  &var, -1);
193
194   if ( ! var_has_label (var))
195     return FALSE;
196
197   gtk_tooltip_set_text (tooltip, var_get_name (var));
198
199   return TRUE;
200 }
201
202    /* Sets up TREEVIEW to display the variables of DICT.
203    MODE is the selection mode for TREEVIEW.
204    PREDICATE determines which variables should be visible, or NULL if
205    all are to be visible.
206  */
207 void
208 attach_dictionary_to_treeview (GtkTreeView *treeview, PsppireDict *dict,
209                                GtkSelectionMode mode,
210                                var_predicate_func *predicate
211                                )
212 {
213   GtkTreeViewColumn *col;
214
215   GtkTreeSelection *selection =
216     gtk_tree_view_get_selection (treeview);
217
218   GtkCellRenderer *renderer;
219
220   GtkTreeModel *model ;
221
222   if ( predicate )
223     {
224       model = gtk_tree_model_filter_new (GTK_TREE_MODEL (dict),
225                                           NULL);
226
227       gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER (model),
228                                               filter_variables,
229                                               predicate,
230                                               NULL);
231     }
232   else
233     {
234       model = GTK_TREE_MODEL (dict);
235     }
236
237   gtk_tree_view_set_model (GTK_TREE_VIEW (treeview), model);
238
239
240   col = gtk_tree_view_column_new ();
241   gtk_tree_view_column_set_title (col, _("Variable"));
242
243   renderer = gtk_cell_renderer_pixbuf_new ();
244   gtk_tree_view_column_pack_start (col, renderer, FALSE);
245
246   gtk_tree_view_column_set_cell_data_func (col, renderer,
247                                            var_icon_cell_data_func,
248                                            NULL, NULL);
249
250
251   renderer = gtk_cell_renderer_text_new ();
252   gtk_tree_view_column_pack_start (col, renderer, TRUE);
253   gtk_tree_view_column_set_cell_data_func (col, renderer,
254                                            var_description_cell_data_func,
255                                            NULL, NULL);
256
257   g_object_set (renderer, "ellipsize-set", TRUE, NULL);
258   g_object_set (renderer, "ellipsize", PANGO_ELLIPSIZE_MIDDLE, NULL);
259
260   gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_FIXED);
261
262   /* FIXME: make this a value in terms of character widths */
263   gtk_tree_view_column_set_min_width (col, 150);
264
265   gtk_tree_view_append_column (treeview, col);
266
267   gtk_tree_selection_set_mode (selection, mode);
268
269   g_object_set (treeview, "has-tooltip", TRUE, NULL);
270
271   g_signal_connect (treeview, "query-tooltip", G_CALLBACK (set_tooltip_for_variable), NULL);
272 }
273
274
275 void
276 insert_source_row_into_entry (GtkTreeIter iter,
277                               GtkWidget *dest,
278                               GtkTreeModel *model,
279                               gpointer data
280                               )
281 {
282   GtkTreePath *path;
283   GtkTreeModel *dict;
284   gint *idx;
285   struct variable *var;
286   GtkTreeIter dict_iter;
287   gchar *name;
288
289   g_return_if_fail (GTK_IS_ENTRY(dest));
290
291   get_base_model (model, &iter, &dict, &dict_iter);
292
293   path = gtk_tree_model_get_path (GTK_TREE_MODEL (dict), &dict_iter);
294
295   idx = gtk_tree_path_get_indices (path);
296
297   var =  psppire_dict_get_variable (PSPPIRE_DICT (dict), *idx);
298
299   gtk_tree_path_free (path);
300
301   name = pspp_locale_to_utf8 (var_get_name (var), -1, NULL);
302   gtk_entry_set_text (GTK_ENTRY (dest),  name);
303   g_free (name);
304 }
305
306
307
308 void
309 insert_source_row_into_tree_view (GtkTreeIter iter,
310                                   GtkWidget *dest,
311                                   GtkTreeModel *model,
312                                   gpointer data
313                                   )
314 {
315   GtkTreePath *path;
316   GtkTreeIter dest_iter;
317   GtkTreeIter dict_iter;
318   gint *row ;
319   GtkTreeModel *destmodel = gtk_tree_view_get_model ( GTK_TREE_VIEW (dest));
320
321   GtkTreeModel *dict;
322
323
324   get_base_model (model, &iter, &dict, &dict_iter);
325
326   path = gtk_tree_model_get_path (dict, &dict_iter);
327
328   row = gtk_tree_path_get_indices (path);
329
330   gtk_list_store_append (GTK_LIST_STORE (destmodel),  &dest_iter);
331   gtk_list_store_set (GTK_LIST_STORE (destmodel), &dest_iter, 0, *row, -1);
332
333   gtk_tree_path_free (path);
334 }
335
336
337 gboolean
338 is_currently_in_entry (GtkTreeModel *model, GtkTreeIter *iter,
339                        PsppireSelector *selector)
340 {
341   gboolean result;
342   gchar *name;
343   GtkTreeIter dict_iter;
344   GtkTreeModel *dict;
345   struct variable *var;
346   gint dict_index;
347   gint *indeces;
348   GtkTreePath *path;
349   const gchar *text =   gtk_entry_get_text (GTK_ENTRY (selector->dest));
350
351   get_base_model (model, iter, &dict, &dict_iter);
352
353   path = gtk_tree_model_get_path (dict, &dict_iter);
354
355   indeces = gtk_tree_path_get_indices (path);
356
357   dict_index = indeces [0];
358
359   var = psppire_dict_get_variable (PSPPIRE_DICT (dict), dict_index);
360
361   gtk_tree_path_free (path);
362
363   name = pspp_locale_to_utf8 (var_get_name (var), -1, NULL);
364   result = ( 0 == strcmp (text, name));
365   g_free (name);
366
367   return result;
368 }
369
370