X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Fui%2Fgui%2Fpsppire-dict.c;h=924ff7c5564e70530ae0323bd679cc69c760700d;hb=8180c5dd1591446174c0753ee960921786113403;hp=91bfed2597be89d297be3c00c7c4d36a021945d6;hpb=fe8dc2171009e90d2335f159d05f7e6660e24780;p=pspp diff --git a/src/ui/gui/psppire-dict.c b/src/ui/gui/psppire-dict.c index 91bfed2597..924ff7c556 100644 --- a/src/ui/gui/psppire-dict.c +++ b/src/ui/gui/psppire-dict.c @@ -1,5 +1,6 @@ /* PSPPIRE - a graphical user interface for PSPP. - Copyright (C) 2004, 2006, 2007, 2009, 2010, 2011 Free Software Foundation + Copyright (C) 2004, 2006, 2007, 2009, 2010, 2011, 2012, + 2016, 2017 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 @@ -33,18 +34,25 @@ #include "ui/gui/psppire-marshal.h" #include "ui/gui/psppire-var-ptr.h" +#include + +#include + #include #define _(msgid) gettext (msgid) #define N_(msgid) msgid -enum { - BACKEND_CHANGED, + +GType align_enum_type; +GType measure_enum_type; +GType role_enum_type; + + +enum { VARIABLE_CHANGED, - VARIABLE_RESIZED, VARIABLE_INSERTED, VARIABLE_DELETED, - VARIABLE_DISPLAY_WIDTH_CHANGED, WEIGHT_CHANGED, FILTER_CHANGED, @@ -56,11 +64,58 @@ enum { /* --- 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 psppire_dict_dispose (GObject *object); static void dictionary_tree_model_init (GtkTreeModelIface *iface); + +static guint +gni (GListModel *list) +{ + PsppireDict *dict = PSPPIRE_DICT (list); + + return psppire_dict_get_var_cnt (dict); +} + +static GType +git (GListModel *list) +{ + return SSW_TYPE_DATUM; +} + +static gpointer +gi (GListModel *list, guint id) +{ + SswDatum *gd = SSW_DATUM (g_object_new (SSW_TYPE_DATUM, NULL)); + + PsppireDict *dict = PSPPIRE_DICT (list); + + if (id >= psppire_dict_get_var_cnt (dict)) + { + gd->text = g_strdup (_("Var")); + } + else + { + const struct variable *v = psppire_dict_get_variable (dict, id); + + gd->text = g_strdup (var_get_name (v)); + gd->label = g_strdup (var_get_label (v)); + } + + return gd; +} + + +static void +ssw_init_iface (GListModelInterface *iface) +{ + iface->get_n_items = gni; + iface->get_item = gi; + iface->get_item_type = git; +} + + /* --- variables --- */ static GObjectClass *parent_class = NULL; @@ -96,12 +151,21 @@ psppire_dict_get_type (void) NULL }; + static const GInterfaceInfo list_model_info = { + (GInterfaceInitFunc) ssw_init_iface, + NULL, + NULL + }; + 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, G_TYPE_LIST_MODEL, + &list_model_info); } return object_type; @@ -115,34 +179,26 @@ psppire_dict_class_init (PsppireDictClass *class) parent_class = g_type_class_peek_parent (class); - object_class->finalize = psppire_dict_finalize; - - 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); - + object_class->dispose = psppire_dict_dispose; signals [VARIABLE_CHANGED] = - g_signal_new ("variable_changed", + g_signal_new ("variable-changed", G_TYPE_FROM_CLASS (class), G_SIGNAL_RUN_FIRST, 0, NULL, NULL, - g_cclosure_marshal_VOID__INT, + psppire_marshal_VOID__INT_UINT_POINTER, G_TYPE_NONE, - 1, - G_TYPE_INT); + 3, + G_TYPE_INT, + G_TYPE_UINT, + G_TYPE_POINTER + ); signals [VARIABLE_INSERTED] = - g_signal_new ("variable_inserted", + g_signal_new ("variable-inserted", G_TYPE_FROM_CLASS (class), G_SIGNAL_RUN_FIRST, 0, @@ -159,38 +215,14 @@ psppire_dict_class_init (PsppireDictClass *class) G_SIGNAL_RUN_FIRST, 0, NULL, NULL, - psppire_marshal_VOID__INT_INT_INT, + psppire_marshal_VOID__POINTER_INT_INT, G_TYPE_NONE, 3, - G_TYPE_INT, + G_TYPE_POINTER, G_TYPE_INT, G_TYPE_INT); - signals [VARIABLE_RESIZED] = - g_signal_new ("dict-size-changed", - 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); - - 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), @@ -227,13 +259,13 @@ psppire_dict_class_init (PsppireDictClass *class) } static void -psppire_dict_finalize (GObject *object) +psppire_dict_dispose (GObject *object) { PsppireDict *d = PSPPIRE_DICT (object); - dict_destroy (d->dict); + dict_set_callbacks (d->dict, NULL, NULL); - G_OBJECT_CLASS (parent_class)->finalize (object); + G_OBJECT_CLASS (parent_class)->dispose (object); } /* Pass on callbacks from src/data/dictionary, as @@ -244,26 +276,26 @@ addcb (struct dictionary *d, int idx, void *pd) PsppireDict *dict = PSPPIRE_DICT (pd); if ( ! dict->disable_insert_signal) - g_signal_emit (dict, signals [VARIABLE_INSERTED], 0, idx); + { + g_signal_emit (dict, signals [VARIABLE_INSERTED], 0, idx); + g_signal_emit_by_name (dict, "items-changed", idx, 1, 1); + } } static void -delcb (struct dictionary *d, int dict_idx, int case_idx, int width, void *pd) +delcb (struct dictionary *d, const struct variable *var, + int dict_idx, int case_idx, void *pd) { g_signal_emit (pd, signals [VARIABLE_DELETED], 0, - dict_idx, case_idx, width ); -} - -static void -mutcb (struct dictionary *d, int idx, void *pd) -{ - g_signal_emit (pd, signals [VARIABLE_CHANGED], 0, idx); + var, dict_idx, case_idx); + g_signal_emit_by_name (pd, "items-changed", dict_idx, 1, 0); } static void -resize_cb (struct dictionary *d, int idx, int old_width, void *pd) +mutcb (struct dictionary *d, int idx, unsigned int what, const struct variable *oldvar, void *pd) { - g_signal_emit (pd, signals [VARIABLE_RESIZED], 0, idx, old_width); + g_signal_emit (pd, signals [VARIABLE_CHANGED], 0, idx, what, oldvar); + g_signal_emit_by_name (pd, "items-changed", idx, 1, 1); } static void @@ -284,24 +316,14 @@ 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 + split_changed_callback }; static void @@ -334,6 +356,9 @@ psppire_dict_replace_dictionary (PsppireDict *dict, struct dictionary *d) { struct variable *var = dict_get_weight (d); + guint old_n = dict_get_var_cnt (dict->dict); + guint new_n = dict_get_var_cnt (d); + dict->dict = d; weight_changed_callback (d, var ? var_get_dict_index (var) : -1, dict); @@ -345,45 +370,60 @@ psppire_dict_replace_dictionary (PsppireDict *dict, struct dictionary *d) dict_set_callbacks (dict->dict, &gui_callbacks, dict); - g_signal_emit (dict, signals [BACKEND_CHANGED], 0); + g_signal_emit_by_name (dict, "items-changed", 0, old_n, new_n); } -/* Returns a valid name for a new variable in DICT. - The return value is statically allocated */ -static gchar * -auto_generate_var_name (PsppireDict *dict) +/* Stores a valid name for a new variable in DICT into the SIZE bytes in NAME. + Returns true if successful, false if SIZE is insufficient. */ +bool +psppire_dict_generate_name (const PsppireDict *dict, char *name, size_t size) { - gint d = 0; - static gchar name[10]; + gint d; - /* TRANSLATORS: This string must be a valid variable name. That means: - - The string must be at most 64 bytes (not characters) long. - - The string may not contain whitespace. - - The first character may not be '$' - - The first character may not be a digit - - The final charactor may not be '.' or '_' - */ - while (g_snprintf (name, 10, _("VAR%05d"), d++), - psppire_dict_lookup_var (dict, name)) - ; + for (d = 1; ; d++) + { + int len; + + /* TRANSLATORS: This string must be a valid variable name. That means: + - The string must be at most 64 bytes (not characters) long. + - The string may not contain whitespace. + - The first character may not be '$' + - The first character may not be a digit + - The final character may not be '.' or '_' + */ + len = snprintf (name, size, _("Var%04d"), d); + if (len + 1 >= size) + return false; + + if (psppire_dict_lookup_var (dict, name) == NULL) + return true; + } return name; } -/* Insert a new variable at posn IDX, with the name NAME. +/* Insert a new variable at posn IDX, with the name NAME, and return the + new variable. If NAME is null, then a name will be automatically assigned. */ -void +struct variable * psppire_dict_insert_variable (PsppireDict *d, gint idx, const gchar *name) { - struct variable *var ; - g_return_if_fail (idx >= 0); - g_return_if_fail (d); - g_return_if_fail (PSPPIRE_IS_DICT (d)); + struct variable *var; + char tmpname[64]; + + g_return_val_if_fail (idx >= 0, NULL); + g_return_val_if_fail (d, NULL); + g_return_val_if_fail (PSPPIRE_IS_DICT (d), NULL); - if ( ! name ) - name = auto_generate_var_name (d); + if (name == NULL) + { + if (!psppire_dict_generate_name (d, tmpname, sizeof tmpname)) + g_return_val_if_reached (NULL); + + name = tmpname; + } d->disable_insert_signal = TRUE; @@ -394,6 +434,9 @@ psppire_dict_insert_variable (PsppireDict *d, gint idx, const gchar *name) d->disable_insert_signal = FALSE; g_signal_emit (d, signals[VARIABLE_INSERTED], 0, idx); + g_signal_emit_by_name (d, "items-changed", idx, 0, 1); + + return var; } /* Delete N variables beginning at FIRST */ @@ -520,7 +563,7 @@ psppire_dict_clear (PsppireDict *d) } -/* Return true is NAME would be a valid name of a variable to add to the +/* Return true if 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 */ @@ -534,7 +577,7 @@ psppire_dict_check_name (const PsppireDict *dict, if (psppire_dict_lookup_var (dict, name)) { if ( report ) - msg (ME,"Duplicate variable name."); + msg (ME, _("Duplicate variable name.")); return FALSE; } @@ -549,22 +592,6 @@ psppire_dict_get_next_value_idx (const PsppireDict *dict) } -void -psppire_dict_resize_variable (PsppireDict *d, const struct variable *pv, - gint old_size, gint new_size) -{ - g_return_if_fail (d); - g_return_if_fail (d->dict); - - if ( old_size == new_size ) - return ; - - 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); @@ -654,21 +681,34 @@ tree_model_column_type (GtkTreeModel *model, gint index) { g_return_val_if_fail (PSPPIRE_IS_DICT (model), (GType) 0); + GType t = 0; + switch (index) { case DICT_TVM_COL_NAME: - return G_TYPE_STRING; + case DICT_TVM_COL_LABEL: + t = G_TYPE_STRING; + break; + case DICT_TVM_COL_DECIMAL: + case DICT_TVM_COL_WIDTH: + case DICT_TVM_COL_COLUMNS: + t = G_TYPE_INT; break; case DICT_TVM_COL_VAR: - return PSPPIRE_VAR_PTR_TYPE; + t = PSPPIRE_VAR_PTR_TYPE; break; - default: - g_return_val_if_reached ((GType)0); + case DICT_TVM_COL_ALIGNMENT: + t = align_enum_type; + break; + case DICT_TVM_COL_MEASURE: + t = measure_enum_type; + break; + case DICT_TVM_COL_ROLE: + t = role_enum_type; break; } - g_assert_not_reached (); - return ((GType)0); + return t; } static gboolean @@ -714,11 +754,11 @@ tree_model_iter_next (GtkTreeModel *model, GtkTreeIter *iter) struct variable *var; gint idx; - g_return_val_if_fail (iter->stamp == dict->stamp, FALSE); - if ( iter == NULL || iter->user_data == NULL) return FALSE; + g_return_val_if_fail (iter->stamp == dict->stamp, FALSE); + var = iter->user_data; idx = var_get_dict_index (var); @@ -756,6 +796,7 @@ tree_model_get_path (GtkTreeModel *model, GtkTreeIter *iter) return path; } +const struct fmt_spec *var_get_write_format (const struct variable *); static void tree_model_get_value (GtkTreeModel *model, GtkTreeIter *iter, @@ -766,22 +807,51 @@ tree_model_get_value (GtkTreeModel *model, GtkTreeIter *iter, g_return_if_fail (iter->stamp == dict->stamp); - var = iter->user_data; + var = iter->user_data; + + const struct fmt_spec *fs = var_get_write_format (var); switch (column) { case DICT_TVM_COL_NAME: - { - g_value_init (value, G_TYPE_STRING); - g_value_set_string (value, var_get_name (var)); - } + g_value_init (value, G_TYPE_STRING); + g_value_set_string (value, var_get_name (var)); + break; + case DICT_TVM_COL_WIDTH: + g_value_init (value, G_TYPE_INT); + g_value_set_int (value, fs->w); + break; + case DICT_TVM_COL_DECIMAL: + g_value_init (value, G_TYPE_INT); + g_value_set_int (value, fs->d); + break; + case DICT_TVM_COL_LABEL: + g_value_init (value, G_TYPE_STRING); + g_value_set_string (value, var_get_label (var)); + break; + case DICT_TVM_COL_COLUMNS: + g_value_init (value, G_TYPE_INT); + g_value_set_int (value, var_get_display_width (var)); + break; + case DICT_TVM_COL_ALIGNMENT: + g_value_init (value, align_enum_type); + g_value_set_enum (value, var_get_alignment (var)); + break; + case DICT_TVM_COL_MEASURE: + g_value_init (value, measure_enum_type); + g_value_set_enum (value, var_get_measure (var)); + break; + case DICT_TVM_COL_ROLE: + g_value_init (value, role_enum_type); + g_value_set_enum (value, var_get_role (var)); break; case DICT_TVM_COL_VAR: g_value_init (value, PSPPIRE_VAR_PTR_TYPE); g_value_set_boxed (value, var); break; default: - g_return_if_reached (); + g_value_init (value, G_TYPE_STRING); + g_value_set_string (value, "????"); break; } } @@ -800,7 +870,7 @@ tree_model_n_children (GtkTreeModel *model, { PsppireDict *dict = PSPPIRE_DICT (model); - if ( iter == NULL ) + if (iter == NULL) return psppire_dict_get_var_cnt (dict); return 0;