projects / pspp / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
src/output/cairo.c (xr_chart_renderer): Set the chart size to 0.8 of the smallest...
[pspp] / src / ui / gui / psppire-data-store.c
diff --git a/src/ui/gui/psppire-data-store.c b/src/ui/gui/psppire-data-store.c
index af205ccde2c8613c6653ccfe61449b5b459435c2..59099a153e9297961a659d3bfc1a59b6d70c0ff9 100644 (file)
--- a/src/ui/gui/psppire-data-store.c
+++ b/src/ui/gui/psppire-data-store.c
@@ -1,11 +1,9 @@
-/* psppire-data-store.c
+/* PSPPIRE - a graphical user interface for PSPP.
+   Copyright (C) 2006, 2008, 2009, 2010, 2011, 2012, 2013, 2016  Free Software Foundation
 
 
-   PSPPIRE --- A Graphical User Interface for PSPP
-   Copyright (C) 2006  Free Software Foundation
-
-   This program is free software; you can redistribute it and/or modify
+   This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2 of the License, or
+   the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
@@ -14,9 +12,7 @@
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-   02110-1301, USA. */
+   along with this program.  If not, see <http://www.gnu.org/licenses/>. */
 
 #include <config.h>
 #include <string.h>
 
 #include <config.h>
 #include <string.h>
@@ -25,57 +21,63 @@
 #define _(msgid) gettext (msgid)
 #define N_(msgid) msgid
 
 #define _(msgid) gettext (msgid)
 #define N_(msgid) msgid
 
-#include <data/casewriter.h>
 #include <data/datasheet.h>
 #include <data/data-out.h>
 #include <data/variable.h>
 
 #include <data/datasheet.h>
 #include <data/data-out.h>
 #include <data/variable.h>
 
-#include <gtksheet/gtksheet.h>
-#include <gtksheet/gsheetmodel.h>
-#include <gtksheet/gsheet-column-iface.h>
+#include <ui/gui/psppire-marshal.h>
 
 #include <pango/pango-context.h>
 
 #include "psppire-data-store.h"
 
 #include <pango/pango-context.h>
 
 #include "psppire-data-store.h"
-#include "psppire-case-file.h"
+#include <libpspp/i18n.h>
 #include "helper.h"
 
 #include <data/dictionary.h>
 #include <data/missing-values.h>
 #include <data/value-labels.h>
 #include <data/data-in.h>
 #include "helper.h"
 
 #include <data/dictionary.h>
 #include <data/missing-values.h>
 #include <data/value-labels.h>
 #include <data/data-in.h>
+#include <data/format.h>
+
+#include <math/sort.h>
 
 
-#include <data/file-handle-def.h>
-#include <data/sys-file-writer.h>
+#include "xalloc.h"
+#include "xmalloca.h"
 
 
 
 static void psppire_data_store_init            (PsppireDataStore      *data_store);
 static void psppire_data_store_class_init      (PsppireDataStoreClass *class);
 
 
 
 static void psppire_data_store_init            (PsppireDataStore      *data_store);
 static void psppire_data_store_class_init      (PsppireDataStoreClass *class);
-static void psppire_data_store_sheet_model_init (GSheetModelIface *iface);
-static void psppire_data_store_sheet_column_init (GSheetColumnIface *iface);
-static void psppire_data_store_sheet_row_init (GSheetRowIface *iface);
 
 static void psppire_data_store_finalize        (GObject           *object);
 
 static void psppire_data_store_finalize        (GObject           *object);
+static void psppire_data_store_dispose        (GObject           *object);
 
 
-static gboolean psppire_data_store_clear_datum (GSheetModel *model,
-                                         gint row, gint column);
-
+static gboolean psppire_data_store_insert_case (PsppireDataStore *ds,
+                                               struct ccase *cc,
+                                               casenumber posn);
 
 
-#define MIN_COLUMNS 10
 
 
-#define TRAILING_ROWS 10
+static gboolean psppire_data_store_data_in (PsppireDataStore *ds,
+                                           casenumber casenum, gint idx,
+                                           struct substring input,
+                                           const struct fmt_spec *fmt);
 
 static GObjectClass *parent_class = NULL;
 
 
 
 static GObjectClass *parent_class = NULL;
 
 
-enum  {FONT_CHANGED,
-       n_SIGNALS};
+enum
+  {
+    BACKEND_CHANGED,
+    CASES_DELETED,
+    CASE_INSERTED,
+    CASE_CHANGED,
+    n_SIGNALS
+  };
 
 static guint signals [n_SIGNALS];
 
 
 
 static guint signals [n_SIGNALS];
 
 
-inline GType
+GType
 psppire_data_store_get_type (void)
 {
   static GType data_store_type = 0;
 psppire_data_store_get_type (void)
 {
   static GType data_store_type = 0;
@@ -95,42 +97,9 @@ psppire_data_store_get_type (void)
         (GInstanceInitFunc) psppire_data_store_init,
       };
 
         (GInstanceInitFunc) psppire_data_store_init,
       };
 
-      static const GInterfaceInfo sheet_model_info =
-      {
-       (GInterfaceInitFunc) psppire_data_store_sheet_model_init,
-       NULL,
-       NULL
-      };
-
-      static const GInterfaceInfo sheet_column_info =
-      {
-       (GInterfaceInitFunc) psppire_data_store_sheet_column_init,
-       NULL,
-       NULL
-      };
-
-      static const GInterfaceInfo sheet_row_info =
-      {
-       (GInterfaceInitFunc) psppire_data_store_sheet_row_init,
-       NULL,
-       NULL
-      };
-
-
-      data_store_type = g_type_register_static (G_TYPE_OBJECT, "PsppireDataStore",
+      data_store_type = g_type_register_static (G_TYPE_OBJECT,
+                                               "PsppireDataStore",
                                                &data_store_info, 0);
                                                &data_store_info, 0);
