Change how checking for missing values works.
[pspp] / src / ui / gui / psppire-data-store.c
index c7dc55afa5d4898ded22d0f41047ac4f34b7ff8c..2a3efe639522ea320a515914eeb3a734df4db6f6 100644 (file)
@@ -20,7 +20,7 @@
 #include <stdlib.h>
 #include <gettext.h>
 #define _(msgid) gettext (msgid)
-#define N_(msgid) msgid
+#define P_(msgid) msgid
 
 #include <data/datasheet.h>
 #include <data/data-out.h>
 
 #include <math/sort.h>
 
-#include "xalloc.h"
 #include "xmalloca.h"
 
 #include "value-variant.h"
 
-static void psppire_data_store_init            (PsppireDataStore      *data_store);
-static void psppire_data_store_class_init      (PsppireDataStoreClass *class);
-
 static void psppire_data_store_finalize        (GObject           *object);
 static void psppire_data_store_dispose        (GObject           *object);
 
@@ -81,6 +77,9 @@ __tree_model_iter_n_children (GtkTreeModel *tree_model,
 {
   PsppireDataStore *store  = PSPPIRE_DATA_STORE (tree_model);
 
+  if (store->datasheet == NULL)
+    return 0;
+
   gint n =  datasheet_get_n_rows (store->datasheet);
 
   return n;
@@ -99,7 +98,7 @@ __tree_model_get_n_columns (GtkTreeModel *tree_model)
 {
   PsppireDataStore *store  = PSPPIRE_DATA_STORE (tree_model);
 
-  return psppire_dict_get_var_cnt (store->dict);
+  return psppire_dict_get_n_vars (store->dict);
 }
 
 
@@ -110,30 +109,39 @@ __iter_nth_child (GtkTreeModel *tree_model,
                  gint n)
 {
   PsppireDataStore *store  = PSPPIRE_DATA_STORE (tree_model);
-  
-  g_assert (parent == NULL);
 
+  g_assert (parent == NULL);
   g_return_val_if_fail (store, FALSE);
-  g_return_val_if_fail (store->datasheet, FALSE);
 
-  if (n >= datasheet_get_n_rows (store->datasheet))
+  if (!store->datasheet || n >= datasheet_get_n_rows (store->datasheet))
     {
       iter->stamp = -1;
       iter->user_data = NULL;
       return FALSE;
     }
-  
+
   iter->user_data = GINT_TO_POINTER (n);
   iter->stamp = store->stamp;
-  
+
   return TRUE;
 }
 
+/* Set the contents of OUT to reflect the information provided by IN, COL, and
+   ROW, for MODEL.  Returns TRUE if successful. */
 gboolean
-myreversefunc (GtkTreeModel *model, gint col, gint row,
-              const gchar *in, GValue *out)
+psppire_data_store_string_to_value (GtkTreeModel *model, gint col, gint row,
+                                   const gchar *in, GValue *out)
 {
-  PsppireDataStore *store  = PSPPIRE_DATA_STORE (model);
+  PsppireDataStore *store = PSPPIRE_DATA_STORE (model);
+
+  while (col >= psppire_dict_get_n_vars (store->dict))
+    {
+      const struct variable *var =
+       psppire_dict_insert_variable (store->dict,
+                                     psppire_dict_get_n_vars (store->dict),
+                                     NULL);
+      g_return_val_if_fail (var, FALSE);
+    }
 
   const struct variable *variable = psppire_dict_get_variable (store->dict, col);
   g_return_val_if_fail (variable, FALSE);
@@ -144,9 +152,21 @@ myreversefunc (GtkTreeModel *model, gint col, gint row,
 
   union value val;
   value_init (&val, width);
-  char *xx = 
-    data_in (ss_cstr (in), psppire_dict_encoding (store->dict),
-            fmt->type, &val, width, "UTF-8");
+  const struct val_labs *value_labels = var_get_value_labels (variable);
+  const union value *vp = NULL;
+  if (value_labels)
+    {
+      vp = val_labs_find_value (value_labels, in);
+      if (vp)
+       value_copy (&val, vp, width);
+    }
+  char *xx = NULL;
+  if (vp == NULL)
+    {
+      xx = data_in (ss_cstr (in), psppire_dict_encoding (store->dict),
+                   fmt->type, settings_get_fmt_settings (),
+                    &val, width, "UTF-8");
+    }
 
   GVariant *vrnt = value_variant_new (&val, width);
   value_destroy (&val, width);
@@ -157,18 +177,55 @@ myreversefunc (GtkTreeModel *model, gint col, gint row,
   return TRUE;
 }
 
+static char *
+unlabeled_value (PsppireDataStore *store, const struct variable *variable, const union value *val)
+{
+  if (var_is_numeric (variable) &&
+      var_is_value_missing (variable, val) == MV_SYSTEM)
+    return g_strdup ("");
+
+  const struct fmt_spec *fmt = var_get_print_format (variable);
+  return value_to_text__ (*val, fmt, psppire_dict_encoding (store->dict));
+}
+
 gchar *
-psppire_data_store_value_to_string (PsppireDataStore *store, gint col, gint row, const GValue *v)
+psppire_data_store_value_to_string (gpointer unused, PsppireDataStore *store, gint col, gint row, const GValue *v)
 {
   const struct variable *variable = psppire_dict_get_variable (store->dict, col);
   g_return_val_if_fail (variable, g_strdup ("???"));
 
   GVariant *vrnt = g_value_get_variant (v);
+  g_return_val_if_fail (vrnt, g_strdup ("???"));
+
   union value val;
   value_variant_get (&val, vrnt);
 
-  const struct fmt_spec *fmt = var_get_print_format (variable);
-  char *out =  data_out (&val, psppire_dict_encoding (store->dict),  fmt);
+  char *out = unlabeled_value (store, variable, &val);
+
+  value_destroy_from_variant (&val, vrnt);
+
+  return out;
+}
+
+gchar *
+psppire_data_store_value_to_string_with_labels (gpointer unused, PsppireDataStore *store, gint col, gint row, const GValue *v)
+{
+  const struct variable *variable = psppire_dict_get_variable (store->dict, col);
+  g_return_val_if_fail (variable, g_strdup ("???"));
+
+  GVariant *vrnt = g_value_get_variant (v);
+  union value val;
+  value_variant_get (&val, vrnt);
+
+  char *out = NULL;
+
+  const struct val_labs *vls = var_get_value_labels (variable);
+  struct val_lab *vl = val_labs_lookup (vls, &val);
+  if (vl != NULL)
+    out = strdup (val_lab_get_label (vl));
+  else
+    out = unlabeled_value (store, variable, &val);
+
   value_destroy_from_variant (&val, vrnt);
 
   return out;
@@ -183,23 +240,25 @@ __get_value (GtkTreeModel *tree_model,
   PsppireDataStore *store  = PSPPIRE_DATA_STORE (tree_model);
 
   g_return_if_fail (iter->stamp == store->stamp);
-  
+
   const struct variable *variable = psppire_dict_get_variable (store->dict, column);
   if (NULL == variable)
     return;
 
-  g_value_init (value, G_TYPE_VARIANT);
-
   gint row = GPOINTER_TO_INT (iter->user_data);
 
   struct ccase *cc = datasheet_get_row (store->datasheet, row);
 
+  g_return_if_fail (cc);
+
+  g_value_init (value, G_TYPE_VARIANT);
+
   const union value *val = case_data_idx (cc, var_get_case_index (variable));
 
   GVariant *vv = value_variant_new (val, var_get_width (variable));
 
   g_value_set_variant (value, vv);
-  
+
   case_unref (cc);
 }
 
@@ -210,56 +269,21 @@ __tree_model_init (GtkTreeModelIface *iface)
   iface->get_flags       = __tree_model_get_flags;
   iface->get_n_columns   = __tree_model_get_n_columns ;
   iface->get_column_type = NULL;
-  iface->get_iter        = NULL; 
-  iface->iter_next       = NULL; 
-  iface->get_path        = NULL; 
+  iface->get_iter        = NULL;
+  iface->iter_next       = NULL;
+  iface->get_path        = NULL;
   iface->get_value       = __get_value;
 
-  iface->iter_children   = NULL; 
-  iface->iter_has_child  = NULL; 
+  iface->iter_children   = NULL;
+  iface->iter_has_child  = NULL;
   iface->iter_n_children = __tree_model_iter_n_children;
   iface->iter_nth_child  = __iter_nth_child;
-  iface->iter_parent     = NULL; 
-}
-
-
-GType
-psppire_data_store_get_type (void)
-{
-  static GType data_store_type = 0;
-
-  if (!data_store_type)
-    {
-      static const GTypeInfo data_store_info =
-      {
-       sizeof (PsppireDataStoreClass),
-       NULL,           /* base_init */
-       NULL,           /* base_finalize */
-        (GClassInitFunc) psppire_data_store_class_init,
-       NULL,           /* class_finalize */
-       NULL,           /* class_data */
-        sizeof (PsppireDataStore),
-       0,
-        (GInstanceInitFunc) psppire_data_store_init,
-      };
-
-      static const GInterfaceInfo tree_model_info = {
-       (GInterfaceInitFunc) __tree_model_init,
-       NULL,
-       NULL
-      };
-
-      data_store_type = g_type_register_static (G_TYPE_OBJECT,
-                                               "PsppireDataStore",
-                                               &data_store_info, 0);
-
-      g_type_add_interface_static (data_store_type, GTK_TYPE_TREE_MODEL,
-                                  &tree_model_info);
-    }
-
-  return data_store_type;
+  iface->iter_parent     = NULL;
 }
 
+G_DEFINE_TYPE_WITH_CODE (PsppireDataStore, psppire_data_store, G_TYPE_OBJECT,
+                        G_IMPLEMENT_INTERFACE (GTK_TYPE_TREE_MODEL,
+                                               __tree_model_init))
 
 static void
 psppire_data_store_class_init (PsppireDataStoreClass *class)
@@ -267,7 +291,7 @@ psppire_data_store_class_init (PsppireDataStoreClass *class)
   GObjectClass *object_class;
 
   parent_class = g_type_class_peek_parent (class);
-  object_class = (GObjectClass*) class;
+  object_class = G_OBJECT_CLASS (class);
 
   object_class->finalize = psppire_data_store_finalize;
   object_class->dispose = psppire_data_store_dispose;
@@ -308,7 +332,7 @@ psppire_data_store_get_case_count (const PsppireDataStore *store)
 size_t
 psppire_data_store_get_value_count (const PsppireDataStore *store)
 {
-  return psppire_dict_get_value_cnt (store->dict);
+  return psppire_dict_get_n_values (store->dict);
 }
 
 const struct caseproto *
@@ -331,6 +355,8 @@ static void
 psppire_data_store_delete_value (PsppireDataStore *store, gint case_index)
 {
   g_return_if_fail (store->datasheet);
+  g_return_if_fail (case_index < datasheet_get_n_columns (store->datasheet));
+
   datasheet_delete_columns (store->datasheet, case_index, 1);
   datasheet_insert_column (store->datasheet, NULL, -1, case_index);
 }
@@ -363,11 +389,13 @@ resize_datum (const union value *old, union value *new, const void *aux_)
   int new_width = var_get_width (aux->new_variable);
   const char *enc = dict_get_encoding (aux->dict);
   const struct fmt_spec *newfmt = var_get_print_format (aux->new_variable);
-  char *s = data_out (old, enc, var_get_print_format (aux->old_variable));
+  char *s = data_out (old, enc, var_get_print_format (aux->old_variable),
+                      settings_get_fmt_settings ());
   enum fmt_type type = (fmt_usable_for_input (newfmt->type)
                         ? newfmt->type
                         : FMT_DOLLAR);
-  free (data_in (ss_cstr (s), enc, type, new, new_width, enc));
+  free (data_in (ss_cstr (s), enc, type, settings_get_fmt_settings (),
+                 new, new_width, enc));
   free (s);
 }
 
@@ -431,7 +459,7 @@ psppire_data_store_set_reader (PsppireDataStore *ds,
 {
   gint i;
   gint old_n = 0;
-  if ( ds->datasheet)
+  if (ds->datasheet)
     {
       old_n = datasheet_get_n_rows (ds->datasheet);
       datasheet_destroy (ds->datasheet);
@@ -440,11 +468,11 @@ psppire_data_store_set_reader (PsppireDataStore *ds,
   ds->datasheet = datasheet_create (reader);
 
   gint new_n = datasheet_get_n_rows (ds->datasheet);
-  
-  if ( ds->dict )
-    for (i = 0 ; i < n_dict_signals; ++i )
+
+  if (ds->dict)
+    for (i = 0 ; i < n_dict_signals; ++i)
       {
-       if ( ds->dict_handler_id [i] > 0)
+       if (ds->dict_handler_id [i] > 0)
          {
            g_signal_handler_unblock (ds->dict,
                                      ds->dict_handler_id[i]);
@@ -469,8 +497,8 @@ psppire_data_store_set_dictionary (PsppireDataStore *data_store, PsppireDict *di
   int i;
 
   /* Disconnect any existing handlers */
-  if ( data_store->dict )
-    for (i = 0 ; i < n_dict_signals; ++i )
+  if (data_store->dict)
+    for (i = 0 ; i < n_dict_signals; ++i)
       {
        g_signal_handler_disconnect (data_store->dict,
                                     data_store->dict_handler_id[i]);
@@ -478,7 +506,7 @@ psppire_data_store_set_dictionary (PsppireDataStore *data_store, PsppireDict *di
 
   data_store->dict = dict;
 
-  if ( dict != NULL)
+  if (dict != NULL)
     {
 
       data_store->dict_handler_id [VARIABLE_INSERTED] =
@@ -501,10 +529,10 @@ psppire_data_store_set_dictionary (PsppireDataStore *data_store, PsppireDict *di
 
   /* The entire model has changed */
 
-  if ( data_store->dict )
-    for (i = 0 ; i < n_dict_signals; ++i )
+  if (data_store->dict)
+    for (i = 0 ; i < n_dict_signals; ++i)
       {
-       if ( data_store->dict_handler_id [i] > 0)
+       if (data_store->dict_handler_id [i] > 0)
          {
            g_signal_handler_block (data_store->dict,
                                    data_store->dict_handler_id[i]);
@@ -588,7 +616,7 @@ psppire_data_store_get_value (PsppireDataStore *store,
   return TRUE;
 }
 
-  
+
 
 gchar *
 psppire_data_store_get_string (PsppireDataStore *store,
@@ -600,7 +628,7 @@ psppire_data_store_get_string (PsppireDataStore *store,
   int width = var_get_width (var);
   if (! psppire_data_store_get_value (store, row, var, &v))
     return NULL;
-  
+
   string = NULL;
   if (use_value_label)
     {
@@ -679,11 +707,10 @@ psppire_data_store_clear (PsppireDataStore *ds)
 struct casereader *
 psppire_data_store_get_reader (PsppireDataStore *ds)
 {
-  int i;
   struct casereader *reader ;
 
-  if ( ds->dict )
-    for (i = 0 ; i < n_dict_signals; ++i )
+  if (ds->dict)
+    for (int i = 0 ; i < n_dict_signals; ++i)
       {
        g_signal_handler_block (ds->dict,
                                ds->dict_handler_id[i]);
@@ -744,7 +771,7 @@ psppire_data_store_insert_case (PsppireDataStore *ds,
   cc = case_ref (cc);
   result = datasheet_insert_rows (ds->datasheet, posn, &cc, 1);
 
-  if ( result )
+  if (result)
     {
       g_signal_emit (ds, signals[ITEMS_CHANGED], 0, posn, 0, 1);
     }
@@ -769,7 +796,7 @@ psppire_data_store_set_value (PsppireDataStore *ds, casenumber casenum,
   g_return_val_if_fail (ds->datasheet, FALSE);
 
   n_cases = psppire_data_store_get_case_count (ds);
-  if ( casenum > n_cases)
+  if (casenum > n_cases)
     return FALSE;
 
   if (casenum == n_cases)
@@ -778,7 +805,10 @@ psppire_data_store_set_value (PsppireDataStore *ds, casenumber casenum,
   ok = datasheet_put_value (ds->datasheet, casenum, var_get_case_index (var),
                             v);
   if (ok)
-    g_signal_emit (ds, signals [CASE_CHANGED], 0, casenum);
+    {
+      g_signal_emit (ds, signals [CASE_CHANGED], 0, casenum);
+      g_signal_emit (ds, signals [ITEMS_CHANGED], 0, casenum, 1, 1);
+    }
 
   return ok;
 }
@@ -810,8 +840,8 @@ psppire_data_store_data_in (PsppireDataStore *ds, casenumber casenum, gint idx,
                         FALSE);
   value_init (&value, width);
   ok = (datasheet_get_value (ds->datasheet, casenum, idx, &value)
-        && data_in_msg (input, UTF8, fmt->type, &value, width,
-                        dict_get_encoding (dict->dict))
+        && data_in_msg (input, UTF8, fmt->type, settings_get_fmt_settings (),
+                        &value, width, dict_get_encoding (dict->dict))
         && datasheet_put_value (ds->datasheet, casenum, idx, &value));
   value_destroy (&value, width);
 
@@ -832,7 +862,7 @@ psppire_data_store_insert_value (PsppireDataStore *ds,
 
   g_assert (width >= 0);
 
-  if ( ! ds->datasheet )
+  if (! ds->datasheet)
     ds->datasheet = datasheet_create (NULL);
 
   value_init (&value, width);
@@ -853,20 +883,20 @@ psppire_data_store_filtered (PsppireDataStore *ds,
   const struct dictionary *dict;
   const struct variable *filter;
 
-  if ( row < 0 || row >= datasheet_get_n_rows (ds->datasheet))
+  if (row < 0 || row >= datasheet_get_n_rows (ds->datasheet))
     return FALSE;
 
   dict = ds->dict->dict;
   g_return_val_if_fail (dict, FALSE);
   filter = dict_get_filter (dict);
-  if ( ! filter)
+  if (! filter)
     return FALSE;
 
   g_return_val_if_fail (var_is_numeric (filter), FALSE);
   value_init (&val, 0);
-  if ( ! datasheet_get_value (ds->datasheet, row,
+  if (! datasheet_get_value (ds->datasheet, row,
                               var_get_case_index (filter),
-                              &val) )
+                              &val))
     return FALSE;
 
   return (val.f == 0.0);