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