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 N_(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>
48 #include "value-variant.h"
50 static void psppire_data_store_init (PsppireDataStore *data_store);
51 static void psppire_data_store_class_init (PsppireDataStoreClass *class);
53 static void psppire_data_store_finalize (GObject *object);
54 static void psppire_data_store_dispose (GObject *object);
56 static gboolean psppire_data_store_insert_case (PsppireDataStore *ds,
61 static gboolean psppire_data_store_data_in (PsppireDataStore *ds,
62 casenumber casenum, gint idx,
63 struct substring input,
64 const struct fmt_spec *fmt);
66 static GObjectClass *parent_class = NULL;
77 static guint signals [n_SIGNALS];
80 __tree_model_iter_n_children (GtkTreeModel *tree_model,
83 PsppireDataStore *store = PSPPIRE_DATA_STORE (tree_model);
85 gint n = datasheet_get_n_rows (store->datasheet);
90 static GtkTreeModelFlags
91 __tree_model_get_flags (GtkTreeModel *model)
93 g_return_val_if_fail (PSPPIRE_IS_DATA_STORE (model), (GtkTreeModelFlags) 0);
95 return GTK_TREE_MODEL_LIST_ONLY;
99 __tree_model_get_n_columns (GtkTreeModel *tree_model)
101 PsppireDataStore *store = PSPPIRE_DATA_STORE (tree_model);
103 return psppire_dict_get_value_cnt (store->dict);
108 __iter_nth_child (GtkTreeModel *tree_model,
113 PsppireDataStore *store = PSPPIRE_DATA_STORE (tree_model);
115 g_assert (parent == NULL);
117 g_return_val_if_fail (store, FALSE);
118 g_return_val_if_fail (store->datasheet, FALSE);
120 if (n >= datasheet_get_n_rows (store->datasheet))
123 iter->user_data = NULL;
127 iter->user_data = GINT_TO_POINTER (n);
128 iter->stamp = store->stamp;
134 myreversefunc (GtkTreeModel *model, gint col, gint row,
135 const gchar *in, GValue *out)
137 PsppireDataStore *store = PSPPIRE_DATA_STORE (model);
139 const struct variable *variable = psppire_dict_get_variable (store->dict, col);
140 g_return_if_fail (variable);
142 const struct fmt_spec *fmt = var_get_print_format (variable);
144 int width = var_get_width (variable);
147 value_init (&val, width);
149 data_in (ss_cstr (in), psppire_dict_encoding (store->dict),
150 fmt->type, &val, width, "UTF-8");
152 GVariant *vrnt = value_variant_new (&val, width);
153 value_destroy (&val, width);
155 g_value_init (out, G_TYPE_VARIANT);
156 g_value_set_variant (out, vrnt);
161 myconvfunc (GtkTreeModel *model, gint col, gint row, const GValue *v)
163 PsppireDataStore *store = PSPPIRE_DATA_STORE (model);
165 const struct variable *variable = psppire_dict_get_variable (store->dict, col);
166 g_return_val_if_fail (variable, g_strdup ("???"));
168 GVariant *vrnt = g_value_get_variant (v);
170 value_variant_get (&val, vrnt);
172 const struct fmt_spec *fmt = var_get_print_format (variable);
173 char *out = data_out (&val, psppire_dict_encoding (store->dict), fmt);
174 value_destroy_from_variant (&val, vrnt);
180 __get_value (GtkTreeModel *tree_model,
185 PsppireDataStore *store = PSPPIRE_DATA_STORE (tree_model);
187 g_return_if_fail (iter->stamp == store->stamp);
189 const struct variable *variable = psppire_dict_get_variable (store->dict, column);
190 if (NULL == variable)
193 g_value_init (value, G_TYPE_VARIANT);
195 gint row = GPOINTER_TO_INT (iter->user_data);
197 struct ccase *cc = datasheet_get_row (store->datasheet, row);
199 const union value *val = case_data_idx (cc, column);
201 GVariant *vv = value_variant_new (val, var_get_width (variable));
203 g_value_set_variant (value, vv);
210 __tree_model_init (GtkTreeModelIface *iface)
212 iface->get_flags = __tree_model_get_flags;
213 iface->get_n_columns = __tree_model_get_n_columns ;
214 iface->get_column_type = NULL;
215 iface->get_iter = NULL;
216 iface->iter_next = NULL;
217 iface->get_path = NULL;
218 iface->get_value = __get_value;
220 iface->iter_children = NULL;
221 iface->iter_has_child = NULL;
222 iface->iter_n_children = __tree_model_iter_n_children;
223 iface->iter_nth_child = __iter_nth_child;
224 iface->iter_parent = NULL;
229 psppire_data_store_get_type (void)
231 static GType data_store_type = 0;
233 if (!data_store_type)
235 static const GTypeInfo data_store_info =
237 sizeof (PsppireDataStoreClass),
238 NULL, /* base_init */
239 NULL, /* base_finalize */
240 (GClassInitFunc) psppire_data_store_class_init,
241 NULL, /* class_finalize */
242 NULL, /* class_data */
243 sizeof (PsppireDataStore),
245 (GInstanceInitFunc) psppire_data_store_init,
248 static const GInterfaceInfo tree_model_info = {
249 (GInterfaceInitFunc) __tree_model_init,
254 data_store_type = g_type_register_static (G_TYPE_OBJECT,
256 &data_store_info, 0);
258 g_type_add_interface_static (data_store_type, GTK_TYPE_TREE_MODEL,
262 return data_store_type;
267 psppire_data_store_class_init (PsppireDataStoreClass *class)
269 GObjectClass *object_class;
271 parent_class = g_type_class_peek_parent (class);
272 object_class = (GObjectClass*) class;
274 object_class->finalize = psppire_data_store_finalize;
275 object_class->dispose = psppire_data_store_dispose;
277 signals [ITEMS_CHANGED] =
278 g_signal_new ("changed",
279 G_TYPE_FROM_CLASS (class),
283 psppire_marshal_VOID__UINT_UINT_UINT,
290 signals [CASE_CHANGED] =
291 g_signal_new ("case-changed",
292 G_TYPE_FROM_CLASS (class),
296 g_cclosure_marshal_VOID__INT,
301 signals [CASES_DELETED] =
302 g_signal_new ("cases-deleted",
303 G_TYPE_FROM_CLASS (class),
307 psppire_marshal_VOID__INT_INT,
317 psppire_data_store_insert_value (PsppireDataStore *ds,
318 gint width, gint where);
321 psppire_data_store_get_case_count (const PsppireDataStore *store)
323 return datasheet_get_n_rows (store->datasheet);
327 psppire_data_store_get_value_count (const PsppireDataStore *store)
329 return psppire_dict_get_value_cnt (store->dict);
332 const struct caseproto *
333 psppire_data_store_get_proto (const PsppireDataStore *store)
335 return psppire_dict_get_proto (store->dict);
339 psppire_data_store_init (PsppireDataStore *data_store)
341 data_store->dict = NULL;
342 data_store->datasheet = NULL;
343 data_store->dispose_has_run = FALSE;
344 data_store->stamp = g_random_int ();
348 A callback which occurs after a variable has been deleted.
351 delete_variable_callback (GObject *obj, const struct variable *var UNUSED,
352 gint dict_index, gint case_index,
355 PsppireDataStore *store = PSPPIRE_DATA_STORE (data);
357 g_return_if_fail (store->datasheet);
359 datasheet_delete_columns (store->datasheet, case_index, 1);
360 datasheet_insert_column (store->datasheet, NULL, -1, case_index);
363 struct resize_datum_aux
365 const struct dictionary *dict;
366 const struct variable *new_variable;
367 const struct variable *old_variable;
371 resize_datum (const union value *old, union value *new, const void *aux_)
373 const struct resize_datum_aux *aux = aux_;
374 int new_width = var_get_width (aux->new_variable);
375 const char *enc = dict_get_encoding (aux->dict);
376 const struct fmt_spec *newfmt = var_get_print_format (aux->new_variable);
377 char *s = data_out (old, enc, var_get_print_format (aux->old_variable));
378 enum fmt_type type = (fmt_usable_for_input (newfmt->type)
381 free (data_in (ss_cstr (s), enc, type, new, new_width, enc));
386 variable_changed_callback (GObject *obj, gint var_num, guint what, const struct variable *oldvar,
389 PsppireDataStore *store = PSPPIRE_DATA_STORE (data);
390 struct variable *variable = psppire_dict_get_variable (store->dict, var_num);
392 if (what & VAR_TRAIT_WIDTH)
394 int posn = var_get_case_index (variable);
395 struct resize_datum_aux aux;
396 aux.old_variable = oldvar;
397 aux.new_variable = variable;
398 aux.dict = store->dict->dict;
399 datasheet_resize_column (store->datasheet, posn, var_get_width (variable),
405 insert_variable_callback (GObject *obj, gint var_num, gpointer data)
407 struct variable *variable;
408 PsppireDataStore *store;
411 g_return_if_fail (data);
413 store = PSPPIRE_DATA_STORE (data);
415 variable = psppire_dict_get_variable (store->dict, var_num);
416 posn = var_get_case_index (variable);
417 psppire_data_store_insert_value (store, var_get_width (variable), posn);
421 * psppire_data_store_new:
422 * @dict: The dictionary for this data_store.
425 * Return value: a new #PsppireDataStore
428 psppire_data_store_new (PsppireDict *dict)
430 PsppireDataStore *retval;
432 retval = g_object_new (PSPPIRE_TYPE_DATA_STORE, NULL);
434 psppire_data_store_set_dictionary (retval, dict);
440 psppire_data_store_set_reader (PsppireDataStore *ds,
441 struct casereader *reader)
447 old_n = datasheet_get_n_rows (ds->datasheet);
448 datasheet_destroy (ds->datasheet);
451 ds->datasheet = datasheet_create (reader);
453 gint new_n = datasheet_get_n_rows (ds->datasheet);
456 for (i = 0 ; i < n_dict_signals; ++i )
458 if ( ds->dict_handler_id [i] > 0)
460 g_signal_handler_unblock (ds->dict,
461 ds->dict_handler_id[i]);
465 g_signal_emit (ds, signals[ITEMS_CHANGED], 0, 0, old_n, new_n);
470 * psppire_data_store_replace_set_dictionary:
471 * @data_store: The variable store
472 * @dict: The dictionary to set
474 * If a dictionary is already associated with the data-store, then it will be
478 psppire_data_store_set_dictionary (PsppireDataStore *data_store, PsppireDict *dict)
482 /* Disconnect any existing handlers */
483 if ( data_store->dict )
484 for (i = 0 ; i < n_dict_signals; ++i )
486 g_signal_handler_disconnect (data_store->dict,
487 data_store->dict_handler_id[i]);
490 data_store->dict = dict;
495 data_store->dict_handler_id [VARIABLE_INSERTED] =
496 g_signal_connect (dict, "variable-inserted",
497 G_CALLBACK (insert_variable_callback),
500 data_store->dict_handler_id [VARIABLE_DELETED] =
501 g_signal_connect (dict, "variable-deleted",
502 G_CALLBACK (delete_variable_callback),
505 data_store->dict_handler_id [VARIABLE_CHANGED] =
506 g_signal_connect (dict, "variable-changed",
507 G_CALLBACK (variable_changed_callback),
513 /* The entire model has changed */
515 if ( data_store->dict )
516 for (i = 0 ; i < n_dict_signals; ++i )
518 if ( data_store->dict_handler_id [i] > 0)
520 g_signal_handler_block (data_store->dict,
521 data_store->dict_handler_id[i]);
527 psppire_data_store_finalize (GObject *object)
529 PsppireDataStore *ds = PSPPIRE_DATA_STORE (object);
533 datasheet_destroy (ds->datasheet);
534 ds->datasheet = NULL;
538 (* parent_class->finalize) (object);
543 psppire_data_store_dispose (GObject *object)
545 PsppireDataStore *ds = PSPPIRE_DATA_STORE (object);
547 if (ds->dispose_has_run)
550 psppire_data_store_set_dictionary (ds, NULL);
553 (* parent_class->dispose) (object);
555 ds->dispose_has_run = TRUE;
560 /* Insert a blank case before POSN */
562 psppire_data_store_insert_new_case (PsppireDataStore *ds, casenumber posn)
565 const struct caseproto *proto;
567 g_return_val_if_fail (ds, FALSE);
569 proto = datasheet_get_proto (ds->datasheet);
570 g_return_val_if_fail (caseproto_get_n_widths (proto) > 0, FALSE);
571 g_return_val_if_fail (posn <= psppire_data_store_get_case_count (ds), FALSE);
573 cc = case_create (proto);
574 case_set_missing (cc);
576 result = psppire_data_store_insert_case (ds, cc, posn);
584 psppire_data_store_get_value (PsppireDataStore *store,
585 glong row, const struct variable *var,
588 g_return_val_if_fail (store != NULL, FALSE);
589 g_return_val_if_fail (store->datasheet != NULL, FALSE);
590 g_return_val_if_fail (var != NULL, FALSE);
592 if (row < 0 || row >= datasheet_get_n_rows (store->datasheet))
595 int width = var_get_width (var);
596 value_init (val, width);
597 datasheet_get_value (store->datasheet, row, var_get_case_index (var), val);
605 psppire_data_store_get_string (PsppireDataStore *store,
606 glong row, const struct variable *var,
607 bool use_value_label)
611 int width = var_get_width (var);
612 if (! psppire_data_store_get_value (store, row, var, &v))
618 const char *label = var_lookup_value_label (var, &v);
620 string = g_strdup (label);
623 string = value_to_text (v, var);
625 value_destroy (&v, width);
631 /* Attempts to update that part of the variable store which corresponds to VAR
632 within ROW with the value TEXT.
634 If USE_VALUE_LABEL is true, and TEXT is a value label for the column's
635 variable, then stores the value from that value label instead of the literal
638 Returns true if anything was updated, false otherwise. */
640 psppire_data_store_set_string (PsppireDataStore *store,
642 glong row, const struct variable *var,
643 gboolean use_value_label)
649 n_cases = psppire_data_store_get_case_count (store);
653 psppire_data_store_insert_new_case (store, row);
655 case_index = var_get_case_index (var);
658 const struct val_labs *vls = var_get_value_labels (var);
659 const union value *value = vls ? val_labs_find_value (vls, text) : NULL;
661 ok = datasheet_put_value (store->datasheet, row, case_index, value);
666 ok = psppire_data_store_data_in (store, row, case_index, ss_cstr (text),
667 var_get_print_format (var));
670 g_signal_emit (store, signals [CASE_CHANGED], 0, row);
677 psppire_data_store_clear (PsppireDataStore *ds)
679 datasheet_destroy (ds->datasheet);
680 ds->datasheet = NULL;
682 psppire_dict_clear (ds->dict);
684 g_signal_emit (ds, signals [CASES_DELETED], 0, 0, -1);
689 /* Return a casereader made from this datastore */
691 psppire_data_store_get_reader (PsppireDataStore *ds)
694 struct casereader *reader ;
697 for (i = 0 ; i < n_dict_signals; ++i )
699 g_signal_handler_block (ds->dict,
700 ds->dict_handler_id[i]);
703 reader = datasheet_make_reader (ds->datasheet);
705 /* We must not reference this again */
706 ds->datasheet = NULL;
711 /* Returns the CASENUMth case, or a null pointer on failure.
714 psppire_data_store_get_case (const PsppireDataStore *ds,
717 g_return_val_if_fail (ds, FALSE);
718 g_return_val_if_fail (ds->datasheet, FALSE);
720 return datasheet_get_row (ds->datasheet, casenum);
725 psppire_data_store_delete_cases (PsppireDataStore *ds, casenumber first,
728 g_return_val_if_fail (ds, FALSE);
729 g_return_val_if_fail (ds->datasheet, FALSE);
731 g_return_val_if_fail (first + n_cases <=
732 psppire_data_store_get_case_count (ds), FALSE);
735 datasheet_delete_rows (ds->datasheet, first, n_cases);
737 g_signal_emit (ds, signals [CASES_DELETED], 0, first, n_cases);
744 /* Insert case CC into the case file before POSN */
746 psppire_data_store_insert_case (PsppireDataStore *ds,
752 g_return_val_if_fail (ds, FALSE);
753 g_return_val_if_fail (ds->datasheet, FALSE);
756 result = datasheet_insert_rows (ds->datasheet, posn, &cc, 1);
760 g_signal_emit (ds, signals[ITEMS_CHANGED], 0, posn, 0, 1);
763 g_warning ("Cannot insert case at position %ld\n", posn);
769 /* Set the value of VAR in case CASENUM to V.
770 V must be the correct width for IDX.
771 Returns true if successful, false on I/O error. */
773 psppire_data_store_set_value (PsppireDataStore *ds, casenumber casenum,
774 const struct variable *var, const union value *v)
779 g_return_val_if_fail (ds, FALSE);
780 g_return_val_if_fail (ds->datasheet, FALSE);
782 n_cases = psppire_data_store_get_case_count (ds);
783 if ( casenum > n_cases)
786 if (casenum == n_cases)
787 psppire_data_store_insert_new_case (ds, casenum);
789 ok = datasheet_put_value (ds->datasheet, casenum, var_get_case_index (var),
792 g_signal_emit (ds, signals [CASE_CHANGED], 0, casenum);
800 /* Set the IDXth value of case C using D_IN */
802 psppire_data_store_data_in (PsppireDataStore *ds, casenumber casenum, gint idx,
803 struct substring input, const struct fmt_spec *fmt)
811 g_return_val_if_fail (ds, FALSE);
812 g_return_val_if_fail (ds->datasheet, FALSE);
814 g_return_val_if_fail (idx < datasheet_get_n_columns (ds->datasheet), FALSE);
818 width = fmt_var_width (fmt);
819 g_return_val_if_fail (caseproto_get_width (
820 datasheet_get_proto (ds->datasheet), idx) == width,
822 value_init (&value, width);
823 ok = (datasheet_get_value (ds->datasheet, casenum, idx, &value)
824 && data_in_msg (input, UTF8, fmt->type, &value, width,
825 dict_get_encoding (dict->dict))
826 && datasheet_put_value (ds->datasheet, casenum, idx, &value));
827 value_destroy (&value, width);
832 /* Resize the cases in the casefile, by inserting a value of the
833 given WIDTH into every one of them at the position immediately
837 psppire_data_store_insert_value (PsppireDataStore *ds,
838 gint width, gint where)
842 g_return_val_if_fail (ds, FALSE);
844 g_assert (width >= 0);
846 if ( ! ds->datasheet )
847 ds->datasheet = datasheet_create (NULL);
849 value_init (&value, width);
850 value_set_missing (&value, width);
852 datasheet_insert_column (ds->datasheet, &value, width, where);
853 value_destroy (&value, width);
859 psppire_data_store_filtered (PsppireDataStore *ds,
864 const struct dictionary *dict;
865 const struct variable *filter;
867 if ( row < 0 || row >= datasheet_get_n_rows (ds->datasheet))
870 dict = ds->dict->dict;
871 g_return_val_if_fail (dict, FALSE);
872 filter = dict_get_filter (dict);
876 g_return_val_if_fail (var_is_numeric (filter), FALSE);
877 value_init (&val, 0);
878 if ( ! datasheet_get_value (ds->datasheet, row,
879 var_get_case_index (filter),
883 return (val.f == 0.0);