-
-      g_type_add_interface_static (data_store_type,
-                                  G_TYPE_SHEET_MODEL,
-                                  &sheet_model_info);
-
-      g_type_add_interface_static (data_store_type,
-                                  G_TYPE_SHEET_COLUMN,
-                                  &sheet_column_info);
-
-      g_type_add_interface_static (data_store_type,
-                                  G_TYPE_SHEET_ROW,
-                                  &sheet_row_info);
     }
 
   return data_store_type;
     }
 
   return data_store_type;
@@ -146,9 +115,10 @@ psppire_data_store_class_init (PsppireDataStoreClass *class)
   object_class = (GObjectClass*) class;
 
   object_class->finalize = psppire_data_store_finalize;
   object_class = (GObjectClass*) class;
 
   object_class->finalize = psppire_data_store_finalize;
+  object_class->dispose = psppire_data_store_dispose;
 
 
-  signals [FONT_CHANGED] =
-    g_signal_new ("font_changed",
+  signals [BACKEND_CHANGED] =
+    g_signal_new ("backend-changed",
                  G_TYPE_FROM_CLASS (class),
                  G_SIGNAL_RUN_FIRST,
                  0,
                  G_TYPE_FROM_CLASS (class),
                  G_SIGNAL_RUN_FIRST,
                  0,
@@ -156,172 +126,136 @@ psppire_data_store_class_init (PsppireDataStoreClass *class)
                  g_cclosure_marshal_VOID__VOID,
                  G_TYPE_NONE,
                  0);
                  g_cclosure_marshal_VOID__VOID,
                  G_TYPE_NONE,
                  0);
-}
-
-
-
-static gint
-psppire_data_store_get_var_count (const GSheetModel *model)
-{
-  const PsppireDataStore *store = PSPPIRE_DATA_STORE (model);
-
-  return psppire_dict_get_var_cnt (store->dict);
-}
-
-static gint
-psppire_data_store_get_case_count (const GSheetModel *model)
-{
-  const PsppireDataStore *store = PSPPIRE_DATA_STORE (model);
-
-  return psppire_case_file_get_case_count (store->case_file);
-}
-
-
-static void
-psppire_data_store_init (PsppireDataStore *data_store)
-{
-  data_store->dict = 0;
-  data_store->case_file = 0;
-  data_store->width_of_m = 10;
-}
 
 
-const PangoFontDescription *
-psppire_data_store_get_font_desc (const GSheetModel *model,
-                             gint row, gint column)
-{
-  PsppireDataStore *store = PSPPIRE_DATA_STORE (model);
+  signals [CASE_INSERTED] =
+    g_signal_new ("case-inserted",
+                 G_TYPE_FROM_CLASS (class),
+                 G_SIGNAL_RUN_FIRST,
+                 0,
+                 NULL, NULL,
+                 g_cclosure_marshal_VOID__INT,
+                 G_TYPE_NONE,
+                 1,
+                 G_TYPE_INT);
 
 
-  return store->font_desc;
-}
-
-static inline gchar *
-psppire_data_store_get_string_wrapper (const GSheetModel *model, gint row,
-                                      gint column)
-{
-  return psppire_data_store_get_string (PSPPIRE_DATA_STORE (model), row, column);
-}
 
 
+  signals [CASE_CHANGED] =
+    g_signal_new ("case-changed",
+                 G_TYPE_FROM_CLASS (class),
+                 G_SIGNAL_RUN_FIRST,
+                 0,
+                 NULL, NULL,
+                 g_cclosure_marshal_VOID__INT,
+                 G_TYPE_NONE,
+                 1,
+                 G_TYPE_INT);
 
 
-static inline gboolean
-psppire_data_store_set_string_wrapper (GSheetModel *model,
-                                      const gchar *text,
-                                      gint row, gint column)
-{
-  return psppire_data_store_set_string (PSPPIRE_DATA_STORE (model), text,
-                                       row, column);
+  signals [CASES_DELETED] =
+    g_signal_new ("cases-deleted",
+                 G_TYPE_FROM_CLASS (class),
+                 G_SIGNAL_RUN_FIRST,
+                 0,
+                 NULL, NULL,
+                 psppire_marshal_VOID__INT_INT,
+                 G_TYPE_NONE,
+                 2,
+                 G_TYPE_INT,
+                 G_TYPE_INT);
 }
 
 
 
 }
 
 
 
+static gboolean
+psppire_data_store_insert_value (PsppireDataStore *ds,
+                                 gint width, gint where);
 
 
-static void
-psppire_data_store_sheet_model_init (GSheetModelIface *iface)
+casenumber
+psppire_data_store_get_case_count (const PsppireDataStore *store)
 {
 {
-  iface->free_strings = TRUE;
-  iface->get_string = psppire_data_store_get_string_wrapper;
-  iface->set_string = psppire_data_store_set_string_wrapper;
-  iface->clear_datum = psppire_data_store_clear_datum;
-  iface->is_editable = NULL;
-  iface->is_visible = NULL;
-  iface->get_foreground = NULL;
-  iface->get_background = NULL;
-  iface->get_font_desc = psppire_data_store_get_font_desc;
-  iface->get_cell_border = NULL;
-  iface->get_column_count = psppire_data_store_get_var_count;
-  iface->get_row_count = psppire_data_store_get_case_count;
+  return datasheet_get_n_rows (store->datasheet);
 }
 
 }
 
