1 /* PSPPIRE - a graphical user interface for PSPP.
2 Copyright (C) 2006, 2008, 2009, 2010, 2011, 2012 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];
81 psppire_data_store_get_type (void)
83 static GType data_store_type = 0;
87 static const GTypeInfo data_store_info =
89 sizeof (PsppireDataStoreClass),
91 NULL, /* base_finalize */
92 (GClassInitFunc) psppire_data_store_class_init,
93 NULL, /* class_finalize */
94 NULL, /* class_data */
95 sizeof (PsppireDataStore),
97 (GInstanceInitFunc) psppire_data_store_init,
100 data_store_type = g_type_register_static (G_TYPE_OBJECT,
102 &data_store_info, 0);
105 return data_store_type;
110 psppire_data_store_class_init (PsppireDataStoreClass *class)
112 GObjectClass *object_class;
114 parent_class = g_type_class_peek_parent (class);
115 object_class = (GObjectClass*) class;
117 object_class->finalize = psppire_data_store_finalize;
118 object_class->dispose = psppire_data_store_dispose;
120 signals [BACKEND_CHANGED] =
121 g_signal_new ("backend-changed",
122 G_TYPE_FROM_CLASS (class),
126 g_cclosure_marshal_VOID__VOID,
130 signals [CASE_INSERTED] =
131 g_signal_new ("case-inserted",
132 G_TYPE_FROM_CLASS (class),
136 g_cclosure_marshal_VOID__INT,
142 signals [CASE_CHANGED] =
143 g_signal_new ("case-changed",
144 G_TYPE_FROM_CLASS (class),
148 g_cclosure_marshal_VOID__INT,
153 signals [CASES_DELETED] =
154 g_signal_new ("cases-deleted",
155 G_TYPE_FROM_CLASS (class),
159 psppire_marshal_VOID__INT_INT,
169 psppire_data_store_insert_value (PsppireDataStore *ds,
170 gint width, gint where);
173 psppire_data_store_get_case_count (const PsppireDataStore *store)
175 return datasheet_get_n_rows (store->datasheet);
179 psppire_data_store_get_value_count (const PsppireDataStore *store)
181 return psppire_dict_get_value_cnt (store->dict);
184 const struct caseproto *
185 psppire_data_store_get_proto (const PsppireDataStore *store)
187 return psppire_dict_get_proto (store->dict);
191 psppire_data_store_init (PsppireDataStore *data_store)
193 data_store->dict = NULL;
194 data_store->datasheet = NULL;
195 data_store->dispose_has_run = FALSE;
199 A callback which occurs after a variable has been deleted.
202 delete_variable_callback (GObject *obj, const struct variable *var UNUSED,
203 gint dict_index, gint case_index,
206 PsppireDataStore *store = PSPPIRE_DATA_STORE (data);
209 datasheet_delete_columns (store->datasheet, case_index, 1);
210 datasheet_insert_column (store->datasheet, NULL, -1, case_index);
214 variable_changed_callback (GObject *obj, gint var_num, gpointer data)
219 insert_variable_callback (GObject *obj, gint var_num, gpointer data)
221 struct variable *variable;
222 PsppireDataStore *store;
225 g_return_if_fail (data);
227 store = PSPPIRE_DATA_STORE (data);
229 variable = psppire_dict_get_variable (store->dict, var_num);
230 posn = var_get_case_index (variable);
231 psppire_data_store_insert_value (store, var_get_width (variable), posn);
234 struct resize_datum_aux
242 resize_datum (const union value *old, union value *new, void *aux_)
244 struct resize_datum_aux *aux = aux_;
246 if (aux->new_width == 0)
248 /* FIXME: try to parse string as number. */
251 else if (aux->old_width == 0)
253 /* FIXME: format number as string. */
254 value_set_missing (new, aux->new_width);
257 value_copy_rpad (new, aux->new_width, old, aux->old_width, ' ');
261 dict_size_change_callback (GObject *obj,
262 gint var_num, gint old_width, gpointer data)
264 PsppireDataStore *store = PSPPIRE_DATA_STORE (data);
265 struct variable *variable;
268 variable = psppire_dict_get_variable (store->dict, var_num);
269 posn = var_get_case_index (variable);
271 if (old_width != var_get_width (variable))
273 struct resize_datum_aux aux;
274 aux.old_width = old_width;
275 aux.new_width = var_get_width (variable);
276 datasheet_resize_column (store->datasheet, posn, aux.new_width,
284 * psppire_data_store_new:
285 * @dict: The dictionary for this data_store.
288 * Return value: a new #PsppireDataStore
291 psppire_data_store_new (PsppireDict *dict)
293 PsppireDataStore *retval;
295 retval = g_object_new (PSPPIRE_TYPE_DATA_STORE, NULL);
297 psppire_data_store_set_dictionary (retval, dict);
303 psppire_data_store_set_reader (PsppireDataStore *ds,
304 struct casereader *reader)
309 datasheet_destroy (ds->datasheet);
311 ds->datasheet = datasheet_create (reader);
314 for (i = 0 ; i < n_dict_signals; ++i )
316 if ( ds->dict_handler_id [i] > 0)
318 g_signal_handler_unblock (ds->dict,
319 ds->dict_handler_id[i]);
323 g_signal_emit (ds, signals[BACKEND_CHANGED], 0);
328 * psppire_data_store_replace_set_dictionary:
329 * @data_store: The variable store
330 * @dict: The dictionary to set
332 * If a dictionary is already associated with the data-store, then it will be
336 psppire_data_store_set_dictionary (PsppireDataStore *data_store, PsppireDict *dict)
340 /* Disconnect any existing handlers */
341 if ( data_store->dict )
342 for (i = 0 ; i < n_dict_signals; ++i )
344 g_signal_handler_disconnect (data_store->dict,
345 data_store->dict_handler_id[i]);
348 data_store->dict = dict;
353 data_store->dict_handler_id [VARIABLE_INSERTED] =
354 g_signal_connect (dict, "variable-inserted",
355 G_CALLBACK (insert_variable_callback),
358 data_store->dict_handler_id [VARIABLE_DELETED] =
359 g_signal_connect (dict, "variable-deleted",
360 G_CALLBACK (delete_variable_callback),
363 data_store->dict_handler_id [VARIABLE_CHANGED] =
364 g_signal_connect (dict, "variable-changed",
365 G_CALLBACK (variable_changed_callback),
368 data_store->dict_handler_id [SIZE_CHANGED] =
369 g_signal_connect (dict, "dict-size-changed",
370 G_CALLBACK (dict_size_change_callback),
376 /* The entire model has changed */
378 if ( data_store->dict )
379 for (i = 0 ; i < n_dict_signals; ++i )
381 if ( data_store->dict_handler_id [i] > 0)
383 g_signal_handler_block (data_store->dict,
384 data_store->dict_handler_id[i]);
390 psppire_data_store_finalize (GObject *object)
392 PsppireDataStore *ds = PSPPIRE_DATA_STORE (object);
396 datasheet_destroy (ds->datasheet);
397 ds->datasheet = NULL;
401 (* parent_class->finalize) (object);
406 psppire_data_store_dispose (GObject *object)
408 PsppireDataStore *ds = PSPPIRE_DATA_STORE (object);
410 if (ds->dispose_has_run)
415 (* parent_class->dispose) (object);
417 ds->dispose_has_run = TRUE;
422 /* Insert a blank case before POSN */
424 psppire_data_store_insert_new_case (PsppireDataStore *ds, casenumber posn)
427 const struct caseproto *proto;
429 g_return_val_if_fail (ds, FALSE);
431 proto = datasheet_get_proto (ds->datasheet);
432 g_return_val_if_fail (caseproto_get_n_widths (proto) > 0, FALSE);
433 g_return_val_if_fail (posn <= psppire_data_store_get_case_count (ds), FALSE);
435 cc = case_create (proto);
436 case_set_missing (cc);
438 result = psppire_data_store_insert_case (ds, cc, posn);
446 psppire_data_store_get_string (PsppireDataStore *store,
447 glong row, const struct variable *var,
448 bool use_value_label)
454 g_return_val_if_fail (store != NULL, NULL);
455 g_return_val_if_fail (var != NULL, NULL);
457 if (row < 0 || row >= datasheet_get_n_rows (store->datasheet))
460 width = var_get_width (var);
461 value_init (&v, width);
462 datasheet_get_value (store->datasheet, row, var_get_case_index (var), &v);
467 const char *label = var_lookup_value_label (var, &v);
469 string = g_strdup (label);
472 string = value_to_text (v, var);
474 value_destroy (&v, width);
480 /* Attempts to update that part of the variable store which corresponds to VAR
481 within ROW with the value TEXT.
483 If USE_VALUE_LABEL is true, and TEXT is a value label for the column's
484 variable, then stores the value from that value label instead of the literal
487 Returns true if anything was updated, false otherwise. */
489 psppire_data_store_set_string (PsppireDataStore *store,
491 glong row, const struct variable *var,
492 gboolean use_value_label)
498 n_cases = psppire_data_store_get_case_count (store);
502 psppire_data_store_insert_new_case (store, row);
504 case_index = var_get_case_index (var);
507 const struct val_labs *vls = var_get_value_labels (var);
508 const union value *value = vls ? val_labs_find_value (vls, text) : NULL;
510 ok = datasheet_put_value (store->datasheet, row, case_index, value);
515 ok = psppire_data_store_data_in (store, row, case_index, ss_cstr (text),
516 var_get_print_format (var));
519 g_signal_emit (store, signals [CASE_CHANGED], 0, row);
526 psppire_data_store_clear (PsppireDataStore *ds)
528 datasheet_destroy (ds->datasheet);
529 ds->datasheet = NULL;
531 psppire_dict_clear (ds->dict);
533 g_signal_emit (ds, signals [CASES_DELETED], 0, 0, -1);
538 /* Return a casereader made from this datastore */
540 psppire_data_store_get_reader (PsppireDataStore *ds)
543 struct casereader *reader ;
546 for (i = 0 ; i < n_dict_signals; ++i )
548 g_signal_handler_block (ds->dict,
549 ds->dict_handler_id[i]);
552 reader = datasheet_make_reader (ds->datasheet);
554 /* We must not reference this again */
555 ds->datasheet = NULL;
562 /* Column related funcs */
565 static const gchar null_var_name[]=N_("var");
571 /* Returns the CASENUMth case, or a null pointer on failure.
574 psppire_data_store_get_case (const PsppireDataStore *ds,
577 g_return_val_if_fail (ds, FALSE);
578 g_return_val_if_fail (ds->datasheet, FALSE);
580 return datasheet_get_row (ds->datasheet, casenum);
585 psppire_data_store_delete_cases (PsppireDataStore *ds, casenumber first,
588 g_return_val_if_fail (ds, FALSE);
589 g_return_val_if_fail (ds->datasheet, FALSE);
591 g_return_val_if_fail (first + n_cases <=
592 psppire_data_store_get_case_count (ds), FALSE);
595 datasheet_delete_rows (ds->datasheet, first, n_cases);
597 g_signal_emit (ds, signals [CASES_DELETED], 0, first, n_cases);
604 /* Insert case CC into the case file before POSN */
606 psppire_data_store_insert_case (PsppireDataStore *ds,
612 g_return_val_if_fail (ds, FALSE);
613 g_return_val_if_fail (ds->datasheet, FALSE);
616 result = datasheet_insert_rows (ds->datasheet, posn, &cc, 1);
619 g_signal_emit (ds, signals [CASE_INSERTED], 0, posn);
621 g_warning ("Cannot insert case at position %ld\n", posn);
627 /* Set the value of VAR in case CASENUM to V.
628 V must be the correct width for IDX.
629 Returns true if successful, false on I/O error. */
631 psppire_data_store_set_value (PsppireDataStore *ds, casenumber casenum,
632 const struct variable *var, const union value *v)
637 g_return_val_if_fail (ds, FALSE);
638 g_return_val_if_fail (ds->datasheet, FALSE);
640 n_cases = psppire_data_store_get_case_count (ds);
641 if ( casenum > n_cases)
644 if (casenum == n_cases)
645 psppire_data_store_insert_new_case (ds, casenum);
647 ok = datasheet_put_value (ds->datasheet, casenum, var_get_case_index (var),
650 g_signal_emit (ds, signals [CASE_CHANGED], 0, casenum);
658 /* Set the IDXth value of case C using D_IN */
660 psppire_data_store_data_in (PsppireDataStore *ds, casenumber casenum, gint idx,
661 struct substring input, const struct fmt_spec *fmt)
669 g_return_val_if_fail (ds, FALSE);
670 g_return_val_if_fail (ds->datasheet, FALSE);
672 g_return_val_if_fail (idx < datasheet_get_n_columns (ds->datasheet), FALSE);
676 width = fmt_var_width (fmt);
677 g_return_val_if_fail (caseproto_get_width (
678 datasheet_get_proto (ds->datasheet), idx) == width,
680 value_init (&value, width);
681 ok = (datasheet_get_value (ds->datasheet, casenum, idx, &value)
682 && data_in_msg (input, UTF8, fmt->type, &value, width,
683 dict_get_encoding (dict->dict))
684 && datasheet_put_value (ds->datasheet, casenum, idx, &value));
685 value_destroy (&value, width);
690 /* Resize the cases in the casefile, by inserting a value of the
691 given WIDTH into every one of them at the position immediately
695 psppire_data_store_insert_value (PsppireDataStore *ds,
696 gint width, gint where)
700 g_return_val_if_fail (ds, FALSE);
702 g_assert (width >= 0);
704 if ( ! ds->datasheet )
705 ds->datasheet = datasheet_create (NULL);
707 value_init (&value, width);
708 value_set_missing (&value, width);
710 datasheet_insert_column (ds->datasheet, &value, width, where);
711 value_destroy (&value, width);
717 psppire_data_store_filtered (PsppireDataStore *ds,
722 const struct dictionary *dict;
723 const struct variable *filter;
725 if ( row < 0 || row >= datasheet_get_n_rows (ds->datasheet))
728 dict = ds->dict->dict;
729 g_return_val_if_fail (dict, FALSE);
730 filter = dict_get_filter (dict);
734 g_return_val_if_fail (var_is_numeric (filter), FALSE);
735 value_init (&val, 0);
736 if ( ! datasheet_get_value (ds->datasheet, row,
737 var_get_case_index (filter),
741 return (val.f == 0.0);