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
  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 #include "ui/gui/psppire-data-sheet.h"
  42
  43
  44 #include "ui/gui/efficient-sheet/src/jmd-sheet.h"
  45
  46 #include <gettext.h>
  47 #define _(msgid) gettext (msgid)
  48
  49 static void psppire_data_editor_class_init          (PsppireDataEditorClass *klass);
  50 static void psppire_data_editor_init                (PsppireDataEditor      *de);
  51
  52 static void refresh_entry (PsppireDataEditor *);
  53
  54 GType
  55 psppire_data_editor_get_type (void)
  56 {
  57   static GType de_type = 0;
  58
  59   if (!de_type)
  60     {
  61       static const GTypeInfo de_info =
  62       {
  63         sizeof (PsppireDataEditorClass),
  64         NULL, /* base_init */
  65         NULL, /* base_finalize */
  66         (GClassInitFunc) psppire_data_editor_class_init,
  67         NULL, /* class_finalize */
  68         NULL, /* class_data */
  69         sizeof (PsppireDataEditor),
  70         0,
  71         (GInstanceInitFunc) psppire_data_editor_init,
  72       };
  73
  74       de_type = g_type_register_static (GTK_TYPE_NOTEBOOK, "PsppireDataEditor",
  75                                         &de_info, 0);
  76     }
  77
  78   return de_type;
  79 }
  80
  81 static GObjectClass * parent_class = NULL;
  82
  83 static void
  84 psppire_data_editor_dispose (GObject *obj)
  85 {
  86   PsppireDataEditor *de = (PsppireDataEditor *) obj;
  87
  88   if (de->data_store)
  89     {
  90       g_object_unref (de->data_store);
  91       de->data_store = NULL;
  92     }
  93
  94   if (de->dict)
  95     {
  96       g_object_unref (de->dict);
  97       de->dict = NULL;
  98     }
  99
 100   if (de->font != NULL)
 101     {
 102       pango_font_description_free (de->font);
 103       de->font = NULL;
 104     }
 105
 106   /* Chain up to the parent class */
 107   G_OBJECT_CLASS (parent_class)->dispose (obj);
 108 }
 109
 110 enum
 111   {
 112     PROP_0,
 113     PROP_DATA_STORE,
 114     PROP_DICTIONARY,
 115     PROP_VALUE_LABELS,
 116     PROP_SPLIT_WINDOW
 117   };
 118
 119 static void
 120 psppire_data_editor_refresh_model (PsppireDataEditor *de)
 121 {
 122 }
 123
 124
 125 static void
 126 psppire_data_editor_set_property (GObject         *object,
 127                                   guint            prop_id,
 128                                   const GValue    *value,
 129                                   GParamSpec      *pspec)
 130 {
 131   PsppireDataEditor *de = PSPPIRE_DATA_EDITOR (object);
 132
 133   switch (prop_id)
 134     {
 135     case PROP_SPLIT_WINDOW:
 136       de->split = g_value_get_boolean (value);
 137       g_object_set (de->data_sheet, "split", de->split, NULL);
 138       g_object_set (de->var_sheet, "split", de->split, NULL);
 139       break;
 140     case PROP_DATA_STORE:
 141       if ( de->data_store)
 142         {
 143           g_signal_handlers_disconnect_by_func (de->data_store,
 144                                                 G_CALLBACK (refresh_entry),
 145                                                 de);
 146           g_object_unref (de->data_store);
 147         }
 148
 149       de->data_store = g_value_get_pointer (value);
 150       g_object_ref (de->data_store);
 151
 152       g_object_set (de->data_sheet, "data-model", de->data_store, NULL);
 153       psppire_data_editor_refresh_model (de);
 154
 155       g_signal_connect_swapped (de->data_sheet, "selection-changed",
 156                                 G_CALLBACK (refresh_entry),
 157                                 de);
 158
 159       g_signal_connect_swapped (de->data_store, "case-changed",
 160                                 G_CALLBACK (refresh_entry), de);
 161
 162       break;
 163     case PROP_DICTIONARY:
 164       if (de->dict)
 165         g_object_unref (de->dict);
 166       de->dict = g_value_get_pointer (value);
 167       g_object_ref (de->dict);
 168
 169       g_object_set (de->var_sheet, "data-model", de->dict, NULL);
 170       break;
 171     case PROP_VALUE_LABELS:
 172       break;
 173
 174     default:
 175       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 176       break;
 177     };
 178 }
 179
 180 static void
 181 psppire_data_editor_get_property (GObject         *object,
 182                                   guint            prop_id,
 183                                   GValue          *value,
 184                                   GParamSpec      *pspec)
 185 {
 186   PsppireDataEditor *de = PSPPIRE_DATA_EDITOR (object);
 187
 188   switch (prop_id)
 189     {
 190     case PROP_SPLIT_WINDOW:
 191       g_value_set_boolean (value, de->split);
 192       break;
 193     case PROP_DATA_STORE:
 194       g_value_set_pointer (value, de->data_store);
 195       break;
 196     case PROP_DICTIONARY:
 197       g_value_set_pointer (value, de->dict);
 198       break;
 199     case PROP_VALUE_LABELS:
 200       break;
 201     default:
 202       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 203       break;
 204     }
 205 }
 206
 207 static void
 208 psppire_data_editor_switch_page (GtkNotebook     *notebook,
 209                                  GtkWidget *w,
 210                                  guint            page_num)
 211 {
 212   GTK_NOTEBOOK_CLASS (parent_class)->switch_page (notebook, w, page_num);
 213
 214 }
 215
 216 static void
 217 psppire_data_editor_set_focus_child (GtkContainer *container,
 218                                      GtkWidget    *widget)
 219 {
 220   GTK_CONTAINER_CLASS (parent_class)->set_focus_child (container, widget);
 221
 222 }
 223
 224 static void
 225 psppire_data_editor_class_init (PsppireDataEditorClass *klass)
 226 {
 227   GParamSpec *data_store_spec ;
 228   GParamSpec *dict_spec ;
 229   GParamSpec *value_labels_spec;
 230   GParamSpec *split_window_spec;
 231
 232   GObjectClass *object_class = G_OBJECT_CLASS (klass);
 233   GtkContainerClass *container_class = GTK_CONTAINER_CLASS (klass);
 234   GtkNotebookClass *notebook_class = GTK_NOTEBOOK_CLASS (klass);
 235
 236   parent_class = g_type_class_peek_parent (klass);
 237
 238   object_class->dispose = psppire_data_editor_dispose;
 239   object_class->set_property = psppire_data_editor_set_property;
 240   object_class->get_property = psppire_data_editor_get_property;
 241
 242   container_class->set_focus_child = psppire_data_editor_set_focus_child;
 243
 244   notebook_class->switch_page = psppire_data_editor_switch_page;
 245
 246   data_store_spec =
 247     g_param_spec_pointer ("data-store",
 248                           "Data Store",
 249                           "A pointer to the data store associated with this editor",
 250                           G_PARAM_CONSTRUCT_ONLY | G_PARAM_WRITABLE | G_PARAM_READABLE );
 251
 252   g_object_class_install_property (object_class,
 253                                    PROP_DATA_STORE,
 254                                    data_store_spec);
 255
 256   dict_spec =
 257     g_param_spec_pointer ("dictionary",
 258                           "Dictionary",
 259                           "A pointer to the dictionary associated with this editor",
 260                           G_PARAM_CONSTRUCT_ONLY | G_PARAM_WRITABLE | G_PARAM_READABLE );
 261
 262   g_object_class_install_property (object_class,
 263                                    PROP_DICTIONARY,
 264                                    dict_spec);
 265
 266   value_labels_spec =
 267     g_param_spec_boolean ("value-labels",
 268                          "Value Labels",
 269                          "Whether or not the data sheet should display labels instead of values",
 270                           FALSE,
 271                          G_PARAM_WRITABLE | G_PARAM_READABLE);
 272
 273   g_object_class_install_property (object_class,
 274                                    PROP_VALUE_LABELS,
 275                                    value_labels_spec);
 276
 277
 278   split_window_spec =
 279     g_param_spec_boolean ("split",
 280                           "Split Window",
 281                           "True iff the data sheet is split",
 282                           FALSE,
 283                           G_PARAM_READABLE | G_PARAM_WRITABLE);
 284
 285   g_object_class_install_property (object_class,
 286                                    PROP_SPLIT_WINDOW,
 287                                    split_window_spec);
 288 }
 289
 290
 291 static void
 292 on_var_sheet_var_double_clicked (void *var_sheet, gint dict_index,
 293                                  PsppireDataEditor *de)
 294 {
 295   gtk_notebook_set_current_page (GTK_NOTEBOOK (de),
 296                                  PSPPIRE_DATA_EDITOR_DATA_VIEW);
 297
 298   jmd_sheet_scroll_to (JMD_SHEET (de->data_sheet), dict_index, -1);
 299 }
 300
 301
 302 static void
 303 on_data_sheet_var_double_clicked (JmdSheet *data_sheet, gint dict_index,
 304                                  PsppireDataEditor *de)
 305 {
 306
 307   gtk_notebook_set_current_page (GTK_NOTEBOOK (de),
 308                                  PSPPIRE_DATA_EDITOR_VARIABLE_VIEW);
 309
 310   jmd_sheet_scroll_to (JMD_SHEET (de->var_sheet), -1, dict_index);
 311 }
 312
 313
 314
 315 /* Refreshes 'de->cell_ref_label' and 'de->datum_entry' from the currently
 316    active cell or cells. */
 317 static void
 318 refresh_entry (PsppireDataEditor *de)
 319 {
 320   gint row, col;
 321   if (jmd_sheet_get_active_cell (JMD_SHEET (de->data_sheet), &col, &row))
 322     {
 323       union value val;
 324       const struct variable *var = psppire_dict_get_variable (de->dict, col);
 325       if (var == NULL)
 326         return;
 327
 328       psppire_value_entry_set_variable (PSPPIRE_VALUE_ENTRY (de->datum_entry), var);
 329
 330       int width = var_get_width (var);
 331       if (! psppire_data_store_get_value (PSPPIRE_DATA_STORE (de->data_store),
 332                                           row, var, &val))
 333         return;
 334
 335       psppire_value_entry_set_value (PSPPIRE_VALUE_ENTRY (de->datum_entry),
 336                                      &val, width);
 337       value_destroy (&val, width);
 338     }
 339 }
 340
 341 static void
 342 on_datum_entry_activate (PsppireValueEntry *entry, PsppireDataEditor *de)
 343 {
 344 }
 345
 346
 347 /* Called when the active cell or the selection in the data sheet changes */
 348 static void
 349 on_data_selection_change (PsppireDataEditor *de, JmdRange *sel)
 350 {
 351   gchar *ref_cell_text = NULL;
 352
 353   gint n_cases = abs (sel->end_y - sel->start_y) + 1;
 354   gint n_vars = abs (sel->end_x - sel->start_x) + 1;
 355
 356   if (n_cases == 1 && n_vars == 1)
 357     {
 358       /* A single cell is selected */
 359       const struct variable *var = psppire_dict_get_variable (de->dict, sel->start_x);
 360
 361       if (var)
 362         ref_cell_text = g_strdup_printf (_("%d : %s"),
 363                                          sel->start_y + 1, var_get_name (var));
 364     }
 365   else
 366     {
 367       struct string s;
 368
 369       /* The glib string library does not understand the ' printf modifier
 370          on all platforms, but the "struct string" library does (because
 371          Gnulib fixes that problem), so use the latter.  */
 372       ds_init_empty (&s);
 373       ds_put_format (&s, ngettext ("%'d case", "%'d cases", n_cases),
 374                      n_cases);
 375       ds_put_byte (&s, ' ');
 376       ds_put_unichar (&s, 0xd7); /* U+00D7 MULTIPLICATION SIGN */
 377       ds_put_byte (&s, ' ');
 378       ds_put_format (&s, ngettext ("%'d variable", "%'d variables",
 379                                    n_vars),
 380                      n_vars);
 381       ref_cell_text = ds_steal_cstr (&s);
 382     }
 383
 384   gtk_label_set_label (GTK_LABEL (de->cell_ref_label),
 385                        ref_cell_text ? ref_cell_text : "");
 386
 387   g_free (ref_cell_text);
 388 }
 389
 390
 391 static void set_font_recursively (GtkWidget *w, gpointer data);
 392
 393 \f
 394
 395 void
 396 psppire_data_editor_data_delete_variables (PsppireDataEditor *de)
 397 {
 398   JmdRange *range = JMD_SHEET(de->data_sheet)->selection;
 399
 400   psppire_dict_delete_variables (de->dict, range->start_x,
 401                                  (range->end_x - range->start_x + 1));
 402
 403   gtk_widget_queue_draw (GTK_WIDGET (de->data_sheet));
 404 }
 405
 406 void
 407 psppire_data_editor_var_delete_variables (PsppireDataEditor *de)
 408 {
 409   JmdRange *range = JMD_SHEET(de->var_sheet)->selection;
 410
 411   psppire_dict_delete_variables (de->dict, range->start_y,
 412                                  (range->end_y - range->start_y + 1));
 413
 414   gtk_widget_queue_draw (GTK_WIDGET (de->var_sheet));
 415 }
 416
 417 void
 418 psppire_data_editor_insert_new_case_at_posn  (PsppireDataEditor *de, gint posn)
 419 {
 420   psppire_data_store_insert_new_case (de->data_store, posn);
 421
 422   gtk_widget_queue_draw (GTK_WIDGET (de->data_sheet));
 423 }
 424
 425 void
 426 psppire_data_editor_insert_new_variable_at_posn (PsppireDataEditor *de, gint posn)
 427 {
 428   const struct variable *v = psppire_dict_insert_variable (de->dict, posn, NULL);
 429   psppire_data_store_insert_value (de->data_store, var_get_width(v),
 430                                    var_get_case_index (v));
 431
 432   gtk_widget_queue_draw (GTK_WIDGET (de));
 433 }
 434
 435 static void
 436 psppire_data_editor_init (PsppireDataEditor *de)
 437 {
 438   GtkWidget *hbox;
 439   gchar *fontname = NULL;
 440
 441   GtkStyleContext *context = gtk_widget_get_style_context (GTK_WIDGET (de));
 442   gtk_style_context_add_class (context, "psppire-data-editor");
 443
 444   de->font = NULL;
 445
 446   g_object_set (de, "tab-pos", GTK_POS_BOTTOM, NULL);
 447
 448   de->cell_ref_label = gtk_label_new ("");
 449   gtk_label_set_width_chars (GTK_LABEL (de->cell_ref_label), 25);
 450   gtk_widget_set_valign (de->cell_ref_label, GTK_ALIGN_CENTER);
 451
 452   de->datum_entry = psppire_value_entry_new ();
 453   g_signal_connect (GTK_ENTRY (gtk_bin_get_child (GTK_BIN (de->datum_entry))),
 454                     "activate", G_CALLBACK (on_datum_entry_activate), de);
 455
 456   hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
 457   gtk_box_pack_start (GTK_BOX (hbox), de->cell_ref_label, FALSE, FALSE, 0);
 458   gtk_box_pack_start (GTK_BOX (hbox), de->datum_entry, TRUE, TRUE, 0);
 459
 460   de->split = FALSE;
 461   de->data_sheet = psppire_data_sheet_new ();
 462
 463   GtkWidget *data_button = jmd_sheet_get_button (JMD_SHEET (de->data_sheet));
 464   gtk_button_set_label (GTK_BUTTON (data_button), _("Case"));
 465   de->vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
 466   gtk_box_pack_start (GTK_BOX (de->vbox), hbox, FALSE, FALSE, 0);
 467   gtk_box_pack_start (GTK_BOX (de->vbox), de->data_sheet, TRUE, TRUE, 0);
 468
 469
 470   g_signal_connect_swapped (de->data_sheet, "selection-changed",
 471                     G_CALLBACK (on_data_selection_change), de);
 472
 473   gtk_notebook_append_page (GTK_NOTEBOOK (de), de->vbox,
 474                             gtk_label_new_with_mnemonic (_("Data View")));
 475
 476   gtk_widget_show_all (de->vbox);
 477
 478   de->var_sheet = psppire_variable_sheet_new ();
 479
 480   GtkWidget *var_button = jmd_sheet_get_button (JMD_SHEET (de->var_sheet));
 481   gtk_button_set_label (GTK_BUTTON (var_button), _("Variable"));
 482
 483   gtk_notebook_append_page (GTK_NOTEBOOK (de), de->var_sheet,
 484                             gtk_label_new_with_mnemonic (_("Variable View")));
 485
 486   gtk_widget_show_all (de->var_sheet);
 487
 488   g_signal_connect (de->var_sheet, "row-header-double-clicked",
 489                     G_CALLBACK (on_var_sheet_var_double_clicked), de);
 490
 491   g_signal_connect (de->data_sheet, "column-header-double-clicked",
 492                     G_CALLBACK (on_data_sheet_var_double_clicked), de);
 493
 494   g_object_set (de, "can-focus", FALSE, NULL);
 495
 496   if (psppire_conf_get_string (psppire_conf_new (),
 497                            "Data Editor", "font",
 498                                 &fontname) )
 499     {
 500       de->font = pango_font_description_from_string (fontname);
 501       g_free (fontname);
 502       set_font_recursively (GTK_WIDGET (de), de->font);
 503     }
 504
 505 }
 506
 507 GtkWidget*
 508 psppire_data_editor_new (PsppireDict *dict,
 509                          PsppireDataStore *data_store)
 510 {
 511   return  g_object_new (PSPPIRE_DATA_EDITOR_TYPE,
 512                         "dictionary",  dict,
 513                         "data-store",  data_store,
 514                         NULL);
 515 }
 516 \f
 517 /* Turns the visible grid on or off, according to GRID_VISIBLE, for DE's data
 518    sheet(s) and variable sheet. */
 519 void
 520 psppire_data_editor_show_grid (PsppireDataEditor *de, gboolean grid_visible)
 521 {
 522   g_object_set (JMD_SHEET (de->var_sheet), "gridlines", grid_visible, NULL);
 523   g_object_set (JMD_SHEET (de->data_sheet), "gridlines", grid_visible, NULL);
 524 }
 525
 526
 527 static void
 528 set_font_recursively (GtkWidget *w, gpointer data)
 529 {
 530   PangoFontDescription *font_desc = data;
 531
 532   GtkStyleContext *style = gtk_widget_get_style_context (w);
 533   GtkCssProvider *cssp = gtk_css_provider_new ();
 534
 535   gchar *str = pango_font_description_to_string (font_desc);
 536   gchar *css =
 537     g_strdup_printf ("* {font: %s}", str);
 538   g_free (str);
 539
 540   GError *err = NULL;
 541   gtk_css_provider_load_from_data (cssp, css, -1, &err);
 542   if (err)
 543     {
 544       g_warning ("Failed to load font css \"%s\": %s", css, err->message);
 545       g_error_free (err);
 546     }
 547   g_free (css);
 548
 549   gtk_style_context_add_provider (style,
 550                                   GTK_STYLE_PROVIDER (cssp),
 551                                   GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
 552   g_object_unref (cssp);
 553
 554
 555   if ( GTK_IS_CONTAINER (w))
 556     gtk_container_foreach (GTK_CONTAINER (w), set_font_recursively, font_desc);
 557 }
 558
 559 /* Sets FONT_DESC as the font used by the data sheet(s) and variable sheet. */
 560 void
 561 psppire_data_editor_set_font (PsppireDataEditor *de, PangoFontDescription *font_desc)
 562 {
 563   gchar *font_name;
 564   set_font_recursively (GTK_WIDGET (de), font_desc);
 565
 566   if (de->font)
 567     pango_font_description_free (de->font);
 568   de->font = pango_font_description_copy (font_desc);
 569   font_name = pango_font_description_to_string (de->font);
 570
 571   psppire_conf_set_string (psppire_conf_new (),
 572                            "Data Editor", "font",
 573                            font_name);
 574   g_free (font_name);
 575 }
 576
 577 /* If SPLIT is TRUE, splits DE's data sheet into four panes.
 578    If SPLIT is FALSE, un-splits it into a single pane. */
 579 void
 580 psppire_data_editor_split_window (PsppireDataEditor *de, gboolean split)
 581 {
 582   g_object_set (de, "split", split, NULL);
 583 }
 584
 585 /* Makes the variable with dictionary index DICT_INDEX in DE's dictionary
 586    visible and selected in the active view in DE. */
 587 void
 588 psppire_data_editor_goto_variable (PsppireDataEditor *de, gint dict_index)
 589 {
 590   gint page = gtk_notebook_get_current_page (GTK_NOTEBOOK (de));
 591
 592   switch (page)
 593     {
 594       case PSPPIRE_DATA_EDITOR_DATA_VIEW:
 595         jmd_sheet_scroll_to (JMD_SHEET (de->data_sheet), dict_index, -1);
 596         jmd_sheet_set_active_cell (JMD_SHEET (de->data_sheet), dict_index, -1, NULL);
 597         break;
 598       case PSPPIRE_DATA_EDITOR_VARIABLE_VIEW:
 599         jmd_sheet_scroll_to (JMD_SHEET (de->var_sheet), -1, dict_index);
 600         jmd_sheet_set_active_cell (JMD_SHEET (de->var_sheet), -1, dict_index, NULL);
 601         break;
 602     }
 603 }
 604
 605 /* Set the datum at COL, ROW, to that contained in VALUE.
 606  */
 607 static void
 608 store_set_datum (GtkTreeModel *model, gint col, gint row,
 609                          const GValue *value)
 610 {
 611   PsppireDataStore *store = PSPPIRE_DATA_STORE (model);
 612   GVariant *v = g_value_get_variant (value);
 613   union value uv;
 614   value_variant_get (&uv, v);
 615   const struct variable *var = psppire_dict_get_variable (store->dict, col);
 616   psppire_data_store_set_value (store, row, var, &uv);
 617   value_destroy_from_variant (&uv, v);
 618 }
 619
 620 void
 621 psppire_data_editor_paste (PsppireDataEditor *de)
 622 {
 623   JmdSheet *sheet = JMD_SHEET (de->data_sheet);
 624   GtkClipboard *clip =
 625     gtk_clipboard_get_for_display (gtk_widget_get_display (GTK_WIDGET (sheet)),
 626                                    GDK_SELECTION_CLIPBOARD);
 627
 628   jmd_sheet_paste (sheet, clip, store_set_datum);
 629 }