-static
-gboolean always_true ()
+size_t
+psppire_data_store_get_value_count (const PsppireDataStore *store)
 {
 {
-  return TRUE;
+  return psppire_dict_get_value_cnt (store->dict);
 }
 
 }
 
-
-static void
-delete_cases_callback (GtkWidget *w, gint first, gint n_cases, gpointer data)
+const struct caseproto *
+psppire_data_store_get_proto (const PsppireDataStore *store)
 {
 {
-  PsppireDataStore *store  ;
-
-  g_return_if_fail (data);
-
-  store  = PSPPIRE_DATA_STORE (data);
-
-  g_assert (first >= 0);
-
-  g_sheet_model_rows_deleted (G_SHEET_MODEL (store), first, n_cases);
+  return psppire_dict_get_proto (store->dict);
 }
 
 }
 
-
 static void
 static void
-insert_case_callback (GtkWidget *w, gint casenum, gpointer data)
+psppire_data_store_init (PsppireDataStore *data_store)
 {
 {
-  PsppireDataStore *store  ;
-
-  g_return_if_fail (data);
-
-  store  = PSPPIRE_DATA_STORE (data);
-
-  g_sheet_model_range_changed (G_SHEET_MODEL (store),
-                              casenum, -1,
-                              psppire_case_file_get_case_count (store->case_file),
-                              -1);
-
-  g_sheet_model_rows_inserted (G_SHEET_MODEL (store), casenum, 1);
+  data_store->dict = NULL;
+  data_store->datasheet = NULL;
+  data_store->dispose_has_run = FALSE;
 }
 
 }
 
-
+/*
+   A callback which occurs after a variable has been deleted.
+ */
 static void
 static void
-changed_case_callback (GtkWidget *w, gint casenum, gpointer data)
+delete_variable_callback (GObject *obj, const struct variable *var UNUSED,
+                          gint dict_index, gint case_index,
+                          gpointer data)
 {
 {
-  PsppireDataStore *store  ;
-  g_return_if_fail (data);
+  PsppireDataStore *store  = PSPPIRE_DATA_STORE (data);
 
 
-  store  = PSPPIRE_DATA_STORE (data);
+  g_return_if_fail (store->datasheet);
 
 
-  g_sheet_model_range_changed (G_SHEET_MODEL (store),
-                                casenum, -1,
-                                casenum, -1);
+  datasheet_delete_columns (store->datasheet, case_index, 1);
+  datasheet_insert_column (store->datasheet, NULL, -1, case_index);
 }
 
 }
 
+struct resize_datum_aux
+  {
+    const struct dictionary *dict;
+    const struct variable *new_variable;
+    const struct variable *old_variable;
+  };
 
 static void
 
 static void
-delete_variables_callback (GObject *obj, gint var_num, gint n_vars, gpointer data)
+resize_datum (const union value *old, union value *new, const void *aux_)
 {
 {
-  PsppireDataStore *store ;
-
-  g_return_if_fail (data);
-
-  store  = PSPPIRE_DATA_STORE (data);
-
-  g_sheet_model_columns_deleted (G_SHEET_MODEL (store), var_num, n_vars);
-
-  g_sheet_column_columns_changed (G_SHEET_COLUMN (store),
-                                  var_num, -1);
+  const struct resize_datum_aux *aux = 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));
+  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 (s);
 }
 
 }
 
-
 static void
 static void
-variable_changed_callback (GObject *obj, gint var_num, gpointer data)
+variable_changed_callback (GObject *obj, gint var_num, guint what, const struct variable *oldvar,
+                          gpointer data)
 {
 {
-  PsppireDataStore *store;
-
-  g_return_if_fail (data);
-
-  store  = PSPPIRE_DATA_STORE (data);
-
-  g_sheet_column_columns_changed (G_SHEET_COLUMN (store),
-                                 var_num, 1);
-
+  PsppireDataStore *store  = PSPPIRE_DATA_STORE (data);
+  struct variable *variable = psppire_dict_get_variable (store->dict, var_num);
 
 
-  g_sheet_model_range_changed (G_SHEET_MODEL (store),
-                              -1, var_num,
-                              -1, var_num);
+  if (what & VAR_TRAIT_WIDTH)
+    {
+      int posn = var_get_case_index (variable);
+      struct resize_datum_aux aux;
+      aux.old_variable = oldvar;
+      aux.new_variable = variable;
+      aux.dict = store->dict->dict;
+      datasheet_resize_column (store->datasheet, posn, var_get_width (variable),
+                               resize_datum, &aux);
+    }
 }
 
 static void
 insert_variable_callback (GObject *obj, gint var_num, gpointer data)
 {
 }
 
 static void
 insert_variable_callback (GObject *obj, gint var_num, gpointer data)
 {
+  struct variable *variable;
   PsppireDataStore *store;
   gint posn;
 
   PsppireDataStore *store;
   gint posn;
 
@@ -329,44 +263,11 @@ insert_variable_callback (GObject *obj, gint var_num, gpointer data)
 
   store  = PSPPIRE_DATA_STORE (data);
 
 
   store  = PSPPIRE_DATA_STORE (data);
 
-  if ( var_num > 0 )
-    {
-      struct variable *variable =
-       psppire_dict_get_variable (store->dict, var_num);
-
-      g_assert (variable != NULL);
-
-      posn = var_get_case_index (variable);
-    }
-  else
-    {
-      posn = 0;
-    }
-
-  psppire_case_file_insert_values (store->case_file, 1, posn);
-
-  g_sheet_column_columns_changed (G_SHEET_COLUMN (store),
-                                 var_num, 1);
-
-  g_sheet_model_columns_inserted (G_SHEET_MODEL (store), var_num, 1);
-}
-
-
-static void
-dict_size_change_callback (GObject *obj,
-                         gint posn, gint adjustment, gpointer data)
-{
-  PsppireDataStore *store ;
-
-  g_return_if_fail (data);
-
-  store  = PSPPIRE_DATA_STORE (data);
-
-  psppire_case_file_insert_values (store->case_file, adjustment, posn);
+  variable = psppire_dict_get_variable (store->dict, var_num);
+  posn = var_get_case_index (variable);
+  psppire_data_store_insert_value (store, var_get_width (variable), posn);
 }
 
 }
 
