X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Fui%2Fgui%2Fpsppire-dict.c;h=b4503125609fa8a941741f096c9f6f78b32f457d;hb=8f157150f5fe225224e407161fb7f899d34b8b18;hp=0d700fe5a4a12b9eb595c4bce1efd7b4eb75f0e6;hpb=72147c12357446b304264b6944b8a1d92c45f53c;p=pspp-builds.git diff --git a/src/ui/gui/psppire-dict.c b/src/ui/gui/psppire-dict.c index 0d700fe5..b4503125 100644 --- a/src/ui/gui/psppire-dict.c +++ b/src/ui/gui/psppire-dict.c @@ -1,7 +1,6 @@ -/* +/* PSPPIRE --- A Graphical User Interface for PSPP - Copyright (C) 2004, 2006 Free Software Foundation - Written by John Darrington + Copyright (C) 2004, 2006, 2007 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 @@ -18,7 +17,7 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ - +#include #include #include @@ -40,21 +39,22 @@ 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, +enum {VARIABLE_CHANGED, VARIABLE_RESIZED, VARIABLE_INSERTED, - VARIABLES_DELETED, + VARIABLES_DELETED, + WEIGHT_CHANGED, + FILTER_CHANGED, + SPLIT_CHANGED, n_SIGNALS}; -static guint signal[n_SIGNALS]; - -#define CACHE_CHUNK 5 +static guint signals [n_SIGNALS]; /* --- functions --- */ /** @@ -81,16 +81,16 @@ 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_PSPPIRE_OBJECT, "PsppireDict", &object_info, 0); - g_type_add_interface_static(object_type, GTK_TYPE_TREE_MODEL, + g_type_add_interface_static (object_type, GTK_TYPE_TREE_MODEL, &tree_model_info); @@ -109,56 +109,90 @@ psppire_dict_class_init (PsppireDictClass *class) object_class->finalize = psppire_dict_finalize; - signal[VARIABLE_CHANGED] = + 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] = + signals [VARIABLES_DELETED] = g_signal_new ("variables_deleted", - G_TYPE_FROM_CLASS(class), + G_TYPE_FROM_CLASS (class), G_SIGNAL_RUN_FIRST, 0, NULL, NULL, gtkextra_VOID__INT_INT, - G_TYPE_NONE, + G_TYPE_NONE, 2, 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, + G_TYPE_NONE, 2, G_TYPE_INT, 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 @@ -166,7 +200,7 @@ psppire_dict_finalize (GObject *object) { PsppireDict *d = PSPPIRE_DICT (object); - dict_destroy(d->dict); + dict_destroy (d->dict); G_OBJECT_CLASS (parent_class)->finalize (object); } @@ -176,51 +210,56 @@ psppire_dict_finalize (GObject *object) static void addcb (struct dictionary *d, int idx, void *pd) { - g_signal_emit(pd, signal[VARIABLE_INSERTED], 0, idx); + g_signal_emit (pd, signals [VARIABLE_INSERTED], 0, idx); } static void delcb (struct dictionary *d, int idx, void *pd) { - g_signal_emit(pd, signal[VARIABLES_DELETED], 0, idx, 1); + g_signal_emit (pd, signals [VARIABLES_DELETED], 0, idx, 1); } static void mutcb (struct dictionary *d, int idx, void *pd) { - g_signal_emit(pd, signal[VARIABLE_CHANGED], 0, idx); + g_signal_emit (pd, signals [VARIABLE_CHANGED], 0, idx); +} + +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 const struct dict_callbacks gui_callbacks = { addcb, delcb, - mutcb + mutcb, + weight_changed_callback, + filter_changed_callback, + split_changed_callback }; static void psppire_dict_init (PsppireDict *psppire_dict) { - psppire_dict->dict = dict_create (); - - dict_set_callbacks (psppire_dict->dict, &gui_callbacks, psppire_dict); - - psppire_dict->stamp = g_random_int(); -} - -/** - * psppire_dict_new: - * @returns: a new #PsppireDict object - * - * Creates a new #PsppireDict. - */ -PsppireDict* -psppire_dict_new (void) -{ - return g_object_new (G_TYPE_PSPPIRE_DICT, NULL); + psppire_dict->stamp = g_random_int (); } - /** * psppire_dict_new_from_dict: * @returns: a new #PsppireDict object @@ -233,20 +272,29 @@ psppire_dict_new_from_dict (struct dictionary *d) PsppireDict *new_dict = g_object_new (G_TYPE_PSPPIRE_DICT, NULL); new_dict->dict = d; + dict_set_callbacks (new_dict->dict, &gui_callbacks, new_dict); + return new_dict; } +void +psppire_dict_replace_dictionary (PsppireDict *dict, struct dictionary *d) +{ + dict->dict = d; +} + + /* Returns a valid name for a new variable in DICT. The return value is statically allocated */ -static gchar * +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; @@ -256,69 +304,63 @@ auto_generate_var_name (PsppireDict *dict) 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 ; - 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 (G_IS_PSPPIRE_DICT (d)); - if ( ! name ) - name = auto_generate_var_name(d); - - var = dict_create_var(d->dict, name, 0); + if ( ! name ) + name = auto_generate_var_name (d); - dict_reorder_var(d->dict, var, idx); + var = dict_create_var (d->dict, name, 0); - g_signal_emit(d, signal[VARIABLE_INSERTED], 0, idx ); + dict_reorder_var (d->dict, var, 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)); + g_return_if_fail (d); + g_return_if_fail (d->dict); + g_return_if_fail (G_IS_PSPPIRE_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 ); + dict_compact_values (d->dict); } void -psppire_dict_set_name(PsppireDict* d, gint idx, const gchar *name) +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 (G_IS_PSPPIRE_DICT (d)); - 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); } } @@ -326,10 +368,10 @@ psppire_dict_set_name(PsppireDict* d, gint idx, const gchar *name) /* Return the IDXth variable */ struct variable * -psppire_dict_get_variable(PsppireDict *d, gint idx) +psppire_dict_get_variable (const PsppireDict *d, gint idx) { - 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 ( dict_get_var_cnt (d->dict) <= idx ) return NULL; @@ -361,49 +403,34 @@ psppire_dict_lookup_var (const PsppireDict *d, const gchar *name) return dict_lookup_var (d->dict, name); } - -void -psppire_dict_var_changed (PsppireDict *d, gint idx) -{ - g_return_if_fail(d); - - g_signal_emit(d, signal[VARIABLE_CHANGED], 0, idx); -} - - /* Clears the contents of D */ void -psppire_dict_clear(PsppireDict *d) +psppire_dict_clear (PsppireDict *d) { - g_return_if_fail(d); - g_return_if_fail(d->dict); + g_return_if_fail (d); + g_return_if_fail (d->dict); { - const gint n_vars = dict_get_var_cnt(d->dict); - - dict_clear(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. If REPORT is true, then invalid names will be reported as such as errors */ gboolean -psppire_dict_check_name(const PsppireDict *dict, +psppire_dict_check_name (const PsppireDict *dict, const gchar *name, gboolean report) { - if ( ! var_is_valid_name(name, report ) ) + 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."); + msg (ME,"Duplicate variable name."); return FALSE; } @@ -414,7 +441,7 @@ psppire_dict_check_name(const PsppireDict *dict, inline 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); } @@ -433,7 +460,7 @@ psppire_dict_resize_variable (PsppireDict *d, const struct variable *pv, fv = var_get_case_index (pv); - g_signal_emit(d, signal[VARIABLE_RESIZED], 0, + g_signal_emit (d, signals [VARIABLE_RESIZED], 0, fv + old_size, new_size - old_size ); } @@ -447,18 +474,18 @@ static gint tree_model_n_columns (GtkTreeModel *model); static GType tree_model_column_type (GtkTreeModel *model, gint index); -static gboolean tree_model_get_iter (GtkTreeModel *model, GtkTreeIter *iter, +static gboolean tree_model_get_iter (GtkTreeModel *model, GtkTreeIter *iter, GtkTreePath *path); static gboolean tree_model_iter_next (GtkTreeModel *model, GtkTreeIter *iter); -static GtkTreePath * tree_model_get_path (GtkTreeModel *model, +static GtkTreePath * tree_model_get_path (GtkTreeModel *model, GtkTreeIter *iter); static void tree_model_get_value (GtkTreeModel *model, GtkTreeIter *iter, gint column, GValue *value); -static gboolean tree_model_nth_child (GtkTreeModel *model, GtkTreeIter *iter, +static gboolean tree_model_nth_child (GtkTreeModel *model, GtkTreeIter *iter, GtkTreeIter *parent, gint n); @@ -483,7 +510,7 @@ dictionary_tree_model_init (GtkTreeModelIface *iface) static GtkTreeModelFlags tree_model_get_flags (GtkTreeModel *model) { - g_return_val_if_fail (G_IS_PSPPIRE_DICT(model), (GtkTreeModelFlags) 0); + g_return_val_if_fail (G_IS_PSPPIRE_DICT (model), (GtkTreeModelFlags) 0); return GTK_TREE_MODEL_LIST_ONLY; } @@ -498,9 +525,9 @@ tree_model_n_columns (GtkTreeModel *model) static GType 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 (G_IS_PSPPIRE_DICT (model), (GType) 0); - switch(index) + switch (index) { case DICT_TVM_COL_NAME: return G_TYPE_STRING; @@ -509,16 +536,16 @@ tree_model_column_type (GtkTreeModel *model, gint index) return G_TYPE_POINTER; break; default: - g_return_val_if_reached((GType)0); + g_return_val_if_reached ((GType)0); break; } - g_assert_not_reached(); + 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; @@ -531,11 +558,11 @@ tree_model_get_iter(GtkTreeModel *model, GtkTreeIter *iter, GtkTreePath *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]; - if ( n < 0 || n >= psppire_dict_get_var_cnt (dict)) + if ( n < 0 || n >= psppire_dict_get_var_cnt (dict)) return FALSE; variable = dict_get_var (dict->dict, n); @@ -550,13 +577,13 @@ tree_model_get_iter(GtkTreeModel *model, GtkTreeIter *iter, GtkTreePath *path) static gboolean -tree_model_iter_next(GtkTreeModel *model, GtkTreeIter *iter) +tree_model_iter_next (GtkTreeModel *model, GtkTreeIter *iter) { PsppireDict *dict = PSPPIRE_DICT (model); struct variable *variable; 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; @@ -565,7 +592,7 @@ tree_model_iter_next(GtkTreeModel *model, GtkTreeIter *iter) idx = var_get_dict_index (variable); - if ( idx + 1 >= psppire_dict_get_var_cnt(dict)) + if ( idx + 1 >= psppire_dict_get_var_cnt (dict)) return FALSE; variable = psppire_dict_get_variable (dict, idx + 1); @@ -578,68 +605,68 @@ tree_model_iter_next(GtkTreeModel *model, GtkTreeIter *iter) } static GtkTreePath * -tree_model_get_path(GtkTreeModel *model, GtkTreeIter *iter) +tree_model_get_path (GtkTreeModel *model, GtkTreeIter *iter) { GtkTreePath *path; struct variable *variable; 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 variable *) iter->user_data; - path = gtk_tree_path_new(); - gtk_tree_path_append_index(path, var_get_dict_index (variable)); + path = gtk_tree_path_new (); + gtk_tree_path_append_index (path, var_get_dict_index (variable)); return path; } static void -tree_model_get_value(GtkTreeModel *model, GtkTreeIter *iter, +tree_model_get_value (GtkTreeModel *model, GtkTreeIter *iter, gint column, GValue *value) { struct variable *variable; PsppireDict *dict = PSPPIRE_DICT (model); - g_return_if_fail(iter->stamp == dict->stamp); + g_return_if_fail (iter->stamp == dict->stamp); variable = (struct variable *) iter->user_data; - switch(column) + switch (column) { case DICT_TVM_COL_NAME: - g_value_init(value, G_TYPE_STRING); - g_value_set_string(value, var_get_name(variable)); + g_value_init (value, G_TYPE_STRING); + g_value_set_string (value, var_get_name (variable)); 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, variable); break; default: - g_return_if_reached(); + g_return_if_reached (); break; } } static gboolean -tree_model_nth_child(GtkTreeModel *model, GtkTreeIter *iter, +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); + g_return_val_if_fail (G_IS_PSPPIRE_DICT (model), FALSE); - dict = PSPPIRE_DICT(model); + dict = PSPPIRE_DICT (model); 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; @@ -655,3 +682,10 @@ psppire_dict_rename_var (PsppireDict *dict, struct variable *v, { dict_rename_var (dict->dict, v, text); } + + +struct variable * +psppire_dict_get_weight_variable (const PsppireDict *dict) +{ + return dict_get_weight (dict->dict); +}