pintos-os.org Git - pspp/blob - src/ui/gui/psppire-data-editor.c

   1 /* PSPPIRE - a graphical user interface for PSPP.
   2    Copyright (C) 2008, 2009, 2010, 2011, 2012, 2016,
   3    2017 Free Software Foundation, Inc.
   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 "ui/gui/psppire-data-editor.h"
  21
  22 #include <gtk/gtk.h>
  23 #include <gtk-contrib/gtkxpaned.h>
  24
  25 #include "data/datasheet.h"
  26 #include "data/value-labels.h"
  27 #include "libpspp/range-set.h"
  28 #include "libpspp/str.h"
  29 #include "ui/gui/executor.h"
  30 #include "ui/gui/helper.h"
  31 #include "ui/gui/var-display.h"
  32 #include "ui/gui/val-labs-dialog.h"
  33 #include "ui/gui/missing-val-dialog.h"
  34 #include "ui/gui/var-type-dialog.h"
  35 #include "ui/gui/psppire-dict.h"
  36 #include "ui/gui/psppire-data-store.h"
  37 #include "ui/gui/psppire-data-window.h"
  38 #include "ui/gui/psppire-value-entry.h"
  39 #include "ui/gui/psppire-conf.h"
  40 #include "ui/gui/psppire-variable-sheet.h"
  41
  42 #include "value-variant.h"
  43
  44
  45 #include "ui/gui/efficient-sheet/jmd-sheet.h"
  46
  47 #include <gettext.h>
  48 #define _(msgid) gettext (msgid)
  49
  50 static void psppire_data_editor_class_init          (PsppireDataEditorClass *klass);
  51 static void psppire_data_editor_init                (PsppireDataEditor      *de);
  52
  53 static void refresh_entry (PsppireDataEditor *);
  54
  55 GType
  56 psppire_data_editor_get_type (void)
  57 {
  58   static GType de_type = 0;
  59
  60   if (!de_type)
  61     {
  62       static const GTypeInfo de_info =
  63       {
  64         sizeof (PsppireDataEditorClass),
  65         NULL, /* base_init */
  66         NULL, /* base_finalize */
  67         (GClassInitFunc) psppire_data_editor_class_init,
  68         NULL, /* class_finalize */
  69         NULL, /* class_data */
  70         sizeof (PsppireDataEditor),
  71         0,
  72         (GInstanceInitFunc) psppire_data_editor_init,
  73       };
  74
  75       de_type = g_type_register_static (GTK_TYPE_NOTEBOOK, "PsppireDataEditor",
  76                                         &de_info, 0);
  77     }
  78
  79   return de_type;
  80 }
  81
  82 static GObjectClass * parent_class = NULL;
  83
  84 static void
  85 psppire_data_editor_dispose (GObject *obj)
  86 {
  87   PsppireDataEditor *de = (PsppireDataEditor *) obj;
  88
  89   if (de->data_store)
  90     {
  91       g_object_unref (de->data_store);
  92       de->data_store = NULL;
  93     }
  94
  95   if (de->dict)
  96     {
  97       g_object_unref (de->dict);
  98       de->dict = NULL;
  99     }
 100
 101   if (de->font != NULL)
 102     {
 103       pango_font_description_free (de->font);
 104       de->font = NULL;
 105     }
 106
 107   /* Chain up to the parent class */
 108   G_OBJECT_CLASS (parent_class)->dispose (obj);
 109 }
 110
 111 enum
 112   {
 113     PROP_0,
 114     PROP_DATA_STORE,
 115     PROP_DICTIONARY,
 116     PROP_VALUE_LABELS,
 117     PROP_SPLIT_WINDOW
 118   };
 119
 120 static void
 121 psppire_data_editor_refresh_model (PsppireDataEditor *de)
 122 {
 123 }
 124
 125 static void
 126 change_data_value (PsppireDataStore *store, gint col, gint row, GValue *value)
 127 {
 128   const struct variable *var = psppire_dict_get_variable (store->dict, col);
 129
 130   if (NULL == var)
 131     return;
 132
 133   union value v;
 134
 135   GVariant *vrnt = g_value_get_variant (value);
 136
 137   value_variant_get (&v, vrnt);
 138
 139   psppire_data_store_set_value (store, row, var, &v);
 140
 141   value_destroy_from_variant (&v, vrnt);
 142 }
 143
 144 static void
 145 psppire_data_editor_set_property (GObject         *object,
 146                                   guint            prop_id,
 147                                   const GValue    *value,
 148                                   GParamSpec      *pspec)
 149 {
 150   PsppireDataEditor *de = PSPPIRE_DATA_EDITOR (object);
 151
 152   switch (prop_id)
 153     {
 154     case PROP_SPLIT_WINDOW:
 155       de->split = g_value_get_boolean (value);
 156       g_object_set (de->data_sheet, "split", de->split, NULL);
 157       g_object_set (de->var_sheet, "split", de->split, NULL);
 158       break;
 159     case PROP_DATA_STORE:
 160       if ( de->data_store)
 161         {
 162           g_signal_handlers_disconnect_by_func (de->data_store,
 163                                                 G_CALLBACK (refresh_entry),
 164                                                 de);
 165           g_object_unref (de->data_store);
 166         }
 167
 168       de->data_store = g_value_get_pointer (value);
 169       g_object_ref (de->data_store);
 170
 171       g_object_set (de->data_sheet, "data-model", de->data_store, NULL);
 172       psppire_data_editor_refresh_model (de);
 173
 174       g_signal_connect_swapped (de->data_sheet, "selection-changed",
 175                                 G_CALLBACK (refresh_entry),
 176                                 de);
 177
 178       g_signal_connect_swapped (de->data_sheet, "value-changed",
 179                                 G_CALLBACK (change_data_value), de->data_store);
 180
 181       g_signal_connect_swapped (de->data_store, "case-changed",
 182                                 G_CALLBACK (refresh_entry), de);
 183
 184       break;
 185     case PROP_DICTIONARY:
 186       if (de->dict)
 187         g_object_unref (de->dict);
 188       de->dict = g_value_get_pointer (value);
 189       g_object_ref (de->dict);
 190
 191       g_object_set (de->data_sheet, "hmodel", de->dict, NULL);
 192       g_object_set (de->var_sheet, "data-model", de->dict, NULL);
 193       break;
 194     case PROP_VALUE_LABELS:
 195       break;
 196
 197     default:
 198       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 199       break;
 200     };
 201 }
 202
 203 static void
 204 psppire_data_editor_get_property (GObject         *object,
 205                                   guint            prop_id,
 206                                   GValue          *value,
 207                                   GParamSpec      *pspec)
 208 {
 209   PsppireDataEditor *de = PSPPIRE_DATA_EDITOR (object);
 210
 211   switch (prop_id)
 212     {
 213     case PROP_SPLIT_WINDOW:
 214       g_value_set_boolean (value, de->split);
 215       break;
 216     case PROP_DATA_STORE:
 217       g_value_set_pointer (value, de->data_store);
 218       break;
 219     case PROP_DICTIONARY:
 220       g_value_set_pointer (value, de->dict);
 221       break;
 222     case PROP_VALUE_LABELS:
 223       break;
 224     default:
 225       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 226       break;
 227     }
 228 }
 229
 230 static void
 231 psppire_data_editor_switch_page (GtkNotebook     *notebook,
 232                                  GtkWidget *w,
 233                                  guint            page_num)
 234 {
 235   GTK_NOTEBOOK_CLASS (parent_class)->switch_page (notebook, w, page_num);
 236
 237 }
 238
 239 static void
 240 psppire_data_editor_set_focus_child (GtkContainer *container,
 241                                      GtkWidget    *widget)
 242 {
 243   GTK_CONTAINER_CLASS (parent_class)->set_focus_child (container, widget);
 244
 245 }
 246
 247 static void
 248 psppire_data_editor_class_init (PsppireDataEditorClass *klass)
 249 {
 250   GParamSpec *data_store_spec ;
 251   GParamSpec *dict_spec ;
 252   GParamSpec *value_labels_spec;
 253   GParamSpec *split_window_spec;
 254
 255   GObjectClass *object_class = G_OBJECT_CLASS (klass);
 256   GtkContainerClass *container_class = GTK_CONTAINER_CLASS (klass);
 257   GtkNotebookClass *notebook_class = GTK_NOTEBOOK_CLASS (klass);
 258
 259   parent_class = g_type_class_peek_parent (klass);
 260
 261   object_class->dispose = psppire_data_editor_dispose;
 262   object_class->set_property = psppire_data_editor_set_property;
 263   object_class->get_property = psppire_data_editor_get_property;
 264
 265   container_class->set_focus_child = psppire_data_editor_set_focus_child;
 266
 267   notebook_class->switch_page = psppire_data_editor_switch_page;
 268
 269   data_store_spec =
 270     g_param_spec_pointer ("data-store",
 271                           "Data Store",
 272                           "A pointer to the data store associated with this editor",
 273                           G_PARAM_CONSTRUCT_ONLY | G_PARAM_WRITABLE | G_PARAM_READABLE );
 274
 275   g_object_class_install_property (object_class,
 276                                    PROP_DATA_STORE,
 277                                    data_store_spec);
 278
 279   dict_spec =
 280     g_param_spec_pointer ("dictionary",
 281                           "Dictionary",
 282                           "A pointer to the dictionary associated with this editor",
 283                           G_PARAM_CONSTRUCT_ONLY | G_PARAM_WRITABLE | G_PARAM_READABLE );
 284
 285   g_object_class_install_property (object_class,
 286                                    PROP_DICTIONARY,
 287                                    dict_spec);
 288
 289   value_labels_spec =
 290     g_param_spec_boolean ("value-labels",
 291                          "Value Labels",
 292                          "Whether or not the data sheet should display labels instead of values",
 293                           FALSE,
 294                          G_PARAM_WRITABLE | G_PARAM_READABLE);
 295
 296   g_object_class_install_property (object_class,
 297                                    PROP_VALUE_LABELS,
 298                                    value_labels_spec);
 299
 300
 301   split_window_spec =
 302     g_param_spec_boolean ("split",
 303                           "Split Window",
 304                           "True iff the data sheet is split",
 305                           FALSE,
 306                           G_PARAM_READABLE | G_PARAM_WRITABLE);
 307
 308   g_object_class_install_property (object_class,
 309                                    PROP_SPLIT_WINDOW,
 310                                    split_window_spec);
 311 }
 312
 313
 314 static void
 315 on_var_sheet_var_double_clicked (void *var_sheet, gint dict_index,
 316                                  PsppireDataEditor *de)
 317 {
 318   gtk_notebook_set_current_page (GTK_NOTEBOOK (de),
 319                                  PSPPIRE_DATA_EDITOR_DATA_VIEW);
 320
 321   jmd_sheet_scroll_to (JMD_SHEET (de->data_sheet), dict_index, -1);
 322 }
 323
 324
 325 static void
 326 on_data_sheet_var_double_clicked (JmdSheet *data_sheet, gint dict_index,
 327                                  PsppireDataEditor *de)
 328 {
 329
 330   gtk_notebook_set_current_page (GTK_NOTEBOOK (de),
 331                                  PSPPIRE_DATA_EDITOR_VARIABLE_VIEW);
 332
 333   jmd_sheet_scroll_to (JMD_SHEET (de->var_sheet), -1, dict_index);
 334 }
 335
 336
 337
 338 /* Refreshes 'de->cell_ref_label' and 'de->datum_entry' from the currently
 339    active cell or cells. */
 340 static void
 341 refresh_entry (PsppireDataEditor *de)
 342 {
 343   gint row, col;
 344   if (jmd_sheet_get_active_cell (JMD_SHEET (de->data_sheet), &col, &row))
 345     {
 346       union value val;
 347       const struct variable *var = psppire_dict_get_variable (de->dict, col);
 348       if (var == NULL)
 349         return;
 350
 351       psppire_value_entry_set_variable (PSPPIRE_VALUE_ENTRY (de->datum_entry), var);
 352
 353       int width = var_get_width (var);
 354       if (! psppire_data_store_get_value (PSPPIRE_DATA_STORE (de->data_store),
 355                                           row, var, &val))
 356         return;
 357
 358       psppire_value_entry_set_value (PSPPIRE_VALUE_ENTRY (de->datum_entry),
 359                                      &val, width);
 360       value_destroy (&val, width);
 361     }
 362 }
 363
 364 static void
 365 on_datum_entry_activate (PsppireValueEntry *entry, PsppireDataEditor *de)
 366 {
 367 }
 368
 369
 370 /* Called when the active cell or the selection in the data sheet changes */
 371 static void
 372 on_data_selection_change (PsppireDataEditor *de, JmdRange *sel)
 373 {
 374   gchar *ref_cell_text = NULL;
 375
 376   gint n_cases = abs (sel->end_y - sel->start_y) + 1;
 377   gint n_vars = abs (sel->end_x - sel->start_x) + 1;
 378
 379   if (n_cases == 1 && n_vars == 1)
 380     {
 381       /* A single cell is selected */
 382       const struct variable *var = psppire_dict_get_variable (de->dict, sel->start_x);
 383
 384       if (var)
 385         ref_cell_text = g_strdup_printf (_("%d : %s"),
 386                                          sel->start_y + 1, var_get_name (var));
 387     }
 388   else
 389     {
 390       struct string s;
 391
 392       /* The glib string library does not understand the ' printf modifier
 393          on all platforms, but the "struct string" library does (because
 394          Gnulib fixes that problem), so use the latter.  */
 395       ds_init_empty (&s);
 396       ds_put_format (&s, ngettext ("%'d case", "%'d cases", n_cases),
 397                      n_cases);
 398       ds_put_byte (&s, ' ');
 399       ds_put_unichar (&s, 0xd7); /* U+00D7 MULTIPLICATION SIGN */
 400       ds_put_byte (&s, ' ');
 401       ds_put_format (&s, ngettext ("%'d variable", "%'d variables",
 402                                    n_vars),
 403                      n_vars);
 404       ref_cell_text = ds_steal_cstr (&s);
 405     }
 406
 407   gtk_label_set_label (GTK_LABEL (de->cell_ref_label),
 408                        ref_cell_text ? ref_cell_text : "");
 409
 410   g_free (ref_cell_text);
 411 }
 412
 413
 414 static void set_font_recursively (GtkWidget *w, gpointer data);
 415
 416 gboolean myreversefunc (GtkTreeModel *model, gint col, gint row, const gchar *in,
 417                     GValue *out);
 418
 419
 420 enum sort_order
 421   {
 422     SORT_ASCEND,
 423     SORT_DESCEND
 424   };
 425
 426 static void
 427 do_sort (PsppireDataEditor *de, enum sort_order order)
 428 {
 429   JmdRange *range = JMD_SHEET(de->data_sheet)->selection;
 430
 431   int n_vars = 0;
 432   int i;
 433
 434   PsppireDataWindow *pdw =
 435      psppire_data_window_for_data_store (de->data_store);
 436
 437   GString *syntax = g_string_new ("SORT CASES BY");
 438   for (i = range->start_x ; i <= range->end_x; ++i)
 439     {
 440       const struct variable *var = psppire_dict_get_variable (de->dict, i);
 441       if (var != NULL)
 442         {
 443           g_string_append_printf (syntax, " %s", var_get_name (var));
 444           n_vars++;
 445         }
 446     }
 447   if (n_vars > 0)
 448     {
 449       if (order == SORT_DESCEND)
 450         g_string_append (syntax, " (DOWN)");
 451       g_string_append_c (syntax, '.');
 452       execute_const_syntax_string (pdw, syntax->str);
 453     }
 454   g_string_free (syntax, TRUE);
 455 }
 456
 457
 458 static void
 459 sort_ascending (PsppireDataEditor *de)
 460 {
 461   do_sort (de, SORT_ASCEND);
 462
 463   gtk_widget_queue_draw (GTK_WIDGET (de));
 464 }
 465
 466 static void
 467 sort_descending (PsppireDataEditor *de)
 468 {
 469   do_sort (de, SORT_DESCEND);
 470
 471   gtk_widget_queue_draw (GTK_WIDGET (de));
 472 }
 473
 474 static void
 475 delete_cases (PsppireDataEditor *de)
 476 {
 477   JmdRange *range = JMD_SHEET(de->data_sheet)->selection;
 478
 479   psppire_data_store_delete_cases (de->data_store, range->start_y,
 480                                    range->end_y - range->start_y + 1);
 481
 482   gtk_widget_queue_draw (GTK_WIDGET (de));
 483 }
 484
 485 static void
 486 insert_new_case (PsppireDataEditor *de)
 487 {
 488   gint posn = GPOINTER_TO_INT (g_object_get_data
 489                                 (G_OBJECT (de->data_sheet_cases_row_popup), "item"));
 490
 491   psppire_data_editor_insert_new_case_at_posn (de, posn);
 492 }
 493
 494 void
 495 psppire_data_editor_data_delete_variables (PsppireDataEditor *de)
 496 {
 497   JmdRange *range = JMD_SHEET(de->data_sheet)->selection;
 498
 499   psppire_dict_delete_variables (de->dict, range->start_x,
 500                                  (range->end_x - range->start_x + 1));
 501
 502   gtk_widget_queue_draw (GTK_WIDGET (de->data_sheet));
 503 }
 504
 505 void
 506 psppire_data_editor_var_delete_variables (PsppireDataEditor *de)
 507 {
 508   JmdRange *range = JMD_SHEET(de->var_sheet)->selection;
 509
 510   psppire_dict_delete_variables (de->dict, range->start_y,
 511                                  (range->end_y - range->start_y + 1));
 512
 513   gtk_widget_queue_draw (GTK_WIDGET (de->var_sheet));
 514 }
 515
 516 void
 517 psppire_data_editor_insert_new_case_at_posn  (PsppireDataEditor *de, gint posn)
 518 {
 519   psppire_data_store_insert_new_case (de->data_store, posn);
 520
 521   gtk_widget_queue_draw (GTK_WIDGET (de->data_sheet));
 522 }
 523
 524 void
 525 psppire_data_editor_insert_new_variable_at_posn (PsppireDataEditor *de, gint posn)
 526 {
 527   const struct variable *v = psppire_dict_insert_variable (de->dict, posn, NULL);
 528   psppire_data_store_insert_value (de->data_store, var_get_width(v),
 529                                    var_get_case_index (v));
 530
 531   gtk_widget_queue_draw (GTK_WIDGET (de));
 532 }
 533
 534 static GtkWidget *
 535 create_data_row_header_popup_menu (PsppireDataEditor *de)
 536 {
 537   GtkWidget *menu = gtk_menu_new ();
 538
 539   GtkWidget *item =
 540     gtk_menu_item_new_with_mnemonic  (_("_Insert Case"));
 541
 542   g_signal_connect_swapped (item, "activate", G_CALLBACK (insert_new_case), de);
 543   gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
 544
 545   item = gtk_separator_menu_item_new ();
 546   gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
 547
 548   de->data_clear_cases_menu_item = gtk_menu_item_new_with_mnemonic (_("Cl_ear Cases"));
 549   gtk_widget_set_sensitive (de->data_clear_cases_menu_item, FALSE);
 550   gtk_menu_shell_append (GTK_MENU_SHELL (menu), de->data_clear_cases_menu_item);
 551   g_signal_connect_swapped (de->data_clear_cases_menu_item, "activate",
 552                             G_CALLBACK (delete_cases), de);
 553
 554   gtk_widget_show_all (menu);
 555   return menu;
 556 }
 557
 558 static void
 559 insert_new_variable_data (PsppireDataEditor *de)
 560 {
 561   gint posn = GPOINTER_TO_INT (g_object_get_data
 562                                 (G_OBJECT (de->data_sheet_cases_column_popup),
 563                                  "item"));
 564
 565   psppire_data_editor_insert_new_variable_at_posn (de, posn);
 566 }
 567
 568 static GtkWidget *
 569 create_data_column_header_popup_menu (PsppireDataEditor *de)
 570 {
 571   GtkWidget *menu = gtk_menu_new ();
 572
 573   GtkWidget *item =
 574     gtk_menu_item_new_with_mnemonic  (_("_Insert Variable"));
 575   g_signal_connect_swapped (item, "activate", G_CALLBACK (insert_new_variable_data),
 576                             de);
 577   gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
 578
 579   item = gtk_separator_menu_item_new ();
 580   gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
 581
 582   de->data_clear_variables_menu_item =
 583     gtk_menu_item_new_with_mnemonic  (_("Cl_ear Variables"));
 584   g_signal_connect_swapped (de->data_clear_variables_menu_item, "activate",
 585                             G_CALLBACK (psppire_data_editor_data_delete_variables),
 586                             de);
 587   gtk_widget_set_sensitive (de->data_clear_variables_menu_item, FALSE);
 588   gtk_menu_shell_append (GTK_MENU_SHELL (menu), de->data_clear_variables_menu_item);
 589
 590   item = gtk_separator_menu_item_new ();
 591   gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
 592
 593   de->data_sort_ascending_menu_item =
 594     gtk_menu_item_new_with_mnemonic (_("Sort _Ascending"));
 595   g_signal_connect_swapped (de->data_sort_ascending_menu_item, "activate",
 596                             G_CALLBACK (sort_ascending), de);
 597   gtk_widget_set_sensitive (de->data_sort_ascending_menu_item, FALSE);
 598   gtk_menu_shell_append (GTK_MENU_SHELL (menu), de->data_sort_ascending_menu_item);
 599
 600   de->data_sort_descending_menu_item =
 601     gtk_menu_item_new_with_mnemonic (_("Sort _Descending"));
 602   g_signal_connect_swapped (de->data_sort_descending_menu_item, "activate",
 603                             G_CALLBACK (sort_descending), de);
 604   gtk_widget_set_sensitive (de->data_sort_descending_menu_item, FALSE);
 605   gtk_menu_shell_append (GTK_MENU_SHELL (menu), de->data_sort_descending_menu_item);
 606
 607   gtk_widget_show_all (menu);
 608   return menu;
 609 }
 610
 611 static void
 612 set_menu_items_sensitivity (JmdSheet *sheet, gpointer selection, gpointer p)
 613 {
 614   JmdRange *range = selection;
 615   PsppireDataEditor *de = PSPPIRE_DATA_EDITOR (p);
 616   gint width = gtk_tree_model_get_n_columns (sheet->data_model);
 617   gint length = psppire_data_store_get_case_count (de->data_store);
 618
 619
 620   gboolean whole_row_selected = (range->start_x == 0 && range->end_x == width - 1);
 621   gtk_widget_set_sensitive (de->data_clear_cases_menu_item, whole_row_selected);
 622
 623
 624   gboolean whole_column_selected =
 625     (range->start_y == 0 && range->end_y == length - 1);
 626   gtk_widget_set_sensitive (de->data_clear_variables_menu_item,
 627                             whole_column_selected);
 628   gtk_widget_set_sensitive (de->data_sort_ascending_menu_item,
 629                             whole_column_selected);
 630   gtk_widget_set_sensitive (de->data_sort_descending_menu_item,
 631                             whole_column_selected);
 632 }
 633
 634 static void
 635 show_cases_row_popup (JmdSheet *sheet, int row, uint button, uint state, gpointer p)
 636 {
 637   PsppireDataEditor *de = PSPPIRE_DATA_EDITOR (p);
 638   GListModel *vmodel = NULL;
 639   g_object_get (sheet, "vmodel", &vmodel, NULL);
 640   if (vmodel == NULL)
 641     return;
 642
 643   guint n_items = g_list_model_get_n_items (vmodel);
 644
 645   if (row >= n_items)
 646     return;
 647
 648   if (button != 3)
 649     return;
 650
 651   g_object_set_data (G_OBJECT (de->data_sheet_cases_row_popup), "item",
 652                      GINT_TO_POINTER (row));
 653
 654   gtk_menu_popup_at_pointer (GTK_MENU (de->data_sheet_cases_row_popup), NULL);
 655 }
 656
 657 static void
 658 show_cases_column_popup (JmdSheet *sheet, int column, uint button, uint state,
 659                          gpointer p)
 660 {
 661   PsppireDataEditor *de = PSPPIRE_DATA_EDITOR (p);
 662   GListModel *hmodel = NULL;
 663   g_object_get (sheet, "hmodel", &hmodel, NULL);
 664   if (hmodel == NULL)
 665     return;
 666
 667   guint n_items = g_list_model_get_n_items (hmodel);
 668
 669   if (column >= n_items)
 670     return;
 671
 672   if (button != 3)
 673     return;
 674
 675   g_object_set_data (G_OBJECT (de->data_sheet_cases_column_popup), "item",
 676                      GINT_TO_POINTER (column));
 677
 678   gtk_menu_popup_at_pointer (GTK_MENU (de->data_sheet_cases_column_popup), NULL);
 679 }
 680
 681
 682 static gchar *
 683 data_store_value_to_string (JmdSheet *data_sheet, PsppireDataStore *store, gint col, gint row, const GValue *v)
 684 {
 685   return psppire_data_store_value_to_string (store, col, row, v);
 686 }
 687
 688 static void
 689 psppire_data_editor_init (PsppireDataEditor *de)
 690 {
 691   GtkWidget *hbox;
 692   gchar *fontname = NULL;
 693
 694   GtkStyleContext *context = gtk_widget_get_style_context (GTK_WIDGET (de));
 695   gtk_style_context_add_class (context, "psppire-data-editor");
 696
 697   de->font = NULL;
 698
 699   g_object_set (de, "tab-pos", GTK_POS_BOTTOM, NULL);
 700
 701   de->cell_ref_label = gtk_label_new ("");
 702   gtk_label_set_width_chars (GTK_LABEL (de->cell_ref_label), 25);
 703   gtk_widget_set_valign (de->cell_ref_label, GTK_ALIGN_CENTER);
 704
 705   de->datum_entry = psppire_value_entry_new ();
 706   g_signal_connect (GTK_ENTRY (gtk_bin_get_child (GTK_BIN (de->datum_entry))),
 707                     "activate", G_CALLBACK (on_datum_entry_activate), de);
 708
 709   hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
 710   gtk_box_pack_start (GTK_BOX (hbox), de->cell_ref_label, FALSE, FALSE, 0);
 711   gtk_box_pack_start (GTK_BOX (hbox), de->datum_entry, TRUE, TRUE, 0);
 712
 713   de->split = FALSE;
 714   de->data_sheet = jmd_sheet_new ();
 715
 716   de->data_sheet_cases_column_popup = create_data_column_header_popup_menu (de);
 717   de->data_sheet_cases_row_popup = create_data_row_header_popup_menu (de);
 718
 719   g_signal_connect (de->data_sheet, "row-header-pressed",
 720                     G_CALLBACK (show_cases_row_popup), de);
 721
 722   g_signal_connect (de->data_sheet, "column-header-pressed",
 723                     G_CALLBACK (show_cases_column_popup), de);
 724
 725   g_signal_connect (de->data_sheet, "selection-changed",
 726                     G_CALLBACK (set_menu_items_sensitivity), de);
 727
 728   g_object_set (de->data_sheet,
 729                 "forward-conversion", data_store_value_to_string,
 730                 "reverse-conversion", myreversefunc,
 731                 NULL);
 732
 733   GtkWidget *data_button = jmd_sheet_get_button (JMD_SHEET (de->data_sheet));
 734   gtk_button_set_label (GTK_BUTTON (data_button), _("Case"));
 735   de->vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
 736   gtk_box_pack_start (GTK_BOX (de->vbox), hbox, FALSE, FALSE, 0);
 737   gtk_box_pack_start (GTK_BOX (de->vbox), de->data_sheet, TRUE, TRUE, 0);
 738
 739
 740   g_signal_connect_swapped (de->data_sheet, "selection-changed",
 741                     G_CALLBACK (on_data_selection_change), de);
 742
 743   gtk_notebook_append_page (GTK_NOTEBOOK (de), de->vbox,
 744                             gtk_label_new_with_mnemonic (_("Data View")));
 745
 746   gtk_widget_show_all (de->vbox);
 747
 748   de->var_sheet = psppire_variable_sheet_new ();
 749
 750   GtkWidget *var_button = jmd_sheet_get_button (JMD_SHEET (de->var_sheet));
 751   gtk_button_set_label (GTK_BUTTON (var_button), _("Variable"));
 752
 753   gtk_notebook_append_page (GTK_NOTEBOOK (de), de->var_sheet,
 754                             gtk_label_new_with_mnemonic (_("Variable View")));
 755
 756   gtk_widget_show_all (de->var_sheet);
 757
 758   g_signal_connect (de->var_sheet, "row-header-double-clicked",
 759                     G_CALLBACK (on_var_sheet_var_double_clicked), de);
 760
 761   g_signal_connect (de->data_sheet, "column-header-double-clicked",
 762                     G_CALLBACK (on_data_sheet_var_double_clicked), de);
 763
 764   g_object_set (de, "can-focus", FALSE, NULL);
 765
 766   if (psppire_conf_get_string (psppire_conf_new (),
 767                            "Data Editor", "font",
 768                                 &fontname) )
 769     {
 770       de->font = pango_font_description_from_string (fontname);
 771       g_free (fontname);
 772       set_font_recursively (GTK_WIDGET (de), de->font);
 773     }
 774
 775 }
 776
 777 GtkWidget*
 778 psppire_data_editor_new (PsppireDict *dict,
 779                          PsppireDataStore *data_store)
 780 {
 781   return  g_object_new (PSPPIRE_DATA_EDITOR_TYPE,
 782                         "dictionary",  dict,
 783                         "data-store",  data_store,
 784                         NULL);
 785 }
 786 \f
 787 /* Turns the visible grid on or off, according to GRID_VISIBLE, for DE's data
 788    sheet(s) and variable sheet. */
 789 void
 790 psppire_data_editor_show_grid (PsppireDataEditor *de, gboolean grid_visible)
 791 {
 792   g_object_set (JMD_SHEET (de->var_sheet), "gridlines", grid_visible, NULL);
 793   g_object_set (JMD_SHEET (de->data_sheet), "gridlines", grid_visible, NULL);
 794 }
 795
 796
 797 static void
 798 set_font_recursively (GtkWidget *w, gpointer data)
 799 {
 800   PangoFontDescription *font_desc = data;
 801
 802   GtkStyleContext *style = gtk_widget_get_style_context (w);
 803   GtkCssProvider *cssp = gtk_css_provider_new ();
 804
 805   gchar *str = pango_font_description_to_string (font_desc);
 806   gchar *css =
 807     g_strdup_printf ("* {font: %s}", str);
 808   g_free (str);
 809
 810   GError *err = NULL;
 811   gtk_css_provider_load_from_data (cssp, css, -1, &err);
 812   if (err)
 813     {
 814       g_warning ("Failed to load font css \"%s\": %s", css, err->message);
 815       g_error_free (err);
 816     }
 817   g_free (css);
 818
 819   gtk_style_context_add_provider (style,
 820                                   GTK_STYLE_PROVIDER (cssp),
 821                                   GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
 822   g_object_unref (cssp);
 823
 824
 825   if ( GTK_IS_CONTAINER (w))
 826     gtk_container_foreach (GTK_CONTAINER (w), set_font_recursively, font_desc);
 827 }
 828
 829 /* Sets FONT_DESC as the font used by the data sheet(s) and variable sheet. */
 830 void
 831 psppire_data_editor_set_font (PsppireDataEditor *de, PangoFontDescription *font_desc)
 832 {
 833   gchar *font_name;
 834   set_font_recursively (GTK_WIDGET (de), font_desc);
 835
 836   if (de->font)
 837     pango_font_description_free (de->font);
 838   de->font = pango_font_description_copy (font_desc);
 839   font_name = pango_font_description_to_string (de->font);
 840
 841   psppire_conf_set_string (psppire_conf_new (),
 842                            "Data Editor", "font",
 843                            font_name);
 844   g_free (font_name);
 845 }
 846
 847 /* If SPLIT is TRUE, splits DE's data sheet into four panes.
 848    If SPLIT is FALSE, un-splits it into a single pane. */
 849 void
 850 psppire_data_editor_split_window (PsppireDataEditor *de, gboolean split)
 851 {
 852   g_object_set (de, "split", split, NULL);
 853 }
 854
 855 /* Makes the variable with dictionary index DICT_INDEX in DE's dictionary
 856    visible and selected in the active view in DE. */
 857 void
 858 psppire_data_editor_goto_variable (PsppireDataEditor *de, gint dict_index)
 859 {
 860   gint page = gtk_notebook_get_current_page (GTK_NOTEBOOK (de));
 861
 862   switch (page)
 863     {
 864       case PSPPIRE_DATA_EDITOR_DATA_VIEW:
 865         jmd_sheet_scroll_to (JMD_SHEET (de->data_sheet), dict_index, -1);
 866         jmd_sheet_set_active_cell (JMD_SHEET (de->data_sheet), dict_index, -1, NULL);
 867         break;
 868       case PSPPIRE_DATA_EDITOR_VARIABLE_VIEW:
 869         jmd_sheet_scroll_to (JMD_SHEET (de->var_sheet), -1, dict_index);
 870         jmd_sheet_set_active_cell (JMD_SHEET (de->var_sheet), -1, dict_index, NULL);
 871         break;
 872     }
 873 }
 874
 875 /* Set the datum at COL, ROW, to that contained in VALUE.
 876  */
 877 static void
 878 store_set_datum (GtkTreeModel *model, gint col, gint row,
 879                          const GValue *value)
 880 {
 881   PsppireDataStore *store = PSPPIRE_DATA_STORE (model);
 882   GVariant *v = g_value_get_variant (value);
 883   union value uv;
 884   value_variant_get (&uv, v);
 885   const struct variable *var = psppire_dict_get_variable (store->dict, col);
 886   psppire_data_store_set_value (store, row, var, &uv);
 887   value_destroy_from_variant (&uv, v);
 888 }
 889
 890 void
 891 psppire_data_editor_paste (PsppireDataEditor *de)
 892 {
 893   JmdSheet *sheet = JMD_SHEET (de->data_sheet);
 894   GtkClipboard *clip =
 895     gtk_clipboard_get_for_display (gtk_widget_get_display (GTK_WIDGET (sheet)),
 896                                    GDK_SELECTION_CLIPBOARD);
 897
 898   jmd_sheet_paste (sheet, clip, store_set_datum);
 899 }