-
-
 /**
  * psppire_data_store_new:
  * @dict: The dictionary for this data_store.
 /**
  * psppire_data_store_new:
  * @dict: The dictionary for this data_store.
@@ -379,41 +280,38 @@ psppire_data_store_new (PsppireDict *dict)
 {
   PsppireDataStore *retval;
 
 {
   PsppireDataStore *retval;
 
-  retval = g_object_new (GTK_TYPE_DATA_STORE, NULL);
+  retval = g_object_new (PSPPIRE_TYPE_DATA_STORE, NULL);
 
   psppire_data_store_set_dictionary (retval, dict);
 
   return retval;
 }
 
 
   psppire_data_store_set_dictionary (retval, dict);
 
   return retval;
 }
 
-
 void
 void
-psppire_data_store_set_case_file (PsppireDataStore *data_store,
-                                 PsppireCaseFile *cf)
+psppire_data_store_set_reader (PsppireDataStore *ds,
+                              struct casereader *reader)
 {
 {
-  if ( data_store->case_file)
-    {
-      g_object_unref (data_store->case_file);
-    }
+  gint i;
 
 
-  data_store->case_file = cf;
+  if ( ds->datasheet)
+    datasheet_destroy (ds->datasheet);
 
 
-  g_signal_connect (data_store->case_file, "cases-deleted",
-                  G_CALLBACK (delete_cases_callback),
-                  data_store);
-
-  g_signal_connect (data_store->case_file, "case-inserted",
-                  G_CALLBACK (insert_case_callback),
-                  data_store);
+  ds->datasheet = datasheet_create (reader);
 
 
+  if ( ds->dict )
+    for (i = 0 ; i < n_dict_signals; ++i )
+      {
+       if ( ds->dict_handler_id [i] > 0)
+         {
+           g_signal_handler_unblock (ds->dict,
+                                     ds->dict_handler_id[i]);
+         }
+      }
 
 
-  g_signal_connect (data_store->case_file, "case-changed",
-                  G_CALLBACK (changed_case_callback),
-                  data_store);
+  g_signal_emit (ds, signals[BACKEND_CHANGED], 0);
 }
 
 
 }
 
 
-
 /**
  * psppire_data_store_replace_set_dictionary:
  * @data_store: The variable store
 /**
  * psppire_data_store_replace_set_dictionary:
  * @data_store: The variable store
@@ -425,274 +323,199 @@ psppire_data_store_set_case_file (PsppireDataStore *data_store,
 void
 psppire_data_store_set_dictionary (PsppireDataStore *data_store, PsppireDict *dict)
 {
 void
 psppire_data_store_set_dictionary (PsppireDataStore *data_store, PsppireDict *dict)
 {
+  int i;
+
+  /* Disconnect any existing handlers */
+  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]);
+      }
+
   data_store->dict = dict;
 
   data_store->dict = dict;
 
-  g_signal_connect (dict, "variable-inserted",
-                  G_CALLBACK (insert_variable_callback),
-                  data_store);
+  if ( dict != NULL)
+    {
+
+      data_store->dict_handler_id [VARIABLE_INSERTED] =
+       g_signal_connect (dict, "variable-inserted",
+                         G_CALLBACK (insert_variable_callback),
+                         data_store);
 
 
-  g_signal_connect (dict, "variables-deleted",
-                  G_CALLBACK (delete_variables_callback),
-                  data_store);
+      data_store->dict_handler_id [VARIABLE_DELETED] =
+       g_signal_connect (dict, "variable-deleted",
+                         G_CALLBACK (delete_variable_callback),
+                         data_store);
 
 
-  g_signal_connect (dict, "variable-changed",
-                  G_CALLBACK (variable_changed_callback),
-                  data_store);
+      data_store->dict_handler_id [VARIABLE_CHANGED] =
+       g_signal_connect (dict, "variable-changed",
+                         G_CALLBACK (variable_changed_callback),
+                         data_store);
+    }
 
 
 
 
-  g_signal_connect (dict, "dict-size-changed",
-                   G_CALLBACK (dict_size_change_callback),
-                   data_store);
 
   /* The entire model has changed */
 
   /* The entire model has changed */
-  g_sheet_model_range_changed (G_SHEET_MODEL (data_store), -1, -1, -1, -1);
 
 
-  g_sheet_column_columns_changed (G_SHEET_COLUMN (data_store), 0, -1);
+  if ( data_store->dict )
+    for (i = 0 ; i < n_dict_signals; ++i )
+      {
+       if ( data_store->dict_handler_id [i] > 0)
+         {
+           g_signal_handler_block (data_store->dict,
+                                   data_store->dict_handler_id[i]);
+         }
+      }
 }
 
 static void
 psppire_data_store_finalize (GObject *object)
 {
 }
 
 static void
 psppire_data_store_finalize (GObject *object)
 {
+  PsppireDataStore *ds = PSPPIRE_DATA_STORE (object);
+
+  if (ds->datasheet)
+    {
+      datasheet_destroy (ds->datasheet);
+      ds->datasheet = NULL;
+    }
 
   /* must chain up */
   (* parent_class->finalize) (object);
 }
 
 
 
   /* must chain up */
   (* parent_class->finalize) (object);
 }
 
 
