1 /* PSPPIRE - a graphical user interface for PSPP.
2 Copyright (C) 2006, 2008, 2009, 2010, 2011, 2012,
3 2013, 2016, 2017 Free Software Foundation
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.
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.
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/>. */
22 #define _(msgid) gettext (msgid)
23 #define P_(msgid) msgid
25 #include <data/datasheet.h>
26 #include <data/data-out.h>
27 #include <data/variable.h>
29 #include <ui/gui/psppire-marshal.h>
31 #include <pango/pango-context.h>
33 #include "psppire-data-store.h"
34 #include <libpspp/i18n.h>
37 #include <data/dictionary.h>
38 #include <data/missing-values.h>
39 #include <data/value-labels.h>
40 #include <data/data-in.h>
41 #include <data/format.h>
43 #include <math/sort.h>
47 #include "value-variant.h"
49 static void psppire_data_store_finalize (GObject *object);
50 static void psppire_data_store_dispose (GObject *object);
52 static gboolean psppire_data_store_insert_case (PsppireDataStore *ds,
57 static gboolean psppire_data_store_data_in (PsppireDataStore *ds,
58 casenumber casenum, gint idx,
59 struct substring input,
62 static GObjectClass *parent_class = NULL;
72 static guint signals [n_SIGNALS];
75 __tree_model_iter_n_children (GtkTreeModel *tree_model,
78 PsppireDataStore *store = PSPPIRE_DATA_STORE (tree_model);
80 if (store->datasheet == NULL)
83 gint n = datasheet_get_n_rows (store->datasheet);
88 static GtkTreeModelFlags
89 __tree_model_get_flags (GtkTreeModel *model)
91 g_return_val_if_fail (PSPPIRE_IS_DATA_STORE (model), (GtkTreeModelFlags) 0);
93 return GTK_TREE_MODEL_LIST_ONLY;
97 __tree_model_get_n_columns (GtkTreeModel *tree_model)
99 PsppireDataStore *store = PSPPIRE_DATA_STORE (tree_model);
101 return psppire_dict_get_n_vars (store->dict);
106 __iter_nth_child (GtkTreeModel *tree_model,
111 PsppireDataStore *store = PSPPIRE_DATA_STORE (tree_model);
113 g_assert (parent == NULL);
114 g_return_val_if_fail (store, FALSE);
116 if (!store->datasheet || n >= datasheet_get_n_rows (store->datasheet))
119 iter->user_data = NULL;
123 iter->user_data = GINT_TO_POINTER (n);
124 iter->stamp = store->stamp;
129 /* Set the contents of OUT to reflect the information provided by IN, COL, and
130 ROW, for MODEL. Returns TRUE if successful. */
132 psppire_data_store_string_to_value (GtkTreeModel *model, gint col, gint row,
133 const gchar *in, GValue *out)
135 PsppireDataStore *store = PSPPIRE_DATA_STORE (model);
137 while (col >= psppire_dict_get_n_vars (store->dict))
139 const struct variable *var =
140 psppire_dict_insert_variable (store->dict,
141 psppire_dict_get_n_vars (store->dict),
143 g_return_val_if_fail (var, FALSE);
146 const struct variable *variable = psppire_dict_get_variable (store->dict, col);
147 g_return_val_if_fail (variable, FALSE);
149 struct fmt_spec fmt = var_get_print_format (variable);
151 int width = var_get_width (variable);
154 value_init (&val, width);
155 const struct val_labs *value_labels = var_get_value_labels (variable);
156 const union value *vp = NULL;
159 vp = val_labs_find_value (value_labels, in);
161 value_copy (&val, vp, width);
166 xx = data_in (ss_cstr (in), psppire_dict_encoding (store->dict),
167 fmt.type, settings_get_fmt_settings (),
168 &val, width, "UTF-8");
171 GVariant *vrnt = value_variant_new (&val, width);
172 value_destroy (&val, width);
174 g_value_init (out, G_TYPE_VARIANT);
175 g_value_set_variant (out, vrnt);
181 unlabeled_value (PsppireDataStore *store, const struct variable *variable, const union value *val)
183 if (var_is_numeric (variable) &&
184 var_is_value_missing (variable, val) == MV_SYSTEM)
185 return g_strdup ("");
187 struct fmt_spec fmt = var_get_print_format (variable);
188 return value_to_text__ (*val, fmt, psppire_dict_encoding (store->dict));
192 psppire_data_store_value_to_string (gpointer unused, PsppireDataStore *store, gint col, gint row, const GValue *v)
194 const struct variable *variable = psppire_dict_get_variable (store->dict, col);
195 g_return_val_if_fail (variable, g_strdup ("???"));
197 GVariant *vrnt = g_value_get_variant (v);
198 g_return_val_if_fail (vrnt, g_strdup ("???"));
201 value_variant_get (&val, vrnt);
203 char *out = unlabeled_value (store, variable, &val);
205 value_destroy_from_variant (&val, vrnt);
211 psppire_data_store_value_to_string_with_labels (gpointer unused, PsppireDataStore *store, gint col, gint row, const GValue *v)
213 const struct variable *variable = psppire_dict_get_variable (store->dict, col);
214 g_return_val_if_fail (variable, g_strdup ("???"));
216 GVariant *vrnt = g_value_get_variant (v);
218 value_variant_get (&val, vrnt);
222 const struct val_labs *vls = var_get_value_labels (variable);
223 struct val_lab *vl = val_labs_lookup (vls, &val);
225 out = strdup (val_lab_get_label (vl));
227 out = unlabeled_value (store, variable, &val);
229 value_destroy_from_variant (&val, vrnt);
235 __get_value (GtkTreeModel *tree_model,
240 PsppireDataStore *store = PSPPIRE_DATA_STORE (tree_model);
242 g_return_if_fail (iter->stamp == store->stamp);
244 const struct variable *variable = psppire_dict_get_variable (store->dict, column);
245 if (NULL == variable)
248 gint row = GPOINTER_TO_INT (iter->user_data);
250 struct ccase *cc = datasheet_get_row (store->datasheet, row);
252 g_return_if_fail (cc);
254 g_value_init (value, G_TYPE_VARIANT);
256 const union value *val = case_data_idx (cc, var_get_dict_index (variable));
258 GVariant *vv = value_variant_new (val, var_get_width (variable));
260 g_value_set_variant (value, vv);
267 __tree_model_init (GtkTreeModelIface *iface)
269 iface->get_flags = __tree_model_get_flags;
270 iface->get_n_columns = __tree_model_get_n_columns ;
271 iface->get_column_type = NULL;
272 iface->get_iter = NULL;
273 iface->iter_next = NULL;
274 iface->get_path = NULL;
275 iface->get_value = __get_value;
277 iface->iter_children = NULL;
278 iface->iter_has_child = NULL;
279 iface->iter_n_children = __tree_model_iter_n_children;
280 iface->iter_nth_child = __iter_nth_child;
281 iface->iter_parent = NULL;
284 G_DEFINE_TYPE_WITH_CODE (PsppireDataStore, psppire_data_store, G_TYPE_OBJECT,
285 G_IMPLEMENT_INTERFACE (GTK_TYPE_TREE_MODEL,
289 psppire_data_store_class_init (PsppireDataStoreClass *class)
291 GObjectClass *object_class;
293 parent_class = g_type_class_peek_parent (class);
294 object_class = G_OBJECT_CLASS (class);
296 object_class->finalize = psppire_data_store_finalize;
297 object_class->dispose = psppire_data_store_dispose;
299 signals [ITEMS_CHANGED] =
300 g_signal_new ("items-changed",
301 G_TYPE_FROM_CLASS (class),
305 psppire_marshal_VOID__UINT_UINT_UINT,
308 G_TYPE_UINT, /* Index of the start of the change */
309 G_TYPE_UINT, /* The number of items deleted */
310 G_TYPE_UINT); /* The number of items inserted */
312 signals [CASE_CHANGED] =
313 g_signal_new ("case-changed",
314 G_TYPE_FROM_CLASS (class),
318 g_cclosure_marshal_VOID__INT,
327 psppire_data_store_get_case_count (const PsppireDataStore *store)
329 return datasheet_get_n_rows (store->datasheet);
333 psppire_data_store_get_value_count (const PsppireDataStore *store)
335 return psppire_dict_get_n_vars (store->dict);
338 const struct caseproto *
339 psppire_data_store_get_proto (const PsppireDataStore *store)
341 return psppire_dict_get_proto (store->dict);
345 psppire_data_store_init (PsppireDataStore *data_store)
347 data_store->dict = NULL;
348 data_store->datasheet = NULL;
349 data_store->dispose_has_run = FALSE;
350 data_store->stamp = g_random_int ();
355 psppire_data_store_delete_values (PsppireDataStore *store, gint case_index,
358 g_return_if_fail (store->datasheet);
359 g_return_if_fail (case_index < datasheet_get_n_columns (store->datasheet));
361 datasheet_delete_columns (store->datasheet, case_index, n);
366 A callback which occurs after variables have been deleted.
369 delete_variables_callback (GObject *obj, gint dict_index, unsigned int n, gpointer data)
371 PsppireDataStore *store = PSPPIRE_DATA_STORE (data);
373 psppire_data_store_delete_values (store, dict_index, n);
377 A callback which occurs after variables have been deleted.
380 move_variable_callback (GObject *obj, gint new_dict_index, int old_dict_index, gpointer data)
382 PsppireDataStore *store = PSPPIRE_DATA_STORE (data);
384 datasheet_move_columns (store->datasheet, old_dict_index, new_dict_index, 1);
387 struct resize_datum_aux
389 const struct dictionary *dict;
390 const struct variable *new_variable;
391 const struct variable *old_variable;
395 resize_datum (const union value *old, union value *new, const void *aux_)
397 const struct resize_datum_aux *aux = aux_;
398 int new_width = var_get_width (aux->new_variable);
399 const char *enc = dict_get_encoding (aux->dict);
400 struct fmt_spec newfmt = var_get_print_format (aux->new_variable);
401 char *s = data_out (old, enc, var_get_print_format (aux->old_variable),
402 settings_get_fmt_settings ());
403 enum fmt_type type = (fmt_usable_for_input (newfmt.type)
406 free (data_in (ss_cstr (s), enc, type, settings_get_fmt_settings (),
407 new, new_width, enc));
412 variable_changed_callback (GObject *obj, gint var_num, guint what, const struct variable *oldvar,
415 PsppireDataStore *store = PSPPIRE_DATA_STORE (data);
416 struct variable *variable = psppire_dict_get_variable (store->dict, var_num);
418 if (what & VAR_TRAIT_WIDTH)
420 int posn = var_get_dict_index (variable);
421 struct resize_datum_aux aux;
422 aux.old_variable = oldvar;
423 aux.new_variable = variable;
424 aux.dict = store->dict->dict;
425 datasheet_resize_column (store->datasheet, posn, var_get_width (variable),
431 insert_variable_callback (GObject *obj, gint var_num, gpointer data)
433 struct variable *variable;
434 PsppireDataStore *store;
437 g_return_if_fail (data);
439 store = PSPPIRE_DATA_STORE (data);
441 variable = psppire_dict_get_variable (store->dict, var_num);
442 posn = var_get_dict_index (variable);
443 psppire_data_store_insert_value (store, var_get_width (variable), posn);
447 * psppire_data_store_new:
448 * @dict: The dictionary for this data_store.
451 * Return value: a new #PsppireDataStore
454 psppire_data_store_new (PsppireDict *dict)
456 PsppireDataStore *retval;
458 retval = g_object_new (PSPPIRE_TYPE_DATA_STORE, NULL);
460 psppire_data_store_set_dictionary (retval, dict);
466 psppire_data_store_set_reader (PsppireDataStore *ds,
467 struct casereader *reader)
473 old_n = datasheet_get_n_rows (ds->datasheet);
474 datasheet_destroy (ds->datasheet);
477 ds->datasheet = datasheet_create (reader);
479 gint new_n = datasheet_get_n_rows (ds->datasheet);
482 for (i = 0 ; i < n_dict_signals; ++i)
484 if (ds->dict_handler_id [i] > 0)
486 g_signal_handler_unblock (ds->dict,
487 ds->dict_handler_id[i]);
491 g_signal_emit (ds, signals[ITEMS_CHANGED], 0, 0, old_n, new_n);
496 * psppire_data_store_replace_set_dictionary:
497 * @data_store: The variable store
498 * @dict: The dictionary to set
500 * If a dictionary is already associated with the data-store, then it will be
504 psppire_data_store_set_dictionary (PsppireDataStore *data_store, PsppireDict *dict)
508 /* Disconnect any existing handlers */
509 if (data_store->dict)
510 for (i = 0 ; i < n_dict_signals; ++i)
512 g_signal_handler_disconnect (data_store->dict,
513 data_store->dict_handler_id[i]);
516 data_store->dict = dict;
521 data_store->dict_handler_id [VARIABLE_INSERTED] =
522 g_signal_connect (dict, "variable-inserted",
523 G_CALLBACK (insert_variable_callback),
526 data_store->dict_handler_id [VARIABLES_DELETED] =
527 g_signal_connect (dict, "variables-deleted",
528 G_CALLBACK (delete_variables_callback),
531 data_store->dict_handler_id [VARIABLE_MOVED] =
532 g_signal_connect (dict, "variable-moved",
533 G_CALLBACK (move_variable_callback),
536 data_store->dict_handler_id [VARIABLE_CHANGED] =
537 g_signal_connect (dict, "variable-changed",
538 G_CALLBACK (variable_changed_callback),
544 /* The entire model has changed */
546 if (data_store->dict)
547 for (i = 0 ; i < n_dict_signals; ++i)
549 if (data_store->dict_handler_id [i] > 0)
551 g_signal_handler_block (data_store->dict,
552 data_store->dict_handler_id[i]);
558 psppire_data_store_finalize (GObject *object)
560 PsppireDataStore *ds = PSPPIRE_DATA_STORE (object);
564 datasheet_destroy (ds->datasheet);
565 ds->datasheet = NULL;
569 (* parent_class->finalize) (object);
574 psppire_data_store_dispose (GObject *object)
576 PsppireDataStore *ds = PSPPIRE_DATA_STORE (object);
578 if (ds->dispose_has_run)
581 psppire_data_store_set_dictionary (ds, NULL);
584 (* parent_class->dispose) (object);
586 ds->dispose_has_run = TRUE;
591 /* Insert a blank case before POSN */
593 psppire_data_store_insert_new_case (PsppireDataStore *ds, casenumber posn)
596 const struct caseproto *proto;
598 g_return_val_if_fail (ds, FALSE);
600 proto = datasheet_get_proto (ds->datasheet);
601 g_return_val_if_fail (caseproto_get_n_widths (proto) > 0, FALSE);
602 g_return_val_if_fail (posn <= psppire_data_store_get_case_count (ds), FALSE);
604 cc = case_create (proto);
605 case_set_missing (cc);
607 result = psppire_data_store_insert_case (ds, cc, posn);
615 psppire_data_store_get_value (PsppireDataStore *store,
616 glong row, const struct variable *var,
619 g_return_val_if_fail (store != NULL, FALSE);
620 g_return_val_if_fail (store->datasheet != NULL, FALSE);
621 g_return_val_if_fail (var != NULL, FALSE);
623 if (row < 0 || row >= datasheet_get_n_rows (store->datasheet))
626 int width = var_get_width (var);
627 value_init (val, width);
628 datasheet_get_value (store->datasheet, row, var_get_dict_index (var), val);
636 psppire_data_store_get_string (PsppireDataStore *store,
637 glong row, const struct variable *var,
638 bool use_value_label)
642 int width = var_get_width (var);
643 if (! psppire_data_store_get_value (store, row, var, &v))
649 const char *label = var_lookup_value_label (var, &v);
651 string = g_strdup (label);
654 string = value_to_text (v, var);
656 value_destroy (&v, width);
662 /* Attempts to update that part of the variable store which corresponds to VAR
663 within ROW with the value TEXT.
665 If USE_VALUE_LABEL is true, and TEXT is a value label for the column's
666 variable, then stores the value from that value label instead of the literal
669 Returns true if anything was updated, false otherwise. */
671 psppire_data_store_set_string (PsppireDataStore *store,
673 glong row, const struct variable *var,
674 gboolean use_value_label)
680 n_cases = psppire_data_store_get_case_count (store);
684 psppire_data_store_insert_new_case (store, row);
686 case_index = var_get_dict_index (var);
689 const struct val_labs *vls = var_get_value_labels (var);
690 const union value *value = vls ? val_labs_find_value (vls, text) : NULL;
692 ok = datasheet_put_value (store->datasheet, row, case_index, value);
697 ok = psppire_data_store_data_in (store, row, case_index, ss_cstr (text),
698 var_get_print_format (var));
701 g_signal_emit (store, signals [CASE_CHANGED], 0, row);
708 psppire_data_store_clear (PsppireDataStore *ds)
710 datasheet_destroy (ds->datasheet);
711 ds->datasheet = NULL;
713 psppire_dict_clear (ds->dict);
715 g_signal_emit (ds, signals [ITEMS_CHANGED], 0, 0, -1, 0);
720 /* Return a casereader made from this datastore */
722 psppire_data_store_get_reader (PsppireDataStore *ds)
724 struct casereader *reader ;
727 for (int i = 0 ; i < n_dict_signals; ++i)
729 g_signal_handler_block (ds->dict,
730 ds->dict_handler_id[i]);
733 reader = datasheet_make_reader (ds->datasheet);
735 /* We must not reference this again */
736 ds->datasheet = NULL;
741 /* Returns the CASENUMth case, or a null pointer on failure.
744 psppire_data_store_get_case (const PsppireDataStore *ds,
747 g_return_val_if_fail (ds, FALSE);
748 g_return_val_if_fail (ds->datasheet, FALSE);
750 return datasheet_get_row (ds->datasheet, casenum);
755 psppire_data_store_delete_cases (PsppireDataStore *ds, casenumber first,
758 g_return_val_if_fail (ds, FALSE);
759 g_return_val_if_fail (ds->datasheet, FALSE);
761 g_return_val_if_fail (first + n_cases <=
762 psppire_data_store_get_case_count (ds), FALSE);
765 datasheet_delete_rows (ds->datasheet, first, n_cases);
767 g_signal_emit (ds, signals[ITEMS_CHANGED], 0, first, n_cases, 0);
774 /* Insert case CC into the case file before POSN */
776 psppire_data_store_insert_case (PsppireDataStore *ds,
782 g_return_val_if_fail (ds, FALSE);
783 g_return_val_if_fail (ds->datasheet, FALSE);
786 result = datasheet_insert_rows (ds->datasheet, posn, &cc, 1);
790 g_signal_emit (ds, signals[ITEMS_CHANGED], 0, posn, 0, 1);
793 g_warning ("Cannot insert case at position %ld\n", posn);
799 /* Set the value of VAR in case CASENUM to V.
800 V must be the correct width for IDX.
801 Returns true if successful, false on I/O error. */
803 psppire_data_store_set_value (PsppireDataStore *ds, casenumber casenum,
804 const struct variable *var, const union value *v)
809 g_return_val_if_fail (ds, FALSE);
810 g_return_val_if_fail (ds->datasheet, FALSE);
812 n_cases = psppire_data_store_get_case_count (ds);
813 if (casenum > n_cases)
816 if (casenum == n_cases)
817 psppire_data_store_insert_new_case (ds, casenum);
819 ok = datasheet_put_value (ds->datasheet, casenum, var_get_dict_index (var),
823 g_signal_emit (ds, signals [CASE_CHANGED], 0, casenum);
824 g_signal_emit (ds, signals [ITEMS_CHANGED], 0, casenum, 1, 1);
833 /* Set the IDXth value of case C using D_IN */
835 psppire_data_store_data_in (PsppireDataStore *ds, casenumber casenum, gint idx,
836 struct substring input, struct fmt_spec fmt)
844 g_return_val_if_fail (ds, FALSE);
845 g_return_val_if_fail (ds->datasheet, FALSE);
847 g_return_val_if_fail (idx < datasheet_get_n_columns (ds->datasheet), FALSE);
851 width = fmt_var_width (fmt);
852 g_return_val_if_fail (caseproto_get_width (
853 datasheet_get_proto (ds->datasheet), idx) == width,
855 value_init (&value, width);
856 ok = (datasheet_get_value (ds->datasheet, casenum, idx, &value)
857 && data_in_msg (input, UTF8, fmt.type, settings_get_fmt_settings (),
858 &value, width, dict_get_encoding (dict->dict))
859 && datasheet_put_value (ds->datasheet, casenum, idx, &value));
860 value_destroy (&value, width);
865 /* Resize the cases in the casefile, by inserting a value of the
866 given WIDTH into every one of them at the position immediately
870 psppire_data_store_insert_value (PsppireDataStore *ds,
871 gint width, gint where)
875 g_return_val_if_fail (ds, FALSE);
877 g_assert (width >= 0);
880 ds->datasheet = datasheet_create (NULL);
882 value_init (&value, width);
883 value_set_missing (&value, width);
885 datasheet_insert_column (ds->datasheet, &value, width, where);
886 value_destroy (&value, width);
892 psppire_data_store_filtered (PsppireDataStore *ds,
897 const struct dictionary *dict;
898 const struct variable *filter;
900 if (row < 0 || row >= datasheet_get_n_rows (ds->datasheet))
903 dict = ds->dict->dict;
904 g_return_val_if_fail (dict, FALSE);
905 filter = dict_get_filter (dict);
909 g_return_val_if_fail (var_is_numeric (filter), FALSE);
910 value_init (&val, 0);
911 if (! datasheet_get_value (ds->datasheet, row,
912 var_get_dict_index (filter),
916 return (val.f == 0.0);