1 /* PSPPIRE - a graphical user interface for PSPP.
2 Copyright (C) 2006, 2008, 2009, 2010, 2011, 2012, 2013 Free Software Foundation
4 This program is free software: you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation, either version 3 of the License, or
7 (at your option) any later version.
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License
15 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 #define _(msgid) gettext (msgid)
22 #define N_(msgid) msgid
24 #include <data/datasheet.h>
25 #include <data/data-out.h>
26 #include <data/variable.h>
28 #include <ui/gui/psppire-marshal.h>
30 #include <pango/pango-context.h>
32 #include "psppire-data-store.h"
33 #include <libpspp/i18n.h>
36 #include <data/dictionary.h>
37 #include <data/missing-values.h>
38 #include <data/value-labels.h>
39 #include <data/data-in.h>
40 #include <data/format.h>
42 #include <math/sort.h>
49 static void psppire_data_store_init (PsppireDataStore *data_store);
50 static void psppire_data_store_class_init (PsppireDataStoreClass *class);
52 static void psppire_data_store_finalize (GObject *object);
53 static void psppire_data_store_dispose (GObject *object);
55 static gboolean psppire_data_store_insert_case (PsppireDataStore *ds,
60 static gboolean psppire_data_store_data_in (PsppireDataStore *ds,
61 casenumber casenum, gint idx,
62 struct substring input,
63 const struct fmt_spec *fmt);
65 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;
134 __get_value (GtkTreeModel *tree_model,
139 PsppireDataStore *store = PSPPIRE_DATA_STORE (tree_model);
141 const struct variable *variable = psppire_dict_get_variable (store->dict, column);
142 if (NULL == variable)
145 if (var_is_numeric (variable))
146 g_value_init (value, G_TYPE_DOUBLE);
148 g_value_init (value, G_TYPE_STRING);
150 gint row = GPOINTER_TO_INT (iter->user_data);
152 struct ccase *cc = datasheet_get_row (store->datasheet, row);
154 if (var_is_numeric (variable))
155 g_value_set_double (value, case_data_idx (cc, column)->f);
158 const gchar *ss = value_str (case_data_idx (cc, column),
159 var_get_width (variable));
160 g_value_set_string (value, ss);
167 __get_type (GtkTreeModel *tree_model, gint idx)
169 PsppireDataStore *store = PSPPIRE_DATA_STORE (tree_model);
171 const struct variable *variable = psppire_dict_get_variable (store->dict, idx);
173 if (NULL == variable)
176 if (var_is_numeric (variable))
177 return G_TYPE_DOUBLE;
179 return G_TYPE_STRING;
183 __tree_model_init (GtkTreeModelIface *iface)
185 iface->get_flags = __tree_model_get_flags;
186 iface->get_n_columns = __tree_model_get_n_columns ;
187 iface->get_column_type = __get_type;
188 iface->get_iter = NULL;
189 iface->iter_next = NULL;
190 iface->get_path = NULL;
191 iface->get_value = __get_value;
193 iface->iter_children = NULL;
194 iface->iter_has_child = NULL;
195 iface->iter_n_children = __tree_model_iter_n_children;
196 iface->iter_nth_child = __iter_nth_child;
197 iface->iter_parent = NULL;
202 psppire_data_store_get_type (void)
204 static GType data_store_type = 0;
206 if (!data_store_type)
208 static const GTypeInfo data_store_info =
210 sizeof (PsppireDataStoreClass),
211 NULL, /* base_init */
212 NULL, /* base_finalize */
213 (GClassInitFunc) psppire_data_store_class_init,
214 NULL, /* class_finalize */
215 NULL, /* class_data */
216 sizeof (PsppireDataStore),
218 (GInstanceInitFunc) psppire_data_store_init,
221 static const GInterfaceInfo tree_model_info = {
222 (GInterfaceInitFunc) __tree_model_init,
227 data_store_type = g_type_register_static (G_TYPE_OBJECT,
229 &data_store_info, 0);
231 g_type_add_interface_static (data_store_type, GTK_TYPE_TREE_MODEL,
235 return data_store_type;
240 psppire_data_store_class_init (PsppireDataStoreClass *class)
242 GObjectClass *object_class;
244 parent_class = g_type_class_peek_parent (class);
245 object_class = (GObjectClass*) class;
247 object_class->finalize = psppire_data_store_finalize;
248 object_class->dispose = psppire_data_store_dispose;
250 signals [ITEMS_CHANGED] =
251 g_signal_new ("changed",
252 G_TYPE_FROM_CLASS (class),
256 psppire_marshal_VOID__UINT_UINT_UINT,
263 signals [CASE_INSERTED] =
264 g_signal_new ("case-inserted",
265 G_TYPE_FROM_CLASS (class),
269 g_cclosure_marshal_VOID__INT,
275 signals [CASE_CHANGED] =
276 g_signal_new ("case-changed",
277 G_TYPE_FROM_CLASS (class),
281 g_cclosure_marshal_VOID__INT,
286 signals [CASES_DELETED] =
287 g_signal_new ("cases-deleted",
288 G_TYPE_FROM_CLASS (class),
292 psppire_marshal_VOID__INT_INT,
302 psppire_data_store_insert_value (PsppireDataStore *ds,
303 gint width, gint where);
306 psppire_data_store_get_case_count (const PsppireDataStore *store)
308 return datasheet_get_n_rows (store->datasheet);
312 psppire_data_store_get_value_count (const PsppireDataStore *store)
314 return psppire_dict_get_value_cnt (store->dict);
317 const struct caseproto *
318 psppire_data_store_get_proto (const PsppireDataStore *store)
320 return psppire_dict_get_proto (store->dict);
324 psppire_data_store_init (PsppireDataStore *data_store)
326 data_store->dict = NULL;
327 data_store->datasheet = NULL;
328 data_store->dispose_has_run = FALSE;
332 A callback which occurs after a variable has been deleted.
335 delete_variable_callback (GObject *obj, const struct variable *var UNUSED,
336 gint dict_index, gint case_index,
339 PsppireDataStore *store = PSPPIRE_DATA_STORE (data);
341 g_return_if_fail (store->datasheet);
343 datasheet_delete_columns (store->datasheet, case_index, 1);
344 datasheet_insert_column (store->datasheet, NULL, -1, case_index);
347 struct resize_datum_aux
349 const struct dictionary *dict;
350 const struct variable *new_variable;
351 const struct variable *old_variable;
355 resize_datum (const union value *old, union value *new, const void *aux_)
357 const struct resize_datum_aux *aux = aux_;
358 int new_width = var_get_width (aux->new_variable);
359 const char *enc = dict_get_encoding (aux->dict);
360 const struct fmt_spec *newfmt = var_get_print_format (aux->new_variable);
361 char *s = data_out (old, enc, var_get_print_format (aux->old_variable));
362 enum fmt_type type = (fmt_usable_for_input (newfmt->type)
365 free (data_in (ss_cstr (s), enc, type, new, new_width, enc));
370 variable_changed_callback (GObject *obj, gint var_num, guint what, const struct variable *oldvar,
373 PsppireDataStore *store = PSPPIRE_DATA_STORE (data);
374 struct variable *variable = psppire_dict_get_variable (store->dict, var_num);
376 if (what & VAR_TRAIT_WIDTH)
378 int posn = var_get_case_index (variable);
379 struct resize_datum_aux aux;
380 aux.old_variable = oldvar;
381 aux.new_variable = variable;
382 aux.dict = store->dict->dict;
383 datasheet_resize_column (store->datasheet, posn, var_get_width (variable),
389 insert_variable_callback (GObject *obj, gint var_num, gpointer data)
391 struct variable *variable;
392 PsppireDataStore *store;
395 g_return_if_fail (data);
397 store = PSPPIRE_DATA_STORE (data);
399 variable = psppire_dict_get_variable (store->dict, var_num);
400 posn = var_get_case_index (variable);
401 psppire_data_store_insert_value (store, var_get_width (variable), posn);
405 * psppire_data_store_new:
406 * @dict: The dictionary for this data_store.
409 * Return value: a new #PsppireDataStore
412 psppire_data_store_new (PsppireDict *dict)
414 PsppireDataStore *retval;
416 retval = g_object_new (PSPPIRE_TYPE_DATA_STORE, NULL);
418 psppire_data_store_set_dictionary (retval, dict);
424 psppire_data_store_set_reader (PsppireDataStore *ds,
425 struct casereader *reader)
431 old_n = datasheet_get_n_rows (ds->datasheet);
432 datasheet_destroy (ds->datasheet);
435 ds->datasheet = datasheet_create (reader);
437 gint new_n = datasheet_get_n_rows (ds->datasheet);
440 for (i = 0 ; i < n_dict_signals; ++i )
442 if ( ds->dict_handler_id [i] > 0)
444 g_signal_handler_unblock (ds->dict,
445 ds->dict_handler_id[i]);
449 g_signal_emit (ds, signals[ITEMS_CHANGED], 0, 0, old_n, new_n);
454 * psppire_data_store_replace_set_dictionary:
455 * @data_store: The variable store
456 * @dict: The dictionary to set
458 * If a dictionary is already associated with the data-store, then it will be
462 psppire_data_store_set_dictionary (PsppireDataStore *data_store, PsppireDict *dict)
466 /* Disconnect any existing handlers */
467 if ( data_store->dict )
468 for (i = 0 ; i < n_dict_signals; ++i )
470 g_signal_handler_disconnect (data_store->dict,
471 data_store->dict_handler_id[i]);
474 data_store->dict = dict;
479 data_store->dict_handler_id [VARIABLE_INSERTED] =
480 g_signal_connect (dict, "variable-inserted",
481 G_CALLBACK (insert_variable_callback),
484 data_store->dict_handler_id [VARIABLE_DELETED] =
485 g_signal_connect (dict, "variable-deleted",
486 G_CALLBACK (delete_variable_callback),
489 data_store->dict_handler_id [VARIABLE_CHANGED] =
490 g_signal_connect (dict, "variable-changed",
491 G_CALLBACK (variable_changed_callback),
497 /* The entire model has changed */
499 if ( data_store->dict )
500 for (i = 0 ; i < n_dict_signals; ++i )
502 if ( data_store->dict_handler_id [i] > 0)
504 g_signal_handler_block (data_store->dict,
505 data_store->dict_handler_id[i]);
511 psppire_data_store_finalize (GObject *object)
513 PsppireDataStore *ds = PSPPIRE_DATA_STORE (object);
517 datasheet_destroy (ds->datasheet);
518 ds->datasheet = NULL;
522 (* parent_class->finalize) (object);
527 psppire_data_store_dispose (GObject *object)
529 PsppireDataStore *ds = PSPPIRE_DATA_STORE (object);
531 if (ds->dispose_has_run)
534 psppire_data_store_set_dictionary (ds, NULL);
537 (* parent_class->dispose) (object);
539 ds->dispose_has_run = TRUE;
544 /* Insert a blank case before POSN */
546 psppire_data_store_insert_new_case (PsppireDataStore *ds, casenumber posn)
549 const struct caseproto *proto;
551 g_return_val_if_fail (ds, FALSE);
553 proto = datasheet_get_proto (ds->datasheet);
554 g_return_val_if_fail (caseproto_get_n_widths (proto) > 0, FALSE);
555 g_return_val_if_fail (posn <= psppire_data_store_get_case_count (ds), FALSE);
557 cc = case_create (proto);
558 case_set_missing (cc);
560 result = psppire_data_store_insert_case (ds, cc, posn);
568 psppire_data_store_get_string (PsppireDataStore *store,
569 glong row, const struct variable *var,
570 bool use_value_label)
576 g_return_val_if_fail (store != NULL, NULL);
577 g_return_val_if_fail (store->datasheet != NULL, NULL);
578 g_return_val_if_fail (var != NULL, NULL);
580 if (row < 0 || row >= datasheet_get_n_rows (store->datasheet))
583 width = var_get_width (var);
584 value_init (&v, width);
585 datasheet_get_value (store->datasheet, row, var_get_case_index (var), &v);
590 const char *label = var_lookup_value_label (var, &v);
592 string = g_strdup (label);
595 string = value_to_text (v, var);
597 value_destroy (&v, width);
603 /* Attempts to update that part of the variable store which corresponds to VAR
604 within ROW with the value TEXT.
606 If USE_VALUE_LABEL is true, and TEXT is a value label for the column's
607 variable, then stores the value from that value label instead of the literal
610 Returns true if anything was updated, false otherwise. */
612 psppire_data_store_set_string (PsppireDataStore *store,
614 glong row, const struct variable *var,
615 gboolean use_value_label)
621 n_cases = psppire_data_store_get_case_count (store);
625 psppire_data_store_insert_new_case (store, row);
627 case_index = var_get_case_index (var);
630 const struct val_labs *vls = var_get_value_labels (var);
631 const union value *value = vls ? val_labs_find_value (vls, text) : NULL;
633 ok = datasheet_put_value (store->datasheet, row, case_index, value);
638 ok = psppire_data_store_data_in (store, row, case_index, ss_cstr (text),
639 var_get_print_format (var));
642 g_signal_emit (store, signals [CASE_CHANGED], 0, row);
649 psppire_data_store_clear (PsppireDataStore *ds)
651 datasheet_destroy (ds->datasheet);
652 ds->datasheet = NULL;
654 psppire_dict_clear (ds->dict);
656 g_signal_emit (ds, signals [CASES_DELETED], 0, 0, -1);
661 /* Return a casereader made from this datastore */
663 psppire_data_store_get_reader (PsppireDataStore *ds)
666 struct casereader *reader ;
669 for (i = 0 ; i < n_dict_signals; ++i )
671 g_signal_handler_block (ds->dict,
672 ds->dict_handler_id[i]);
675 reader = datasheet_make_reader (ds->datasheet);
677 /* We must not reference this again */
678 ds->datasheet = NULL;
685 /* Column related funcs */
688 static const gchar null_var_name[]=N_("var");
694 /* Returns the CASENUMth case, or a null pointer on failure.
697 psppire_data_store_get_case (const PsppireDataStore *ds,
700 g_return_val_if_fail (ds, FALSE);
701 g_return_val_if_fail (ds->datasheet, FALSE);
703 return datasheet_get_row (ds->datasheet, casenum);
708 psppire_data_store_delete_cases (PsppireDataStore *ds, casenumber first,
711 g_return_val_if_fail (ds, FALSE);
712 g_return_val_if_fail (ds->datasheet, FALSE);
714 g_return_val_if_fail (first + n_cases <=
715 psppire_data_store_get_case_count (ds), FALSE);
718 datasheet_delete_rows (ds->datasheet, first, n_cases);
720 g_signal_emit (ds, signals [CASES_DELETED], 0, first, n_cases);
727 /* Insert case CC into the case file before POSN */
729 psppire_data_store_insert_case (PsppireDataStore *ds,
735 g_return_val_if_fail (ds, FALSE);
736 g_return_val_if_fail (ds->datasheet, FALSE);
739 result = datasheet_insert_rows (ds->datasheet, posn, &cc, 1);
742 g_signal_emit (ds, signals [CASE_INSERTED], 0, posn);
744 g_warning ("Cannot insert case at position %ld\n", posn);
750 /* Set the value of VAR in case CASENUM to V.
751 V must be the correct width for IDX.
752 Returns true if successful, false on I/O error. */
754 psppire_data_store_set_value (PsppireDataStore *ds, casenumber casenum,
755 const struct variable *var, const union value *v)
760 g_return_val_if_fail (ds, FALSE);
761 g_return_val_if_fail (ds->datasheet, FALSE);
763 n_cases = psppire_data_store_get_case_count (ds);
764 if ( casenum > n_cases)
767 if (casenum == n_cases)
768 psppire_data_store_insert_new_case (ds, casenum);
770 ok = datasheet_put_value (ds->datasheet, casenum, var_get_case_index (var),
773 g_signal_emit (ds, signals [CASE_CHANGED], 0, casenum);
781 /* Set the IDXth value of case C using D_IN */
783 psppire_data_store_data_in (PsppireDataStore *ds, casenumber casenum, gint idx,
784 struct substring input, const struct fmt_spec *fmt)
792 g_return_val_if_fail (ds, FALSE);
793 g_return_val_if_fail (ds->datasheet, FALSE);
795 g_return_val_if_fail (idx < datasheet_get_n_columns (ds->datasheet), FALSE);
799 width = fmt_var_width (fmt);
800 g_return_val_if_fail (caseproto_get_width (
801 datasheet_get_proto (ds->datasheet), idx) == width,
803 value_init (&value, width);
804 ok = (datasheet_get_value (ds->datasheet, casenum, idx, &value)
805 && data_in_msg (input, UTF8, fmt->type, &value, width,
806 dict_get_encoding (dict->dict))
807 && datasheet_put_value (ds->datasheet, casenum, idx, &value));
808 value_destroy (&value, width);
813 /* Resize the cases in the casefile, by inserting a value of the
814 given WIDTH into every one of them at the position immediately
818 psppire_data_store_insert_value (PsppireDataStore *ds,
819 gint width, gint where)
823 g_return_val_if_fail (ds, FALSE);
825 g_assert (width >= 0);
827 if ( ! ds->datasheet )
828 ds->datasheet = datasheet_create (NULL);
830 value_init (&value, width);
831 value_set_missing (&value, width);
833 datasheet_insert_column (ds->datasheet, &value, width, where);
834 value_destroy (&value, width);
840 psppire_data_store_filtered (PsppireDataStore *ds,
845 const struct dictionary *dict;
846 const struct variable *filter;
848 if ( row < 0 || row >= datasheet_get_n_rows (ds->datasheet))
851 dict = ds->dict->dict;
852 g_return_val_if_fail (dict, FALSE);
853 filter = dict_get_filter (dict);
857 g_return_val_if_fail (var_is_numeric (filter), FALSE);
858 value_init (&val, 0);
859 if ( ! datasheet_get_value (ds->datasheet, row,
860 var_get_case_index (filter),
864 return (val.f == 0.0);