+static void
+psppire_data_store_dispose (GObject *object)
+{
+  PsppireDataStore *ds = PSPPIRE_DATA_STORE (object);
+
+  if (ds->dispose_has_run)
+    return;
+
+  psppire_data_store_set_dictionary (ds, NULL);
+
+  /* must chain up */
+  (* parent_class->dispose) (object);
+
+  ds->dispose_has_run = TRUE;
+}
+
+
 
 /* Insert a blank case before POSN */
 gboolean
 
 /* Insert a blank case before POSN */
 gboolean
-psppire_data_store_insert_new_case (PsppireDataStore *ds, gint posn)
+psppire_data_store_insert_new_case (PsppireDataStore *ds, casenumber posn)
 {
   gboolean result;
 {
   gboolean result;
-  gint val_cnt, v;
-  struct ccase cc;
+  const struct caseproto *proto;
+  struct ccase *cc;
   g_return_val_if_fail (ds, FALSE);
 
   g_return_val_if_fail (ds, FALSE);
 
+  proto = datasheet_get_proto (ds->datasheet);
+  g_return_val_if_fail (caseproto_get_n_widths (proto) > 0, FALSE);
+  g_return_val_if_fail (posn <= psppire_data_store_get_case_count (ds), FALSE);
 
 
-  /* Opportunity for optimisation exists here when creating a blank case */
-  val_cnt = datasheet_get_column_cnt (ds->case_file->datasheet) ;
-
-  case_create (&cc, val_cnt);
-
-  memset ( case_data_rw_idx (&cc, 0), 0, val_cnt * MAX_SHORT_STRING);
-
-  for (v = 0 ; v < psppire_dict_get_var_cnt (ds->dict) ; ++v)
-    {
-      const struct variable *pv = psppire_dict_get_variable (ds->dict, v);
-      if ( var_is_alpha (pv))
-       continue;
-
-      case_data_rw (&cc, pv)->f = SYSMIS;
-    }
+  cc = case_create (proto);
+  case_set_missing (cc);
 
 
-  result = psppire_case_file_insert_case (ds->case_file, &cc, posn);
+  result = psppire_data_store_insert_case (ds, cc, posn);
 
 
-  case_destroy (&cc);
+  case_unref (cc);
 
   return result;
 }
 
 
   return result;
 }
 
-
 gchar *
 gchar *
-psppire_data_store_get_string (PsppireDataStore *store, gint row, gint column)
+psppire_data_store_get_string (PsppireDataStore *store,
+                               glong row, const struct variable *var,
+                               bool use_value_label)
 {
 {
-  gint idx;
-  char *text;
-  const struct fmt_spec *fp ;
-  const struct variable *pv ;
-  union value *v ;
-  GString *s;
-
-  g_return_val_if_fail (store->dict, NULL);
-  g_return_val_if_fail (store->case_file, NULL);
+  gchar *string;
+  union value v;
+  int width;
 
 
-  if (column >= psppire_dict_get_var_cnt (store->dict))
-    return NULL;
+  g_return_val_if_fail (store != NULL, NULL);
+  g_return_val_if_fail (store->datasheet != NULL, NULL);
+  g_return_val_if_fail (var != NULL, NULL);
 
 
-  if ( row >= psppire_case_file_get_case_count (store->case_file))
+  if (row < 0 || row >= datasheet_get_n_rows (store->datasheet))
     return NULL;
 
     return NULL;
 
-  pv = psppire_dict_get_variable (store->dict, column);
-
-  g_assert (pv);
-
-  idx = var_get_case_index (pv);
+  width = var_get_width (var);
+  value_init (&v, width);
+  datasheet_get_value (store->datasheet, row, var_get_case_index (var), &v);
 
 
-  g_assert (idx >= 0);
-
-  v = psppire_case_file_get_value (store->case_file, row, idx, NULL,
-                                   var_get_width (pv));
-
-  g_return_val_if_fail (v, NULL);
-
-  if ( store->show_labels)
+  string = NULL;
+  if (use_value_label)
     {
     {
-      const gchar *label = var_lookup_value_label (pv, v);
-      if (label)
-        {
-          free (v);
-         return pspp_locale_to_utf8 (label, -1, 0);
-        }
+      const char *label = var_lookup_value_label (var, &v);
+      if (label != NULL)
+        string = g_strdup (label);
     }
     }
+  if (string == NULL)
+    string = value_to_text (v, var);
 
 
-  fp = var_get_write_format (pv);
-
-  s = g_string_sized_new (fp->w + 1);
-  g_string_set_size (s, fp->w);
+  value_destroy (&v, width);
 
 
-  memset (s->str, 0, fp->w);
-
-  g_assert (fp->w == s->len);
-
-  /* Converts binary value V into printable form in the exactly
-     FP->W character in buffer S according to format specification
-     FP.  No null terminator is appended to the buffer.  */
-  data_out (v, fp, s->str);
-
-  text = pspp_locale_to_utf8 (s->str, fp->w, 0);
-  g_string_free (s, TRUE);
-
-  g_strchomp (text);
-
-  free (v);
-  return text;
+  return string;
 }
 
 
 }
 
 
