X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Fui%2Fgui%2Fpsppire-dict.c;h=c82395f2ebdc047e1f8678b9e9d6873df2452207;hb=729b96a6bd9342c45e6f65a113fd87c70da85b0a;hp=94023f55bded26ed7c944163656951c2c9dd1575;hpb=888d0f91d57e0c3c5a4206c30ac71eb87bf44227;p=pspp-builds.git diff --git a/src/ui/gui/psppire-dict.c b/src/ui/gui/psppire-dict.c index 94023f55..c82395f2 100644 --- a/src/ui/gui/psppire-dict.c +++ b/src/ui/gui/psppire-dict.c @@ -1,61 +1,65 @@ -/* - PSPPIRE --- A Graphical User Interface for PSPP - Copyright (C) 2004, 2006 Free Software Foundation - Written by John Darrington +/* PSPPIRE - a graphical user interface for PSPP. + Copyright (C) 2004, 2006, 2007, 2009 Free Software Foundation - 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 - the Free Software Foundation; either version 2 of the License, or - (at your option) any later version. + 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 + 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, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - 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. */ + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + 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, see . */ +#include #include #include #include -#include +#include -#include "psppire-object.h" #include "psppire-dict.h" -#include #include #include #include +#include +#include - +#include "helper.h" #include "message-dialog.h" -#include "psppire-variable.h" + + +enum { + BACKEND_CHANGED, + + VARIABLE_CHANGED, + VARIABLE_RESIZED, + VARIABLE_INSERTED, + VARIABLE_DELETED, + VARIABLE_DISPLAY_WIDTH_CHANGED, + + WEIGHT_CHANGED, + FILTER_CHANGED, + SPLIT_CHANGED, + n_SIGNALS +}; + /* --- prototypes --- */ static void psppire_dict_class_init (PsppireDictClass *class); static void psppire_dict_init (PsppireDict *dict); static void psppire_dict_finalize (GObject *object); -static void dictionary_tree_model_init(GtkTreeModelIface *iface); +static void dictionary_tree_model_init (GtkTreeModelIface *iface); /* --- variables --- */ static GObjectClass *parent_class = NULL; -enum {VARIABLE_CHANGED, - VARIABLE_RESIZED, - VARIABLE_INSERTED, - VARIABLES_DELETED, - n_SIGNALS}; - -static guint signal[n_SIGNALS]; - -#define CACHE_CHUNK 5 +static guint signals [n_SIGNALS]; /* --- functions --- */ /** @@ -82,19 +86,17 @@ psppire_dict_get_type (void) }; static const GInterfaceInfo tree_model_info = { - (GInterfaceInitFunc) dictionary_tree_model_init, - NULL, + (GInterfaceInitFunc) dictionary_tree_model_init, + NULL, NULL }; - object_type = g_type_register_static (G_TYPE_PSPPIRE_OBJECT, + object_type = g_type_register_static (G_TYPE_OBJECT, "PsppireDict", &object_info, 0); - g_type_add_interface_static(object_type, GTK_TYPE_TREE_MODEL, - &tree_model_info); - - + g_type_add_interface_static (object_type, GTK_TYPE_TREE_MODEL, + &tree_model_info); } return object_type; @@ -110,130 +112,248 @@ psppire_dict_class_init (PsppireDictClass *class) object_class->finalize = psppire_dict_finalize; - signal[VARIABLE_CHANGED] = + signals [BACKEND_CHANGED] = + g_signal_new ("backend-changed", + G_TYPE_FROM_CLASS (class), + G_SIGNAL_RUN_FIRST, + 0, + NULL, NULL, + g_cclosure_marshal_VOID__VOID, + G_TYPE_NONE, + 0); + + + signals [VARIABLE_CHANGED] = g_signal_new ("variable_changed", - G_TYPE_FROM_CLASS(class), + G_TYPE_FROM_CLASS (class), G_SIGNAL_RUN_FIRST, 0, NULL, NULL, g_cclosure_marshal_VOID__INT, - G_TYPE_NONE, + G_TYPE_NONE, 1, G_TYPE_INT); - signal[VARIABLE_INSERTED] = + signals [VARIABLE_INSERTED] = g_signal_new ("variable_inserted", - G_TYPE_FROM_CLASS(class), + G_TYPE_FROM_CLASS (class), G_SIGNAL_RUN_FIRST, 0, NULL, NULL, g_cclosure_marshal_VOID__INT, - G_TYPE_NONE, + G_TYPE_NONE, 1, G_TYPE_INT); - signal[VARIABLES_DELETED] = - g_signal_new ("variables_deleted", - G_TYPE_FROM_CLASS(class), + signals [VARIABLE_DELETED] = + g_signal_new ("variable-deleted", + G_TYPE_FROM_CLASS (class), G_SIGNAL_RUN_FIRST, 0, NULL, NULL, - gtkextra_VOID__INT_INT, - G_TYPE_NONE, - 2, + psppire_marshal_VOID__INT_INT_INT, + G_TYPE_NONE, + 3, + G_TYPE_INT, G_TYPE_INT, G_TYPE_INT); - signal[VARIABLE_RESIZED] = + signals [VARIABLE_RESIZED] = g_signal_new ("dict-size-changed", - G_TYPE_FROM_CLASS(class), + G_TYPE_FROM_CLASS (class), G_SIGNAL_RUN_FIRST, 0, NULL, NULL, - gtkextra_VOID__INT_INT, - G_TYPE_NONE, + psppire_marshal_VOID__INT_INT, + G_TYPE_NONE, 2, G_TYPE_INT, G_TYPE_INT); + signals [VARIABLE_DISPLAY_WIDTH_CHANGED] = + g_signal_new ("variable-display-width-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); + + + signals [WEIGHT_CHANGED] = + g_signal_new ("weight-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); + + + signals [FILTER_CHANGED] = + g_signal_new ("filter-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); + + + signals [SPLIT_CHANGED] = + g_signal_new ("split-changed", + G_TYPE_FROM_CLASS (class), + G_SIGNAL_RUN_FIRST, + 0, + NULL, NULL, + g_cclosure_marshal_VOID__VOID, + G_TYPE_NONE, + 0); } static void psppire_dict_finalize (GObject *object) { - gint v; PsppireDict *d = PSPPIRE_DICT (object); - - for (v = 0 ; v < psppire_dict_get_var_cnt(d) ; ++v ) - g_free(d->variables[v]); - g_free(d->variables); - d->cache_size = 0; - - dict_destroy(d->dict); + dict_destroy (d->dict); G_OBJECT_CLASS (parent_class)->finalize (object); } +/* Pass on callbacks from src/data/dictionary, as + signals in the Gtk library */ static void -psppire_dict_init (PsppireDict *psppire_dict) +addcb (struct dictionary *d, int idx, void *pd) { - psppire_dict->dict = dict_create(); + PsppireDict *dict = PSPPIRE_DICT (pd); - psppire_dict->variables = 0; - psppire_dict->cache_size = 0; + if ( ! dict->disable_insert_signal) + g_signal_emit (dict, signals [VARIABLE_INSERTED], 0, idx); +} - psppire_dict->stamp = g_random_int(); +static void +delcb (struct dictionary *d, int dict_idx, int case_idx, int width, void *pd) +{ + g_signal_emit (pd, signals [VARIABLE_DELETED], 0, + dict_idx, case_idx, width ); } -/** - * psppire_dict_new: - * @returns: a new #PsppireDict object - * - * Creates a new #PsppireDict. - */ -PsppireDict* -psppire_dict_new (void) +static void +mutcb (struct dictionary *d, int idx, void *pd) { - return g_object_new (G_TYPE_PSPPIRE_DICT, NULL); + g_signal_emit (pd, signals [VARIABLE_CHANGED], 0, idx); } +static void +resize_cb (struct dictionary *d, int idx, int old_width, void *pd) +{ + g_signal_emit (pd, signals [VARIABLE_RESIZED], 0, idx, old_width); +} + +static void +weight_changed_callback (struct dictionary *d, int idx, void *pd) +{ + g_signal_emit (pd, signals [WEIGHT_CHANGED], 0, idx); +} + +static void +filter_changed_callback (struct dictionary *d, int idx, void *pd) +{ + g_signal_emit (pd, signals [FILTER_CHANGED], 0, idx); +} + +static void +split_changed_callback (struct dictionary *d, void *pd) +{ + g_signal_emit (pd, signals [SPLIT_CHANGED], 0); +} + +static void +variable_display_width_callback (struct dictionary *d, int idx, void *pd) +{ + g_signal_emit (pd, signals [VARIABLE_DISPLAY_WIDTH_CHANGED], 0, idx); +} + + + +static const struct dict_callbacks gui_callbacks = + { + addcb, + delcb, + mutcb, + resize_cb, + weight_changed_callback, + filter_changed_callback, + split_changed_callback, + variable_display_width_callback + }; + +static void +psppire_dict_init (PsppireDict *psppire_dict) +{ + psppire_dict->stamp = g_random_int (); + psppire_dict->disable_insert_signal = FALSE; +} /** * psppire_dict_new_from_dict: * @returns: a new #PsppireDict object - * - * Creates a new #PsppireDict. + * + * Creates a new #PsppireDict. */ PsppireDict* psppire_dict_new_from_dict (struct dictionary *d) { - PsppireDict *new_dict = g_object_new (G_TYPE_PSPPIRE_DICT, NULL); + PsppireDict *new_dict = g_object_new (PSPPIRE_TYPE_DICT, NULL); new_dict->dict = d; - new_dict->cache_size = dict_get_var_cnt(d); - new_dict->variables = g_malloc0(sizeof(struct PsppireVariable *) * - new_dict->cache_size); + dict_set_callbacks (new_dict->dict, &gui_callbacks, new_dict); return new_dict; } +void +psppire_dict_replace_dictionary (PsppireDict *dict, struct dictionary *d) +{ + struct variable *var = dict_get_weight (d); + + dict->dict = d; + + weight_changed_callback (d, var ? var_get_dict_index (var) : -1, dict); + + var = dict_get_filter (d); + filter_changed_callback (d, var ? var_get_dict_index (var) : -1, dict); + + split_changed_callback (d, dict); + + dict_set_callbacks (dict->dict, &gui_callbacks, dict); + + g_signal_emit (dict, signals [BACKEND_CHANGED], 0); +} + + /* Returns a valid name for a new variable in DICT. The return value is statically allocated */ -static gchar * -auto_generate_var_name(PsppireDict *dict) +static gchar * +auto_generate_var_name (PsppireDict *dict) { gint d = 0; static gchar name[10]; - - while (g_snprintf(name, 10, "VAR%05d",d++), - psppire_dict_lookup_var(dict, name)) + while (g_snprintf (name, 10, "VAR%05d",d++), + psppire_dict_lookup_var (dict, name)) ; return name; @@ -241,212 +361,168 @@ auto_generate_var_name(PsppireDict *dict) /* Insert a new variable at posn IDX, with the name NAME. If NAME is null, then a name will be automatically assigned. - */ +*/ void -psppire_dict_insert_variable(PsppireDict *d, gint idx, const gchar *name) +psppire_dict_insert_variable (PsppireDict *d, gint idx, const gchar *name) { struct variable *var ; - gint i; - g_return_if_fail(d); - g_return_if_fail(G_IS_PSPPIRE_DICT(d)); + g_return_if_fail (idx >= 0); + g_return_if_fail (d); + g_return_if_fail (PSPPIRE_IS_DICT (d)); + if ( ! name ) + name = auto_generate_var_name (d); - /* Invalidate the cache from IDX onwards */ - for ( i = idx ; i < d->cache_size ; ++i ) - { - g_free(d->variables[i]); - d->variables[i] = 0; - } + d->disable_insert_signal = TRUE; - /* Ensure that the cache is large enough */ - if ( dict_get_var_cnt(d->dict) >= d->cache_size ) - { - d->variables = g_realloc(d->variables, sizeof(struct PsppireVariable*) * - (d->cache_size + CACHE_CHUNK)); - d->cache_size += CACHE_CHUNK; - } + var = dict_create_var (d->dict, name, 0); - /* Zero the new pointers */ - for ( ; i < d->cache_size ; ++i ) - { - d->variables[i] = 0; - } - - if ( ! name ) - name = auto_generate_var_name(d); - - var = dict_create_var(d->dict, name, 0); - - dict_reorder_var(d->dict, var, idx); + dict_reorder_var (d->dict, var, idx); - d->variables[idx] = g_malloc(sizeof (struct PsppireVariable)); - d->variables[idx]->v = var; - d->variables[idx]->dict = d; + d->disable_insert_signal = FALSE; - g_signal_emit(d, signal[VARIABLE_INSERTED], 0, idx ); + g_signal_emit (d, signals[VARIABLE_INSERTED], 0, idx); } /* Delete N variables beginning at FIRST */ void -psppire_dict_delete_variables(PsppireDict *d, gint first, gint n) +psppire_dict_delete_variables (PsppireDict *d, gint first, gint n) { gint idx; - g_return_if_fail(d); - g_return_if_fail(d->dict); - g_return_if_fail(G_IS_PSPPIRE_DICT(d)); - - /* Invalidate all pvs from FIRST onwards */ - for ( idx = first ; idx < d->cache_size ; ++idx ) - { - g_free(d->variables[idx]); - d->variables[idx] = 0; - } + g_return_if_fail (d); + g_return_if_fail (d->dict); + g_return_if_fail (PSPPIRE_IS_DICT (d)); - for (idx = 0 ; idx < n ; ++idx ) + for (idx = 0 ; idx < n ; ++idx ) { struct variable *var; /* Do nothing if it's out of bounds */ if ( first >= dict_get_var_cnt (d->dict)) - break; + break; - var = dict_get_var(d->dict, first); + var = dict_get_var (d->dict, first); dict_delete_var (d->dict, var); } - dict_compact_values(d->dict); - - g_signal_emit(d, signal[VARIABLES_DELETED], 0, first, idx ); } -void -psppire_dict_set_name(PsppireDict* d, gint idx, const gchar *name) +gboolean +psppire_dict_set_name (PsppireDict* d, gint idx, const gchar *name) { struct variable *var; - g_assert(d); - g_assert(G_IS_PSPPIRE_DICT(d)); + g_assert (d); + g_assert (PSPPIRE_IS_DICT (d)); + if ( ! var_is_valid_name (name, false)) + return FALSE; - if ( idx < dict_get_var_cnt(d->dict)) + if ( idx < dict_get_var_cnt (d->dict)) { /* This is an existing variable? */ - var = dict_get_var(d->dict, idx); - dict_rename_var(d->dict, var, name); - g_signal_emit(d, signal[VARIABLE_CHANGED], 0, idx); + var = dict_get_var (d->dict, idx); + dict_rename_var (d->dict, var, name); } else { /* new variable */ - dict_create_var(d->dict, name, 0); - g_signal_emit(d, signal[VARIABLE_INSERTED], 0, idx); + dict_create_var (d->dict, name, 0); } + + return TRUE; } -/* Return the IDXth variable */ -struct PsppireVariable * -psppire_dict_get_variable(PsppireDict *d, gint idx) +/* Return the IDXth variable. + Will return NULL if IDX exceeds the number of variables in the dictionary. + */ +struct variable * +psppire_dict_get_variable (const PsppireDict *d, gint idx) { - struct PsppireVariable *var ; - g_return_val_if_fail(d, NULL); - g_return_val_if_fail(d->dict, NULL); + g_return_val_if_fail (d, NULL); + g_return_val_if_fail (d->dict, NULL); - if ( ! d->variables) - return NULL; - - if (idx < 0 || idx >= psppire_dict_get_var_cnt(d)) + if ( dict_get_var_cnt (d->dict) <= idx ) return NULL; - var = d->variables[idx] ; - - if (! var ) - { - var = g_malloc(sizeof (*var)); - var->dict = d; - var->v = dict_get_var(d->dict, idx); - d->variables[idx] = var; - } - - return var; + return dict_get_var (d->dict, idx); } /* Return the number of variables in the dictionary */ -gint -psppire_dict_get_var_cnt(const PsppireDict *d) +gint +psppire_dict_get_var_cnt (const PsppireDict *d) { - g_return_val_if_fail(d, -1); - g_return_val_if_fail(d->dict, -1); - + g_return_val_if_fail (d, -1); + g_return_val_if_fail (d->dict, -1); - return dict_get_var_cnt(d->dict); + return dict_get_var_cnt (d->dict); } -/* Return a variable by name. - Return NULL if it doesn't exist -*/ -struct variable * -psppire_dict_lookup_var (const PsppireDict *d, const gchar *name) +/* Return the number of `union value's in the dictionary */ +size_t +psppire_dict_get_value_cnt (const PsppireDict *d) { - g_return_val_if_fail(d, NULL); - g_return_val_if_fail(d->dict, NULL); + g_return_val_if_fail (d, -1); + g_return_val_if_fail (d->dict, -1); - return dict_lookup_var(d->dict, name); + return dict_get_next_value_idx (d->dict); } -void -psppire_dict_var_changed(PsppireDict *d, gint idx) +/* Returns the prototype for the cases that match the dictionary */ +const struct caseproto * +psppire_dict_get_proto (const PsppireDict *d) { - g_return_if_fail(d); + g_return_val_if_fail (d, NULL); + g_return_val_if_fail (d->dict, NULL); - g_signal_emit(d, signal[VARIABLE_CHANGED], 0, idx); + return dict_get_proto (d->dict); } -/* Clears the contents of D */ -void -psppire_dict_clear(PsppireDict *d) +/* Return a variable by name. + Return NULL if it doesn't exist +*/ +struct variable * +psppire_dict_lookup_var (const PsppireDict *d, const gchar *name) { - g_return_if_fail(d); - g_return_if_fail(d->dict); + g_return_val_if_fail (d, NULL); + g_return_val_if_fail (d->dict, NULL); - { - const gint n_vars = dict_get_var_cnt(d->dict); - gint i; - - dict_clear(d->dict); + return dict_lookup_var (d->dict, name); +} - /* Invalidate the entire cache */ - for ( i = 0 ; i < d->cache_size ; ++i ) - { - g_free(d->variables[i]); - d->variables[i] = 0; - } +/* Clears the contents of D */ +void +psppire_dict_clear (PsppireDict *d) +{ + g_return_if_fail (d); + g_return_if_fail (d->dict); - g_signal_emit(d, signal[VARIABLES_DELETED], 0, 0, n_vars ); + { + dict_clear (d->dict); } } - -/* Return true is NAME would be a valid name of a variable to add to the - dictionary. False otherwise. +/* Return true is NAME would be a valid name of a variable to add to the + dictionary. False otherwise. If REPORT is true, then invalid names will be reported as such as errors */ gboolean -psppire_dict_check_name(const PsppireDict *dict, - const gchar *name, gboolean report) +psppire_dict_check_name (const PsppireDict *dict, + const gchar *name, gboolean report) { - if ( ! var_is_valid_name(name, report ) ) - return FALSE; + if ( ! var_is_valid_name (name, report ) ) + return FALSE; - if (psppire_dict_lookup_var(dict, name)) + if (psppire_dict_lookup_var (dict, name)) { - if ( report ) - msg(ME,"Duplicate variable name."); + if ( report ) + msg (ME,"Duplicate variable name."); return FALSE; } @@ -454,62 +530,67 @@ psppire_dict_check_name(const PsppireDict *dict, } -inline gint +gint psppire_dict_get_next_value_idx (const PsppireDict *dict) { - return dict_get_next_value_idx(dict->dict); + return dict_get_next_value_idx (dict->dict); } -void -psppire_dict_resize_variable(PsppireDict *d, const struct PsppireVariable *pv, - gint old_size, gint new_size) +void +psppire_dict_resize_variable (PsppireDict *d, const struct variable *pv, + gint old_size, gint new_size) { - gint fv; g_return_if_fail (d); g_return_if_fail (d->dict); - - if ( old_size == new_size ) - return ; - - dict_compact_values(d->dict); - fv = psppire_variable_get_fv(pv); + if ( old_size == new_size ) + return ; - g_signal_emit(d, signal[VARIABLE_RESIZED], 0, - fv + old_size, - new_size - old_size ); + g_signal_emit (d, signals [VARIABLE_RESIZED], 0, + var_get_dict_index (pv), + new_size - old_size ); } +/* Tree Model Stuff */ +static GtkTreeModelFlags tree_model_get_flags (GtkTreeModel *model); +static gint tree_model_n_columns (GtkTreeModel *model); -/* Tree Model Stuff */ +static GType tree_model_column_type (GtkTreeModel *model, gint index); -static GtkTreeModelFlags tree_model_get_flags(GtkTreeModel *model); +static gboolean tree_model_get_iter (GtkTreeModel *model, GtkTreeIter *iter, + GtkTreePath *path); -static gint tree_model_n_columns(GtkTreeModel *model); +static gboolean tree_model_iter_next (GtkTreeModel *model, GtkTreeIter *iter); -static GType tree_model_column_type(GtkTreeModel *model, gint index); +static GtkTreePath * tree_model_get_path (GtkTreeModel *model, + GtkTreeIter *iter); -static gboolean tree_model_get_iter(GtkTreeModel *model, GtkTreeIter *iter, - GtkTreePath *path); +static void tree_model_get_value (GtkTreeModel *model, GtkTreeIter *iter, + gint column, GValue *value); -static gboolean tree_model_iter_next(GtkTreeModel *model, GtkTreeIter *iter); +static gboolean tree_model_nth_child (GtkTreeModel *model, GtkTreeIter *iter, + GtkTreeIter *parent, gint n); -static GtkTreePath * tree_model_get_path(GtkTreeModel *model, - GtkTreeIter *iter); +static gint tree_model_n_children (GtkTreeModel *tree_model, + GtkTreeIter *iter); -static void tree_model_get_value(GtkTreeModel *model, GtkTreeIter *iter, - gint column, GValue *value); +static gboolean tree_model_iter_children (GtkTreeModel *, + GtkTreeIter *, + GtkTreeIter *); -static gboolean tree_model_nth_child(GtkTreeModel *model, GtkTreeIter *iter, - GtkTreeIter *parent, gint n); +static gboolean tree_model_iter_parent (GtkTreeModel *tree_model, + GtkTreeIter *iter, + GtkTreeIter *child); +static gboolean tree_model_iter_has_child (GtkTreeModel *tree_model, + GtkTreeIter *iter); static void -dictionary_tree_model_init(GtkTreeModelIface *iface) +dictionary_tree_model_init (GtkTreeModelIface *iface) { iface->get_flags = tree_model_get_flags; iface->get_n_columns = tree_model_n_columns; @@ -519,177 +600,276 @@ dictionary_tree_model_init(GtkTreeModelIface *iface) iface->get_path = tree_model_get_path; iface->get_value = tree_model_get_value; - iface->iter_children = 0; - iface->iter_has_child =0; - iface->iter_n_children =0; + iface->iter_children = tree_model_iter_children ; + iface->iter_has_child = tree_model_iter_has_child ; + iface->iter_n_children = tree_model_n_children ; iface->iter_nth_child = tree_model_nth_child ; - iface->iter_parent =0; + iface->iter_parent = tree_model_iter_parent ; +} + +static gboolean +tree_model_iter_has_child (GtkTreeModel *tree_model, + GtkTreeIter *iter) +{ + return FALSE; +} + +static gboolean +tree_model_iter_parent (GtkTreeModel *tree_model, + GtkTreeIter *iter, + GtkTreeIter *child) +{ + return TRUE; } static GtkTreeModelFlags -tree_model_get_flags(GtkTreeModel *model) +tree_model_get_flags (GtkTreeModel *model) { - g_return_val_if_fail(G_IS_PSPPIRE_DICT(model), (GtkTreeModelFlags) 0); + g_return_val_if_fail (PSPPIRE_IS_DICT (model), (GtkTreeModelFlags) 0); return GTK_TREE_MODEL_LIST_ONLY; } static gint -tree_model_n_columns(GtkTreeModel *model) +tree_model_n_columns (GtkTreeModel *model) { return n_DICT_COLS; } static GType -tree_model_column_type(GtkTreeModel *model, gint index) +tree_model_column_type (GtkTreeModel *model, gint index) { - g_return_val_if_fail(G_IS_PSPPIRE_DICT(model), (GType) 0); + g_return_val_if_fail (PSPPIRE_IS_DICT (model), (GType) 0); - switch(index) - { - case DICT_TVM_COL_NAME: - return G_TYPE_STRING; - break; - case DICT_TVM_COL_VAR: - return G_TYPE_POINTER; - break; - default: - g_return_val_if_reached((GType)0); - break; - } + switch (index) + { + case DICT_TVM_COL_NAME: + return G_TYPE_STRING; + break; + case DICT_TVM_COL_VAR: + return G_TYPE_POINTER; + break; + default: + g_return_val_if_reached ((GType)0); + break; + } - g_assert_not_reached(); - return ((GType)0); + g_assert_not_reached (); + return ((GType)0); } static gboolean -tree_model_get_iter(GtkTreeModel *model, GtkTreeIter *iter, GtkTreePath *path) +tree_model_get_iter (GtkTreeModel *model, GtkTreeIter *iter, GtkTreePath *path) { gint *indices, depth; gint n; - struct PsppireVariable *variable; + struct variable *var; PsppireDict *dict = PSPPIRE_DICT (model); - g_return_val_if_fail(path, FALSE); + g_return_val_if_fail (path, FALSE); - indices = gtk_tree_path_get_indices(path); - depth = gtk_tree_path_get_depth(path); + indices = gtk_tree_path_get_indices (path); + depth = gtk_tree_path_get_depth (path); - g_return_val_if_fail(depth == 1, FALSE); + g_return_val_if_fail (depth == 1, FALSE); - n = indices[0]; + n = indices [0]; - if ( n < 0 || n >= psppire_dict_get_var_cnt(dict)) - return FALSE; + if ( n < 0 || n >= psppire_dict_get_var_cnt (dict)) + { + iter->stamp = 0; + iter->user_data = NULL; + return FALSE; + } - variable = psppire_dict_get_variable(dict, n); + var = psppire_dict_get_variable (dict, n); - g_assert(psppire_variable_get_index(variable) == n); + g_assert (var_get_dict_index (var) == n); iter->stamp = dict->stamp; - iter->user_data = variable; + iter->user_data = var; return TRUE; } static gboolean -tree_model_iter_next(GtkTreeModel *model, GtkTreeIter *iter) +tree_model_iter_next (GtkTreeModel *model, GtkTreeIter *iter) { PsppireDict *dict = PSPPIRE_DICT (model); - struct PsppireVariable *variable; + struct variable *var; gint idx; - g_return_val_if_fail(iter->stamp == dict->stamp, FALSE); + g_return_val_if_fail (iter->stamp == dict->stamp, FALSE); if ( iter == NULL || iter->user_data == NULL) return FALSE; - variable = (struct PsppireVariable *) iter->user_data; + var = iter->user_data; - idx = psppire_variable_get_index(variable); - - if ( idx + 1 >= psppire_dict_get_var_cnt(dict)) - return FALSE; + idx = var_get_dict_index (var); + + if ( idx + 1 >= psppire_dict_get_var_cnt (dict)) + { + iter->user_data = NULL; + iter->stamp = 0; + return FALSE; + } - variable = psppire_dict_get_variable(dict, idx + 1); + var = psppire_dict_get_variable (dict, idx + 1); - g_assert(psppire_variable_get_index(variable) == idx + 1); - - iter->user_data = variable; + g_assert (var_get_dict_index (var) == idx + 1); + + iter->user_data = var; return TRUE; } static GtkTreePath * -tree_model_get_path(GtkTreeModel *model, GtkTreeIter *iter) +tree_model_get_path (GtkTreeModel *model, GtkTreeIter *iter) { GtkTreePath *path; - struct PsppireVariable *variable; + struct variable *var; PsppireDict *dict = PSPPIRE_DICT (model); - g_return_val_if_fail(iter->stamp == dict->stamp, FALSE); + g_return_val_if_fail (iter->stamp == dict->stamp, FALSE); - variable = (struct PsppireVariable *) iter->user_data; + var = iter->user_data; - path = gtk_tree_path_new(); - gtk_tree_path_append_index(path, psppire_variable_get_index(variable)); + path = gtk_tree_path_new (); + gtk_tree_path_append_index (path, var_get_dict_index (var)); return path; } static void -tree_model_get_value(GtkTreeModel *model, GtkTreeIter *iter, - gint column, GValue *value) +tree_model_get_value (GtkTreeModel *model, GtkTreeIter *iter, + gint column, GValue *value) { - struct PsppireVariable *variable; + struct variable *var; PsppireDict *dict = PSPPIRE_DICT (model); - g_return_if_fail(iter->stamp == dict->stamp); + g_return_if_fail (iter->stamp == dict->stamp); - variable = (struct PsppireVariable *) iter->user_data; + var = iter->user_data; - switch(column) + switch (column) { case DICT_TVM_COL_NAME: - g_value_init(value, G_TYPE_STRING); - g_value_set_string(value, psppire_variable_get_name(variable)); + { + g_value_init (value, G_TYPE_STRING); + g_value_set_string (value, var_get_name (var)); + } break; case DICT_TVM_COL_VAR: - g_value_init(value, G_TYPE_POINTER); - g_value_set_pointer(value, variable); + g_value_init (value, G_TYPE_POINTER); + g_value_set_pointer (value, var); break; default: - g_return_if_reached(); + g_return_if_reached (); break; } } +static gboolean +tree_model_iter_children (GtkTreeModel *tree_model, + GtkTreeIter *iter, + GtkTreeIter *parent) +{ + return FALSE; +} + +static gint +tree_model_n_children (GtkTreeModel *model, + GtkTreeIter *iter) +{ + PsppireDict *dict = PSPPIRE_DICT (model); + + if ( iter == NULL ) + return psppire_dict_get_var_cnt (dict); + + return 0; +} static gboolean -tree_model_nth_child(GtkTreeModel *model, GtkTreeIter *iter, - GtkTreeIter *parent, gint n) +tree_model_nth_child (GtkTreeModel *model, GtkTreeIter *iter, + GtkTreeIter *parent, gint n) { PsppireDict *dict; - g_return_val_if_fail(G_IS_PSPPIRE_DICT(model), FALSE); - dict = PSPPIRE_DICT(model); + g_return_val_if_fail (PSPPIRE_IS_DICT (model), FALSE); + + dict = PSPPIRE_DICT (model); - if ( parent ) + if ( parent ) return FALSE; - if ( n >= psppire_dict_get_var_cnt(dict) ) + if ( n >= psppire_dict_get_var_cnt (dict) ) return FALSE; iter->stamp = dict->stamp; - iter->user_data = psppire_dict_get_variable(dict, n); + iter->user_data = psppire_dict_get_variable (dict, n); + + if ( !iter->user_data) + return FALSE; + + return TRUE; +} - if ( !iter->user_data) + +gboolean +psppire_dict_rename_var (PsppireDict *dict, struct variable *v, + const gchar *name) +{ + if ( ! var_is_valid_name (name, false)) + return FALSE; + + /* Make sure no other variable has this name */ + if ( NULL != psppire_dict_lookup_var (dict, name)) return FALSE; - - + + dict_rename_var (dict->dict, v, name); + return TRUE; } + + +struct variable * +psppire_dict_get_weight_variable (const PsppireDict *dict) +{ + return dict_get_weight (dict->dict); +} + + + +#if DEBUGGING +void +psppire_dict_dump (const PsppireDict *dict) +{ + gint i; + const struct dictionary *d = dict->dict; + + for (i = 0; i < dict_get_var_cnt (d); ++i) + { + const struct variable *v = psppire_dict_get_variable (dict, i); + int di = var_get_dict_index (v); + g_print ("\"%s\" idx=%d, fv=%d\n", + var_get_name(v), + di, + var_get_case_index(v)); + + } +} +#endif + + + + +const gchar * +psppire_dict_encoding (const PsppireDict *dict) +{ + return dict_get_encoding (dict->dict); +}