-static gboolean
-psppire_data_store_clear_datum (GSheetModel *model,
-                                         gint row, gint col)
+/* Attempts to update that part of the variable store which corresponds to VAR
+   within ROW with the value TEXT.
 
 
-{
-  PsppireDataStore *store = PSPPIRE_DATA_STORE (model);
+   If USE_VALUE_LABEL is true, and TEXT is a value label for the column's
+   variable, then stores the value from that value label instead of the literal
+   TEXT.
 
 
-  union value v;
-  const struct variable *pv = psppire_dict_get_variable (store->dict, col);
-
-  const gint index = var_get_case_index (pv) ;
-
-  if ( var_is_numeric (pv))
-    v.f = SYSMIS;
-  else
-    memcpy (v.s, "", MAX_SHORT_STRING);
-
-  psppire_case_file_set_value (store->case_file, row, index, &v,
-                             var_get_width (pv));
-
-  return TRUE;
-}
-
-
-/* Attempts to update that part of the variable store which corresponds
-   to ROW, COL with  the value TEXT.
-   Returns true if anything was updated, false otherwise.
-*/
+   Returns true if anything was updated, false otherwise.  */
 gboolean
 psppire_data_store_set_string (PsppireDataStore *store,
 gboolean
 psppire_data_store_set_string (PsppireDataStore *store,
-                              const gchar *text, gint row, gint col)
-{
-  const struct variable *pv = psppire_dict_get_variable (store->dict, col);
-  g_return_val_if_fail (pv, FALSE);
-
-#if 0
-  /* Allow the user to insert a lot of blank cases, simply by skipping rows */
-  for (r = psppire_case_file_get_case_count (store->case_file); r <= row ; ++r)
+                              const gchar *text,
+                               glong row, const struct variable *var,
+                               gboolean use_value_label)
+{
+  gint case_index;
+  glong n_cases;
+  gboolean ok;
+
+  n_cases = psppire_data_store_get_case_count (store);
+  if (row > n_cases)
+    return FALSE;
+  if (row == n_cases)
+    psppire_data_store_insert_new_case (store, row);
+
+  case_index = var_get_case_index (var);
+  if (use_value_label)
     {
     {
-
-      gint c;
-
-      psppire_case_array_insert_case (store->cases, r, 0, 0);
-
-
-      for (c = 0 ; c < psppire_dict_get_var_cnt (store->dict); ++c )
-       psppire_data_store_clear_datum (model, r, c);
+      const struct val_labs *vls = var_get_value_labels (var);
+      const union value *value = vls ? val_labs_find_value (vls, text) : NULL;
+      if (value)
+        ok = datasheet_put_value (store->datasheet, row, case_index, value);
+      else
+        ok = FALSE;
     }
     }
-#endif
-
-  psppire_case_file_data_in (store->case_file, row,
-                             var_get_case_index (pv), ss_cstr (text),
-                             var_get_write_format (pv));
-
-  return TRUE;
-}
-
-
-void
-psppire_data_store_set_font (PsppireDataStore *store,
-                           const PangoFontDescription *fd)
-{
-  g_return_if_fail (store);
-  g_return_if_fail (PSPPIRE_IS_DATA_STORE (store));
-
-  store->font_desc = fd;
-#if 0
-  store->width_of_m = calc_m_width (fd);
-#endif
-  g_signal_emit (store, signals [FONT_CHANGED], 0);
-
-
-  g_sheet_model_range_changed (G_SHEET_MODEL (store),
-                                -1, -1, -1, -1);
-}
-
-
-void
-psppire_data_store_show_labels (PsppireDataStore *store, gboolean show_labels)
-{
-  g_return_if_fail (store);
-  g_return_if_fail (PSPPIRE_IS_DATA_STORE (store));
-
-  store->show_labels = show_labels;
+  else
+    ok = psppire_data_store_data_in (store, row, case_index, ss_cstr (text),
+                                     var_get_print_format (var));
 
 
-  g_sheet_model_range_changed (G_SHEET_MODEL (store),
-                                -1, -1, -1, -1);
+  if (ok)
+    g_signal_emit (store, signals [CASE_CHANGED], 0, row);
+  return ok;
 }
 
 
 
 }
 
 
 
-/* FIXME: There's no reason to actually have this function.
-   It should be done by a procedure */
 void
 void
-psppire_data_store_create_system_file (PsppireDataStore *store,
-                             struct file_handle *handle)
+psppire_data_store_clear (PsppireDataStore *ds)
 {
 {
-  gint i, var_cnt;
-  const struct sfm_write_options wo = {
-    true, /* writeable */
-    false, /* dont compress */
-    3 /* version */
-  };
-
-  struct casewriter *writer;
-
-  g_assert (handle);
-
-  writer = sfm_open_writer (handle, store->dict->dict, wo);
-
-  if ( ! writer)
-    return;
-
-
-  var_cnt = psppire_data_store_get_var_count (G_SHEET_MODEL (store));
+  datasheet_destroy (ds->datasheet);
+  ds->datasheet = NULL;
 
 
-  for (i = 0 ; i < psppire_case_file_get_case_count (store->case_file); ++i )
-    {
-      struct ccase c;
-      psppire_case_file_get_case (store->case_file, i, &c);
-      casewriter_write (writer, &c);
-    }
-  casewriter_destroy (writer);
-}
-
-
-
-void
-psppire_data_store_clear (PsppireDataStore *data_store)
-{
-  psppire_case_file_clear (data_store->case_file);
+  psppire_dict_clear (ds->dict);
 
 
-  psppire_dict_clear (data_store->dict);
+  g_signal_emit (ds, signals [CASES_DELETED], 0, 0, -1);
 }
 
 
 }
 
 
@@ -701,177 +524,193 @@ psppire_data_store_clear (PsppireDataStore *data_store)
 struct casereader *
 psppire_data_store_get_reader (PsppireDataStore *ds)
 {
 struct casereader *
 psppire_data_store_get_reader (PsppireDataStore *ds)
 {
+  int i;
   struct casereader *reader ;
 
   struct casereader *reader ;
 
-  reader = psppire_case_file_make_reader (ds->case_file);
-
-  return reader;
-}
+  if ( ds->dict )
+    for (i = 0 ; i < n_dict_signals; ++i )
+      {
+       g_signal_handler_block (ds->dict,
+                               ds->dict_handler_id[i]);
+      }
 
 
+  reader = datasheet_make_reader (ds->datasheet);
 
 
+  /* We must not reference this again */
+  ds->datasheet = NULL;
 
 
-/* Column related funcs */
+  return reader;
+}
 
 
-static gint
-geometry_get_column_count (const GSheetColumn *geom)
+/* Returns the CASENUMth case, or a null pointer on failure.
+ */
+struct ccase *
+psppire_data_store_get_case (const PsppireDataStore *ds,
+                            casenumber casenum)
 {
 {
-  PsppireDataStore *ds = PSPPIRE_DATA_STORE (geom);
+  g_return_val_if_fail (ds, FALSE);
+  g_return_val_if_fail (ds->datasheet, FALSE);
 
 
-  return MAX (MIN_COLUMNS, psppire_dict_get_var_cnt (ds->dict));
+  return datasheet_get_row (ds->datasheet, casenum);
 }
 
 
 }
 
 
-
-static gint
-geometry_get_width (const GSheetColumn *geom, gint unit)
+gboolean
+psppire_data_store_delete_cases (PsppireDataStore *ds, casenumber first,
+                                casenumber n_cases)
 {
 {
-  const struct variable *pv ;
-  PsppireDataStore *ds = PSPPIRE_DATA_STORE (geom);
-
-  if ( unit >= psppire_dict_get_var_cnt (ds->dict) )
-    return ds->width_of_m * 8 ;
-
-  pv = psppire_dict_get_variable (ds->dict, unit);
+  g_return_val_if_fail (ds, FALSE);
+  g_return_val_if_fail (ds->datasheet, FALSE);
 
 
-  if ( pv == NULL )
-    return ds->width_of_m * 8 ;
+  g_return_val_if_fail (first + n_cases <=
+                       psppire_data_store_get_case_count (ds), FALSE);
 
 
-  return ds->width_of_m * var_get_display_width (pv);
-}
 
 
-static void
-geometry_set_width (GSheetColumn *geom, gint unit, gint width)
-{
-  PsppireDataStore *ds = PSPPIRE_DATA_STORE (geom);
+  datasheet_delete_rows (ds->datasheet, first, n_cases);
 
 
-  struct variable *pv = psppire_dict_get_variable (ds->dict, unit);
+  g_signal_emit (ds, signals [CASES_DELETED], 0, first, n_cases);
 
 
-  var_set_display_width (pv, width / ds->width_of_m );
+  return TRUE;
 }
 
 
 
 }
 
 
 
-static GtkJustification
-geometry_get_justification (const GSheetColumn *geom, gint unit)
+/* Insert case CC into the case file before POSN */
+static gboolean
+psppire_data_store_insert_case (PsppireDataStore *ds,
+                               struct ccase *cc,
+                               casenumber posn)
 {
 {
-  PsppireDataStore *ds = PSPPIRE_DATA_STORE (geom);
-  const struct variable *pv ;
+  bool result ;
 
 
+  g_return_val_if_fail (ds, FALSE);
+  g_return_val_if_fail (ds->datasheet, FALSE);
 
 
-  if ( unit >= psppire_dict_get_var_cnt (ds->dict) )
-    return GTK_JUSTIFY_LEFT;
+  cc = case_ref (cc);
+  result = datasheet_insert_rows (ds->datasheet, posn, &cc, 1);
 
 
-  pv = psppire_dict_get_variable (ds->dict, unit);
+  if ( result )
+    g_signal_emit (ds, signals [CASE_INSERTED], 0, posn);
+  else
+    g_warning ("Cannot insert case at position %ld\n", posn);
 
 
-  return (var_get_alignment (pv) == ALIGN_LEFT ? GTK_JUSTIFY_LEFT
-          : var_get_alignment (pv) == ALIGN_RIGHT ? GTK_JUSTIFY_RIGHT
-          : GTK_JUSTIFY_CENTER);
+  return result;
 }
 
 
 }
 
 
-static const gchar null_var_name[]=N_("var");
-
-static gchar *
-geometry_get_column_button_label (const GSheetColumn *geom, gint unit)
+/* Set the value of VAR in case CASENUM to V.
+   V must be the correct width for IDX.
+   Returns true if successful, false on I/O error. */
+gboolean
+psppire_data_store_set_value (PsppireDataStore *ds, casenumber casenum,
+                             const struct variable *var, const union value *v)
 {
 {
-  gchar *text;
-  struct variable *pv ;
-  PsppireDataStore *ds = PSPPIRE_DATA_STORE (geom);
+  glong n_cases;
+  bool ok;
+
+  g_return_val_if_fail (ds, FALSE);
+  g_return_val_if_fail (ds->datasheet, FALSE);
 
 
-  if ( unit >= psppire_dict_get_var_cnt (ds->dict) )
-    return g_locale_to_utf8 (null_var_name, -1, 0, 0, 0);
+  n_cases = psppire_data_store_get_case_count (ds);
+  if ( casenum > n_cases)
+    return FALSE;
 
 
-  pv = psppire_dict_get_variable (ds->dict, unit);
+  if (casenum == n_cases)
+    psppire_data_store_insert_new_case (ds, casenum);
 
 
-  text =  pspp_locale_to_utf8 (var_get_name (pv), -1, 0);
+  ok = datasheet_put_value (ds->datasheet, casenum, var_get_case_index (var),
+                            v);
+  if (ok)
+    g_signal_emit (ds, signals [CASE_CHANGED], 0, casenum);
 
 
-  return text;
+  return ok;
 }
 
 
 }
 
 
-static gboolean
-geometry_get_sensitivity (const GSheetColumn *geom, gint unit)
-{
-  PsppireDataStore *ds = PSPPIRE_DATA_STORE (geom);
-
-  return (unit < psppire_dict_get_var_cnt (ds->dict));
-}
 
 
 
 
-static void
-psppire_data_store_sheet_column_init (GSheetColumnIface *iface)
+/* Set the IDXth value of case C using D_IN */
+static gboolean
+psppire_data_store_data_in (PsppireDataStore *ds, casenumber casenum, gint idx,
+                           struct substring input, const struct fmt_spec *fmt)
 {
 {
-  iface->get_column_count = geometry_get_column_count;
-  iface->get_width = geometry_get_width;
-  iface->set_width = geometry_set_width;
-  iface->get_visibility = always_true;
-  iface->get_sensitivity = geometry_get_sensitivity;
-  iface->get_justification = geometry_get_justification;
-  iface->get_button_label = geometry_get_column_button_label;
-}
+  union value value;
+  int width;
+  bool ok;
 
 
+  PsppireDict *dict;
 
 
-/* Row related funcs */
+  g_return_val_if_fail (ds, FALSE);
+  g_return_val_if_fail (ds->datasheet, FALSE);
 
 
-static gint
-geometry_get_row_count (const GSheetRow *geom, gpointer data)
-{
-  PsppireDataStore *ds = PSPPIRE_DATA_STORE (geom);
+  g_return_val_if_fail (idx < datasheet_get_n_columns (ds->datasheet), FALSE);
 
 
-  return TRAILING_ROWS + psppire_case_file_get_case_count (ds->case_file);
-}
+  dict = ds->dict;
 
 
+  width = fmt_var_width (fmt);
+  g_return_val_if_fail (caseproto_get_width (
+                          datasheet_get_proto (ds->datasheet), idx) == width,
+                        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))
+        && datasheet_put_value (ds->datasheet, casenum, idx, &value));
+  value_destroy (&value, width);
 
 
-static gint
-geometry_get_height (const GSheetRow *geom, gint unit, gpointer data)
-{
-  return 25;
+  return ok;
 }
 
 }
 
-
+/* Resize the cases in the casefile, by inserting a value of the
+   given WIDTH into every one of them at the position immediately
+   preceding WHERE.
+*/
 static gboolean
 static gboolean
-geometry_get_row_sensitivity (const GSheetRow *geom, gint unit, gpointer data)
+psppire_data_store_insert_value (PsppireDataStore *ds,
+                                 gint width, gint where)
 {
 {
-  PsppireDataStore *ds = PSPPIRE_DATA_STORE (geom);
-
-
-  return (unit < psppire_case_file_get_case_count (ds->case_file));
-}
-
+  union value value;
 
 
-static gchar *
-geometry_get_row_button_label (const GSheetRow *geom, gint unit, gpointer data)
-{
-  gchar *text;
-  gchar *s;
-  PsppireDataStore *ds = PSPPIRE_DATA_STORE (geom);
+  g_return_val_if_fail (ds, FALSE);
 
 
-  if ( unit >
-       TRAILING_ROWS + psppire_case_file_get_case_count (ds->case_file))
-    return 0;
+  g_assert (width >= 0);
 
 
-  s = g_strdup_printf (_("%d"), unit);
+  if ( ! ds->datasheet )
+    ds->datasheet = datasheet_create (NULL);
 
 
-  text =  pspp_locale_to_utf8 (s, -1, 0);
+  value_init (&value, width);
+  value_set_missing (&value, width);
 
 
-  g_free (s);
+  datasheet_insert_column (ds->datasheet, &value, width, where);
+  value_destroy (&value, width);
 
 
-  return text;
+  return TRUE;
 }
 
 }
 
-
-static void
-psppire_data_store_sheet_row_init (GSheetRowIface *iface)
+gboolean
+psppire_data_store_filtered (PsppireDataStore *ds,
+                             glong row)
 {
 {
-  iface->get_row_count = geometry_get_row_count;
+  union value val;
 
 
-  iface->get_height = geometry_get_height;
-  iface->set_height = 0;
-  iface->get_visibility = always_true;
-  iface->get_sensitivity = geometry_get_row_sensitivity;
+  const struct dictionary *dict;
+  const struct variable *filter;
 
 
-  iface->get_button_label = geometry_get_row_button_label;
-}
+  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)
+    return FALSE;
 
 
+  g_return_val_if_fail (var_is_numeric (filter), FALSE);
+  value_init (&val, 0);
+  if ( ! datasheet_get_value (ds->datasheet, row,
+                              var_get_case_index (filter),
+                              &val) )
+    return FALSE;
 
 
+  return (val.f == 0.0);
+}
Unnamed repository; edit this file to name it for gitweb.