From b042af35db4f47a7f3b63bf9ace7df0b101126dc Mon Sep 17 00:00:00 2001 From: Juan Ferrer Toribio Date: Wed, 9 Jul 2014 09:49:56 +0200 Subject: [PATCH] Anjutica --- db/db-calc.c | 311 ++++++++++++++++++++++++------------- db/db-calc.h | 19 +-- db/db-iterator.c | 17 +- db/db-model.c | 16 +- module/data/Makefile.am | 2 +- module/data/customer.glade | 49 +++++- module/data/example.xml | 6 + module/src/Makefile.am | 6 +- sql/sql-batch.c | 139 ++++++++++------- sql/sql-batch.h | 25 +-- sql/sql-value.c | 5 +- vn/column/vn-column-spin.c | 10 +- vn/field/vn-completion.c | 4 +- vn/vn-column.c | 5 +- vn/vn-handler.c | 4 +- 15 files changed, 405 insertions(+), 213 deletions(-) diff --git a/db/db-calc.c b/db/db-calc.c index 23e63f3..d7994d2 100644 --- a/db/db-calc.c +++ b/db/db-calc.c @@ -51,13 +51,16 @@ G_DEFINE_TYPE (DbCalc, db_calc, GVN_TYPE_PARAM); * * Return value: a new #DbCalc **/ -DbCalc * db_calc_new (DbModel * model, DbCalcType type, gint col) +DbCalc * db_calc_new (DbModel * model, DbCalcType type, const gchar * column_name) { g_return_val_if_fail (DB_IS_MODEL (model), NULL); - g_return_val_if_fail (0 <= col || col < db_model_get_ncols (model), NULL); - return g_object_new - (DB_TYPE_CALC, "model", model, "type", type, "col", col, NULL); + return g_object_new (DB_TYPE_CALC + ,"model", model + ,"type", type + ,"column-name", column_name + ,NULL + ); } /** @@ -77,8 +80,13 @@ DbCalc * db_calc_new_with_func (DbModel * model, DbCalcType type, DbCalcFunc fun g_return_val_if_fail (DB_IS_MODEL (model), NULL); g_return_val_if_fail (func, NULL); - return g_object_new - (DB_TYPE_CALC, "model", model, "type", type, "function", func, "data", data, NULL); + return g_object_new (DB_TYPE_CALC + ,"model", model + ,"type", type + ,"function", func + ,"data", data + ,NULL + ); } //+++++++++++++++++++++++++++++++++++++++++++++++++++ Private @@ -111,108 +119,194 @@ static gdouble db_calc_value_to_double (const GValue * v) } static void db_calc_internal_func - (DbCalc * obj, DbIter * iter, GValue * out, gpointer data) + (DbCalc * self, DbIter * iter, GValue * out, gpointer data) { - const GValue * value = db_model_get_value (obj->model, iter, obj->col, NULL); - g_value_copy (value, g_value_init (out, G_VALUE_TYPE (value))); + const GValue * value; + + if (self->column_index != -1) + { + value = db_model_get_value (self->model, iter, self->column_index, NULL); + g_value_copy (value, g_value_init (out, G_VALUE_TYPE (value))); + } + else + g_value_init (out, GVN_TYPE_NULL); } -static void db_calc_before_unset (DbModel * model, DbIter * iter, DbCalc * obj) +static void db_calc_reset (DbCalc * self) +{ + g_free (self->column_name); + self->column_name = NULL; + self->column_index = -1; + self->func = db_calc_internal_func; +} + +static void db_calc_refresh (DbCalc * self) +{ + DbIter iter; + gdouble current = 0; + GValue val = G_VALUE_INIT; + DbModel * model = self->model; + + self->count = 0; + + if (model) + { + DbModelStatus status = db_model_get_status (model); + + if (status == DB_MODEL_STATUS_READY && self->column_name) + self->column_index = db_model_get_column_index (model, self->column_name); + + if (status == DB_MODEL_STATUS_READY + && self->column_index != -1 + && db_model_get_iter_first (model, &iter)) + { + do { + self->func (self, &iter, &val, self->data); + + if (!gvn_value_is_null (&val)) + { + current += db_calc_value_to_double (&val); + self->count++; + } + + g_value_unset (&val); + } + while (db_model_iter_next (model, &iter)); + + if (self->type == DB_CALC_TYPE_AVG) + current = (self->count > 0) ? current / (gdouble) self->count : 0; + } + } + + if (self->count > 0) + g_value_set_double (g_value_init (&val, G_TYPE_DOUBLE), current); + else + g_value_init (&val, GVN_TYPE_NULL); + + GVN_PARAM_GET_CLASS (self)->put_value (GVN_PARAM (self), &val); + g_value_unset (&val); +} + +static void db_calc_on_model_refresh (DbModel * model, DbModelStatus status, DbCalc * self) +{ + db_calc_refresh (self); +} + +static void db_calc_on_update (DbModel * model, DbIter * iter, DbCalc * self) { GValue value = G_VALUE_INIT; - obj->func (obj, iter, &value, obj->data); + self->func (self, iter, &value, self->data); if (!gvn_value_is_null (&value)) { gdouble current, old; - current = db_calc_value_to_double (gvn_param_get_value (GVN_PARAM (obj))); + current = db_calc_value_to_double (gvn_param_get_value (GVN_PARAM (self))); old = db_calc_value_to_double (&value); - if (obj->type == DB_CALC_TYPE_AVG) + if (self->type == DB_CALC_TYPE_AVG) { - if (obj->count != 1) - current = (current * (gdouble) obj->count - old) / (gdouble) (obj->count - 1); + if (self->count != 1) + current = (current * (gdouble) self->count - old) / (gdouble) (self->count - 1); else current = 0; } - else if (obj->type == DB_CALC_TYPE_SUM) + else if (self->type == DB_CALC_TYPE_SUM) current -= old; - obj->count--; + self->count--; g_value_unset (&value); g_value_set_double (g_value_init (&value, G_TYPE_DOUBLE), current); - GVN_PARAM_GET_CLASS (obj)->put_value (GVN_PARAM (obj), &value); + GVN_PARAM_GET_CLASS (self)->put_value (GVN_PARAM (self), &value); } g_value_unset (&value); } -static void db_calc_before_delete (DbModel * model, gint path, DbCalc * obj) -{ - DbIter iter; - db_model_get_iter (model, &iter, path); - db_calc_before_unset (model, &iter, obj); -} - -static void db_calc_after_set (DbModel * model, DbIter * iter, DbCalc * obj) +static void db_calc_on_update_after (DbModel * model, DbIter * iter, DbCalc * self) { GValue value = G_VALUE_INIT; - obj->func (obj, iter, &value, obj->data); + self->func (self, iter, &value, self->data); if (!gvn_value_is_null (&value)) { gdouble current, new; - current = db_calc_value_to_double (gvn_param_get_value (GVN_PARAM (obj))); + current = db_calc_value_to_double (gvn_param_get_value (GVN_PARAM (self))); new = db_calc_value_to_double (&value); - if (obj->type == DB_CALC_TYPE_AVG) - current = (current * (gdouble) obj->count + new) / (gdouble) (obj->count + 1); - else if (obj->type == DB_CALC_TYPE_SUM) + if (self->type == DB_CALC_TYPE_AVG) + current = (current * (gdouble) self->count + new) / (gdouble) (self->count + 1); + else if (self->type == DB_CALC_TYPE_SUM) current += new; - obj->count++; + self->count++; g_value_unset (&value); g_value_set_double (g_value_init (&value, G_TYPE_DOUBLE), current); - GVN_PARAM_GET_CLASS (obj)->put_value (GVN_PARAM (obj), &value); + GVN_PARAM_GET_CLASS (self)->put_value (GVN_PARAM (self), &value); } g_value_unset (&value); } -static void db_calc_refresh (DbModel * model, DbModelStatus status, DbCalc * obj) +static void db_calc_on_delete (DbModel * model, gint path, DbCalc * self) { DbIter iter; - gdouble current = 0; - GValue val = G_VALUE_INIT; + db_model_get_iter (model, &iter, path); + db_calc_on_update (model, &iter, self); +} - if (status != DB_MODEL_STATUS_READY) return; - if (!db_model_get_iter_first (model, &iter)) return; +//+++++++++++++++++++++++++++++++++++++++++++++++++++ Public - obj->count = 0; +void db_calc_set_column_name (DbCalc * self, const gchar * name) +{ + g_return_if_fail (DB_IS_CALC (self)); - do { - obj->func (obj, &iter, &val, obj->data); + db_calc_reset (self); + self->column_name = g_strdup (name); + db_calc_refresh (self); +} - if (!gvn_value_is_null (&val)) - { - current += db_calc_value_to_double (&val); - obj->count++; - } +void db_calc_set_column_index (DbCalc * self, gint index) +{ + g_return_if_fail (DB_IS_CALC (self)); - g_value_unset (&val); + db_calc_reset (self); + self->column_index = index; + db_calc_refresh (self); +} + +void db_calc_set_model (DbCalc * self, DbModel * model) +{ + g_return_if_fail (DB_IS_CALC (self)); + g_return_if_fail (DB_IS_MODEL (model) || !model); + + if (self->model) + { + g_object_disconnect (self->model + ,"any_signal::line-updated", db_calc_on_update, self + ,"any_signal::line-updated", db_calc_on_update_after, self + ,"any_signal::line-deleted", db_calc_on_delete, self + ,"any_signal::status-changed", db_calc_on_model_refresh, self + ,NULL + ); + g_clear_object (&self->model); } - while (db_model_iter_next (model, &iter)); - - if (obj->type == DB_CALC_TYPE_AVG) - current = (obj->count > 0) ? current / (gdouble) obj->count : 0; - - g_value_set_double (g_value_init (&val, G_TYPE_DOUBLE), current); - GVN_PARAM_GET_CLASS (obj)->put_value (GVN_PARAM (obj), &val); - g_value_unset (&val); + if (model) + { + self->model = g_object_ref (model); + g_object_connect (self->model + ,"signal::line-updated", db_calc_on_update, self + ,"signal-after::line-updated", db_calc_on_update_after, self + ,"signal::line-deleted", db_calc_on_delete, self + ,"signal::status-changed", db_calc_on_model_refresh, self + ,NULL + ); + } + + db_calc_refresh (self); } //+++++++++++++++++++++++++++++++++++++++++++++++++++ Class @@ -223,98 +317,91 @@ enum ,PROP_TYPE ,PROP_FUNC ,PROP_DATA - ,PROP_COL + ,PROP_COLUMN_INDEX + ,PROP_COLUMN_NAME }; -static void db_calc_set_property (DbCalc * obj, guint id, +static void db_calc_set_property (DbCalc * self, guint id, const GValue * value, GParamSpec * pspec) { switch (id) { case PROP_MODEL: - obj->model = g_value_dup_object (value); - if (obj->model) - g_object_connect (obj->model - ,"signal::line-updated", db_calc_before_unset, obj - ,"signal-after::line-updated", db_calc_after_set, obj - ,"signal::line-deleted", db_calc_before_delete, obj - ,"signal::status-changed", db_calc_refresh, obj - , NULL); + db_calc_set_model (self, g_value_get_object (value)); break; case PROP_TYPE: - obj->type = g_value_get_int (value); + self->type = g_value_get_enum (value); + db_calc_refresh (self); break; case PROP_FUNC: + db_calc_reset (self); if (g_value_get_pointer (value)) - obj->func = g_value_get_pointer (value); + self->func = g_value_get_pointer (value); + db_calc_refresh (self); break; case PROP_DATA: - obj->data = g_value_get_pointer (value); + self->data = g_value_get_pointer (value); break; - case PROP_COL: - obj->col = g_value_get_int (value); - - if (!obj->func) - obj->func = db_calc_internal_func; + case PROP_COLUMN_INDEX: + db_calc_set_column_index (self, g_value_get_int (value)); + break; + case PROP_COLUMN_NAME: + db_calc_set_column_name (self, g_value_get_string (value)); break; default: - G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, id, pspec); + G_OBJECT_WARN_INVALID_PROPERTY_ID (self, id, pspec); } } -static void db_calc_get_property (DbCalc * obj, guint id, +static void db_calc_get_property (DbCalc * self, guint id, GValue * value, GParamSpec * pspec) { switch (id) { case PROP_MODEL: - g_value_set_object (value, obj->model); + g_value_set_object (value, self->model); break; case PROP_TYPE: - g_value_set_int (value, obj->type); + g_value_set_enum (value, self->type); break; case PROP_FUNC: - g_value_set_pointer (value, obj->func); + g_value_set_pointer (value, self->func); break; case PROP_DATA: - g_value_set_pointer (value, obj->data); + g_value_set_pointer (value, self->data); break; - case PROP_COL: - g_value_set_int (value, obj->col); + case PROP_COLUMN_INDEX: + g_value_set_int (value, self->column_index); + break; + case PROP_COLUMN_NAME: + g_value_set_string (value, self->column_name); break; default: - G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, id, pspec); + G_OBJECT_WARN_INVALID_PROPERTY_ID (self, id, pspec); } } -static void db_calc_init (DbCalc * obj) +static void db_calc_init (DbCalc * self) { GvnParamSpec * spec; - obj->model = NULL; - obj->type = 0; - obj->func = NULL; - obj->data = NULL; - obj->col = 0; - obj->count = 0; + self->model = NULL; + self->type = 0; + self->func = NULL; + self->data = NULL; + self->column_index = -1; + self->column_name = NULL; + self->count = 0; spec = gvn_param_spec_new_with_attrs (G_TYPE_DOUBLE, FALSE, TRUE, NULL); - GVN_PARAM_GET_CLASS (obj)->set_spec (GVN_PARAM (obj), spec); + GVN_PARAM_GET_CLASS (self)->set_spec (GVN_PARAM (self), spec); } -static void db_calc_finalize (DbCalc * obj) +static void db_calc_finalize (DbCalc * self) { - if (obj->model) - { - g_object_disconnect (obj->model - ,"any_signal::line-updated", db_calc_before_unset, obj - ,"any_signal::line-updated", db_calc_after_set, obj - ,"any_signal::line-deleted", db_calc_before_delete, obj - ,"any_signal::status-changed", db_calc_refresh, obj - ,NULL - ); - g_clear_object (&obj->model); - } + db_calc_set_model (self, NULL); + g_free (self->column_name); + G_OBJECT_CLASS (db_calc_parent_class)->finalize (G_OBJECT (self)); } static void db_calc_class_init (DbCalcClass * k) @@ -355,13 +442,21 @@ static void db_calc_class_init (DbCalcClass * k) ,G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE) ); - g_object_class_install_property (klass, PROP_COL - ,g_param_spec_int ("col" - ,_("Column") + g_object_class_install_property (klass, PROP_COLUMN_INDEX + ,g_param_spec_int ("column-index" + ,_("Column index") ,_("A column to apply the operations over it") - ,0 - ,G_MAXINT32 - ,0 + ,-1 + ,G_MAXINT + ,-1 + ,G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE) + ); + + g_object_class_install_property (klass, PROP_COLUMN_NAME + ,g_param_spec_string ("column-name" + ,_("Column name") + ,_("A column name to apply the operations over it") + ,NULL ,G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE) ); } diff --git a/db/db-calc.h b/db/db-calc.h index db694a9..f0c8b8f 100644 --- a/db/db-calc.h +++ b/db/db-calc.h @@ -27,11 +27,11 @@ #define DB_CALC_LOG_DOMAIN (g_quark_from_string ("DbCalc")) #define DB_TYPE_CALC (db_calc_get_type ()) -#define DB_CALC(obj) (G_TYPE_CHECK_INSTANCE_CAST (obj, DB_TYPE_CALC, DbCalc)) -#define DB_IS_CALC(obj) (G_TYPE_CHECK_INSTANCE_TYPE (obj, DB_TYPE_CALC)) -#define DB_CALC_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((obj), DB_TYPE_CALC, DbCalcClass)) +#define DB_CALC(self) (G_TYPE_CHECK_INSTANCE_CAST (self, DB_TYPE_CALC, DbCalc)) +#define DB_IS_CALC(self) (G_TYPE_CHECK_INSTANCE_TYPE (self, DB_TYPE_CALC)) +#define DB_CALC_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((self), DB_TYPE_CALC, DbCalcClass)) #define DB_IS_CALC_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), DB_TYPE_CLASS)) -#define DB_CALC_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), DB_TYPE_CALC, DbCalcClass)) +#define DB_CALC_GET_CLASS(self) (G_TYPE_INSTANCE_GET_CLASS ((self), DB_TYPE_CALC, DbCalcClass)) #define DB_TYPE_CALC_TYPE (db_calc_type_get_type ()) @@ -40,7 +40,7 @@ typedef struct _DbCalcClass DbCalcClass; /** * DbCalcFunc: - * @obj: a #DbCalc + * @self: a #DbCalc * @iter: a #DbIter pointing to a row of the model * @out: the return position for the resulting value * @user_data: (closure): the data passed to the function @@ -49,7 +49,7 @@ typedef struct _DbCalcClass DbCalcClass; * on more than one column or to perform additional operations to a column, * previously to add them to the calculations performed by the @DbCalc itself. **/ -typedef void (*DbCalcFunc) (DbCalc * obj, DbIter * iter, GValue * out, gpointer user_data); +typedef void (*DbCalcFunc) (DbCalc * self, DbIter * iter, GValue * out, gpointer user_data); /** * DbCalcType: @@ -61,7 +61,7 @@ typedef void (*DbCalcFunc) (DbCalc * obj, DbIter * iter, GValue * out, gpointer typedef enum { DB_CALC_TYPE_SUM, - DB_CALC_TYPE_AVG + DB_CALC_TYPE_AVG } DbCalcType; @@ -73,7 +73,8 @@ struct _DbCalc DbCalcType type; DbCalcFunc func; gpointer data; - guint col; + guint column_index; + gchar * column_name; guint count; }; @@ -88,7 +89,7 @@ GType db_calc_type_get_type (); DbCalc * db_calc_new (DbModel * model ,DbCalcType type - ,gint col); + ,const gchar * column_name); DbCalc * db_calc_new_with_func (DbModel * model ,DbCalcType type ,DbCalcFunc func diff --git a/db/db-iterator.c b/db/db-iterator.c index 095a6e1..2ebc14f 100644 --- a/db/db-iterator.c +++ b/db/db-iterator.c @@ -73,12 +73,18 @@ static void db_iterator_unref_param (DbIterator * obj, DbParam * param) */ static void db_iterator_row_num_changed (DbIterator * obj) { - if (obj->row_selected) - obj->row = db_model_get_path (obj->model, &obj->iter); - else if (obj->selected || !obj->remember_selection) - obj->row = -1; + gint new_row = obj->row; - g_signal_emit (obj, signals[ROW_NUM_CHANGED], 0); + if (obj->row_selected) + new_row = db_model_get_path (obj->model, &obj->iter); + else if (obj->selected || !obj->remember_selection) + new_row = -1; + + if (new_row != obj->row) + { + obj->row = new_row; + g_signal_emit (obj, signals[ROW_NUM_CHANGED], 0); + } } /* @@ -918,6 +924,7 @@ static void db_iterator_set_property (DbIterator * obj, guint id, break; case PROP_REMEMBER_SELECTION: obj->remember_selection = g_value_get_boolean (value); + db_iterator_row_num_changed (obj); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, id, pspec); diff --git a/db/db-model.c b/db/db-model.c index 4ae3a18..3eee29e 100644 --- a/db/db-model.c +++ b/db/db-model.c @@ -1312,6 +1312,7 @@ const gchar * db_model_get_column_name (DbModel * self, gint col) && col < self->priv->result->ncols) && self->priv->column) return self->priv->column[col].alias; + return NULL; } @@ -1327,12 +1328,15 @@ const gchar * db_model_get_column_name (DbModel * self, gint col) **/ gint db_model_get_column_index (DbModel * self, const gchar * name) { + gpointer column; + g_return_val_if_fail (DB_IS_MODEL (self), -1); - if (!name || !self->priv->column_index) - return -1; + if (name && self->priv->column_index + && g_hash_table_lookup_extended (self->priv->column_index, name, NULL, &column)) + return GPOINTER_TO_INT (column); - return GPOINTER_TO_INT (g_hash_table_lookup (self->priv->column_index, name)); + return -1; } /** @@ -2292,7 +2296,7 @@ gboolean db_model_has_pending_operations (DbModel * self) } static SqlObject * db_model_create_where (DbModel * self, - TableInfo * tinfo, DbOperation * operation, gboolean for_insert) + TableInfo * tinfo, DbOperation * operation, gboolean use_new_values) { GSList * l; DbUpdatedField * u; @@ -2322,7 +2326,7 @@ static SqlObject * db_model_create_where (DbModel * self, g_value = &row->value[col]; - if (!for_insert) + if (!use_new_values) { for (n = operation->updated; n && (u = n->data); n = n->next) if (u->column == col) @@ -2350,7 +2354,7 @@ static SqlObject * db_model_create_where (DbModel * self, g_object_unref (g_object_ref_sink (where)); return NULL; } - + equal = sql_operation_new (SQL_OPERATION_TYPE_EQUAL); sql_list_add (and_operands, equal); diff --git a/module/data/Makefile.am b/module/data/Makefile.am index c119609..b15b0c5 100644 --- a/module/data/Makefile.am +++ b/module/data/Makefile.am @@ -7,7 +7,7 @@ example_DATA = \ example-menu.xml \ consulter.glade \ consulter-menu.xml -# customer.glade + customer.glade # signer.glade EXTRA_DIST = $(example_DATA) diff --git a/module/data/customer.glade b/module/data/customer.glade index 62dde27..a4d2bab 100644 --- a/module/data/customer.glade +++ b/module/data/customer.glade @@ -4,11 +4,45 @@ - - SELECT id, street, pc, city, province, ok, user_id FROM user_address WHERE #link ORDER BY id + + + + SELECT id, object FROM object + + + + + SELECT id, street, pc, city, province, ok, user_id + FROM user_address WHERE #link ORDER BY id + DB_MODEL_INSERT | DB_MODEL_DELETE | DB_MODEL_UPDATE + + + + + + + + SELECT id, name, credit, active, born, photo, object_id + FROM "user" ORDER BY id + DB_MODEL_INSERT | DB_MODEL_DELETE | DB_MODEL_UPDATE + + + + + SELECT id, #field FROM article WHERE #filter + + - - SELECT id, name, credit, active, born, photo, object_id FROM "user" ORDER BY id + + homes-model + + + info-model + + + id + + True @@ -55,6 +89,7 @@ True False + searcher-model name @@ -152,6 +187,7 @@ False info object_id + object-model 1 @@ -214,6 +250,7 @@ False info born + True False @@ -234,7 +271,7 @@ - False + True True 2 @@ -250,7 +287,6 @@ True False - end info VN_HANDLER_SHOW_REFRESH | VN_HANDLER_SHOW_UNDO | VN_HANDLER_SHOW_SAVE | VN_HANDLER_SHOW_REMOVE | VN_HANDLER_SHOW_ADD | VN_HANDLER_SHOW_SCROLL @@ -364,7 +400,6 @@ True False - end homes VN_HANDLER_SHOW_REFRESH | VN_HANDLER_SHOW_UNDO | VN_HANDLER_SHOW_SAVE | VN_HANDLER_SHOW_REMOVE | VN_HANDLER_SHOW_ADD diff --git a/module/data/example.xml b/module/data/example.xml index c04bd13..689126d 100644 --- a/module/data/example.xml +++ b/module/data/example.xml @@ -8,5 +8,11 @@ icon="system-run"> Consulter +
+ Customer +
diff --git a/module/src/Makefile.am b/module/src/Makefile.am index 5542538..40e943d 100644 --- a/module/src/Makefile.am +++ b/module/src/Makefile.am @@ -11,9 +11,9 @@ libexample_la_LDFLAGS = -avoid-version libexample_la_LIBADD = $(top_builddir)/vn/libvn.la libexample_la_SOURCES = \ vn-consulter.h \ - vn-consulter.c -# vn-customer.h -# vn-customer.c + vn-consulter.c \ + vn-customer.h \ + vn-customer.c example_querydir = $(module_querydir)/example example_query_DATA = ../sql/example/consulter.sql diff --git a/sql/sql-batch.c b/sql/sql-batch.c index 1a8ab4b..043ae12 100644 --- a/sql/sql-batch.c +++ b/sql/sql-batch.c @@ -41,17 +41,18 @@ SqlBatch * sql_batch_new () //+++++++++++++++++++++++++++++++++++++++++++++++++++ Private -static void sql_batch_item_changed (SqlObject * item, SqlBatch * obj) +static void sql_batch_item_changed (SqlObject * item, SqlBatch * self) { - sql_batch_changed (obj); + if (!self->frozen) + sql_batch_changed (self); } -static void sql_batch_free_item (SqlBatch * obj, SqlObject * item) +static void sql_batch_free_item (SqlBatch * self, SqlObject * item) { if (item) { g_signal_handlers_disconnect_by_func (item, - sql_batch_item_changed, obj); + sql_batch_item_changed, self); g_object_unref (item); } } @@ -60,20 +61,20 @@ static void sql_batch_free_item (SqlBatch * obj, SqlObject * item) /** * sql_batch_is_ready: - * @obj: a #SqlBatch + * @self: a #SqlBatch * - * Checks if @obj and all of its elements are ready to be rendered. + * Checks if @self and all of its elements are ready to be rendered. * * Return value: %TRUE if ready, %FALSE otherwise. **/ -gboolean sql_batch_is_ready (SqlBatch * obj) +gboolean sql_batch_is_ready (SqlBatch * self) { gpointer item; GHashTableIter iter; - g_return_val_if_fail (SQL_IS_BATCH (obj), FALSE); + g_return_val_if_fail (SQL_IS_BATCH (self), FALSE); - g_hash_table_iter_init (&iter, obj->items); + g_hash_table_iter_init (&iter, self->items); while (g_hash_table_iter_next (&iter, NULL, &item)) if (!item || !sql_object_is_ready (item)) @@ -84,7 +85,7 @@ gboolean sql_batch_is_ready (SqlBatch * obj) /** * sql_batch_get: - * @obj: a #SqlBatch + * @self: a #SqlBatch * @id: the id of the #SqlHolder * * Gets a held object by its id. @@ -92,107 +93,108 @@ gboolean sql_batch_is_ready (SqlBatch * obj) * Return value: (transfer none): the #SqlObject if an object with that id * exists, %NULL otherwise **/ -SqlObject * sql_batch_get (SqlBatch * obj, const gchar * id) +SqlObject * sql_batch_get (SqlBatch * self, const gchar * id) { - g_return_val_if_fail (SQL_IS_BATCH (obj), NULL); + g_return_val_if_fail (SQL_IS_BATCH (self), NULL); g_return_val_if_fail (id, NULL); - if (obj->items) - return g_hash_table_lookup (obj->items, id); + if (self->items) + return g_hash_table_lookup (self->items, id); return NULL; } /** * sql_batch_add: - * @obj: a #SqlBatch + * @self: a #SqlBatch * @id: the id of the #SqlHolder * @item: the #SqlObject * * Adds a new item to the batch. **/ -void sql_batch_add (SqlBatch * obj, const gchar * id, SqlObject * item) +void sql_batch_add (SqlBatch * self, const gchar * id, SqlObject * item) { - g_return_if_fail (SQL_IS_BATCH (obj)); + g_return_if_fail (SQL_IS_BATCH (self)); g_return_if_fail (id); g_return_if_fail (SQL_IS_OBJECT (item) || !item); - sql_batch_remove (obj, id); + sql_batch_remove (self, id); if (item) { g_object_ref_sink (item); g_signal_connect (item, "changed", - G_CALLBACK (sql_batch_item_changed), obj); + G_CALLBACK (sql_batch_item_changed), self); } - g_hash_table_replace (obj->items, g_strdup (id), item); + g_hash_table_replace (self->items, g_strdup (id), item); + sql_batch_item_changed (NULL, self); } /** - * sql_batch_add_from_param: - * @obj: a #SqlBatch + * sql_batch_add_param: + * @self: a #SqlBatch * @id: the id assigned to the item + * @param: the parameter **/ -void sql_batch_add_from_param (SqlBatch * obj, const gchar * id, GvnParam * param) +void sql_batch_add_from_param (SqlBatch * self, const gchar * id, GvnParam * param) { - g_return_if_fail (SQL_IS_BATCH (obj)); + g_return_if_fail (SQL_IS_BATCH (self)); g_return_if_fail (id); g_return_if_fail (GVN_IS_PARAM (param)); - sql_batch_add (obj, id, sql_value_new_with_param (param)); + sql_batch_add (self, id, sql_value_new_with_param (param)); } /** - * sql_batch_add_from_value: - * @obj: a #SqlBatch + * sql_batch_add_value: + * @self: a #SqlBatch * @id: the id assigned to the item + * @value: the value **/ -void sql_batch_add_from_value (SqlBatch * obj, const gchar * id, GType type, gpointer content) +void sql_batch_add_from_value (SqlBatch * self, const gchar * id, const GValue * value) { - g_return_if_fail (SQL_IS_BATCH (obj)); + g_return_if_fail (SQL_IS_BATCH (self)); g_return_if_fail (id); + g_return_if_fail (G_IS_VALUE (value)); - GValue gvalue = {0}; - gvn_value_new_with_content (&gvalue, type, content); - sql_batch_add (obj, id, sql_value_new_with_value (&gvalue)); - g_value_unset (&gvalue); + sql_batch_add (self, id, sql_value_new_with_value (value)); } /** * sql_batch_remove: - * @obj: a #SqlBatch + * @self: a #SqlBatch * @id: the id of the #SqlHolder * * Removes a held object from the batch. **/ -void sql_batch_remove (SqlBatch * obj, const gchar * id) +void sql_batch_remove (SqlBatch * self, const gchar * id) { - g_return_val_if_fail (SQL_IS_BATCH (obj), NULL); + g_return_val_if_fail (SQL_IS_BATCH (self), NULL); g_return_val_if_fail (id, NULL); - SqlObject * item = sql_batch_get (obj, id); + SqlObject * item = sql_batch_get (self, id); if (item) { - sql_batch_free_item (obj, item); - g_hash_table_remove (obj->items, id); + sql_batch_free_item (self, item); + g_hash_table_remove (self->items, id); } } /** * sql_batch_merge: - * @obj: a #SqlBatch + * @self: a #SqlBatch * @batch: a #SqlBatch * * Meges the batch with another batch. **/ -void sql_batch_merge (SqlBatch * obj, SqlBatch * batch) +void sql_batch_merge (SqlBatch * self, SqlBatch * batch) { GHashTableIter iter; gpointer key, value; - g_return_if_fail (SQL_IS_BATCH (obj)); + g_return_if_fail (SQL_IS_BATCH (self)); g_return_if_fail (SQL_IS_BATCH (batch) || !batch); if (!batch) @@ -201,47 +203,74 @@ void sql_batch_merge (SqlBatch * obj, SqlBatch * batch) g_hash_table_iter_init (&iter, batch->items); while (g_hash_table_iter_next (&iter, &key, &value)) - sql_batch_add (obj, key, value); + sql_batch_add (self, key, value); } /** * sql_batch_changed: - * @obj: a #SqlBatch + * @self: a #SqlBatch * * Emits the changed signal on #SqlBatch. **/ -void sql_batch_changed (SqlBatch * obj) +void sql_batch_changed (SqlBatch * self) { - g_return_if_fail (SQL_IS_BATCH (obj)); + g_return_if_fail (SQL_IS_BATCH (self)); - g_signal_emit (obj, signals[CHANGED], 0); + g_signal_emit (self, signals[CHANGED], 0); +} + +/** + * sql_batch_freeze: + * @self: a #SqlBatch + * + * Freezes the changed signal on #SqlBatch. + **/ +void sql_batch_freeze (SqlBatch * self) +{ + g_return_if_fail (SQL_IS_BATCH (self)); + + self->frozen = TRUE; +} + +/** + * sql_batch_unfreeze: + * @self: a #SqlBatch + * + * Unfreezes the changed signal on #SqlBatch. + **/ +void sql_batch_unfreeze (SqlBatch * self) +{ + g_return_if_fail (SQL_IS_BATCH (self)); + + self->frozen = FALSE; } //+++++++++++++++++++++++++++++++++++++++++++++++++++ Class -static void sql_batch_init (SqlBatch * obj) +static void sql_batch_init (SqlBatch * self) { - obj->items = g_hash_table_new_full ( + self->items = g_hash_table_new_full ( g_str_hash ,g_str_equal ,g_free ,NULL ); + self->frozen = FALSE; } -static void sql_batch_finalize (SqlBatch * obj) +static void sql_batch_finalize (SqlBatch * self) { gpointer item; GHashTableIter iter; - g_hash_table_iter_init (&iter, obj->items); + g_hash_table_iter_init (&iter, self->items); while (g_hash_table_iter_next (&iter, NULL, &item)) - sql_batch_free_item (obj, item); + sql_batch_free_item (self, item); - g_hash_table_destroy (obj->items); + g_hash_table_destroy (self->items); - G_OBJECT_CLASS (sql_batch_parent_class)->finalize (G_OBJECT (obj)); + G_OBJECT_CLASS (sql_batch_parent_class)->finalize (G_OBJECT (self)); } static void sql_batch_class_init (SqlBatchClass * klass) @@ -250,7 +279,7 @@ static void sql_batch_class_init (SqlBatchClass * klass) /** * SqlBatch::changed: - * @obj: the object which emit the signal. + * @self: the object which emit the signal. * * This signal is emitted every time the batch or one of its attributes * is modified. diff --git a/sql/sql-batch.h b/sql/sql-batch.h index 0eac51c..3ca3443 100644 --- a/sql/sql-batch.h +++ b/sql/sql-batch.h @@ -21,10 +21,10 @@ #include #define SQL_TYPE_BATCH (sql_batch_get_type ()) -#define SQL_BATCH(obj) (G_TYPE_CHECK_INSTANCE_CAST (obj, SQL_TYPE_BATCH, SqlBatch)) -#define SQL_IS_BATCH(obj) (G_TYPE_CHECK_INSTANCE_TYPE (obj, SQL_TYPE_BATCH)) +#define SQL_BATCH(self) (G_TYPE_CHECK_INSTANCE_CAST (self, SQL_TYPE_BATCH, SqlBatch)) +#define SQL_IS_BATCH(self) (G_TYPE_CHECK_INSTANCE_TYPE (self, SQL_TYPE_BATCH)) #define SQL_BATCH_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST (klass, SQL_TYPE_BATCH, SqlBatchClass)) -#define SQL_BATCH_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS (obj, SQL_TYPE_BATCH, SqlBatchClass)) +#define SQL_BATCH_GET_CLASS(self) (G_TYPE_INSTANCE_GET_CLASS (self, SQL_TYPE_BATCH, SqlBatchClass)) typedef struct _SqlBatch SqlBatch; typedef struct _SqlBatchClass SqlBatchClass; @@ -33,6 +33,7 @@ struct _SqlBatch { GInitiallyUnowned parent; GHashTable * items; + gboolean frozen; }; struct _SqlBatchClass @@ -45,13 +46,15 @@ struct _SqlBatchClass GType sql_batch_get_type (); SqlBatch * sql_batch_new (); -gboolean sql_batch_is_ready (SqlBatch * obj); -SqlObject * sql_batch_get (SqlBatch * obj, const gchar * id); -void sql_batch_add (SqlBatch * obj, const gchar * id, SqlObject * item); -void sql_batch_add_from_param (SqlBatch * obj, const gchar * id, GvnParam * param); -void sql_batch_add_from_value (SqlBatch * obj, const gchar * id, GType type, gpointer content); -void sql_batch_remove (SqlBatch * obj, const gchar * id); -void sql_batch_merge (SqlBatch * obj, SqlBatch * batch); -void sql_batch_changed (SqlBatch * obj); +gboolean sql_batch_is_ready (SqlBatch * self); +SqlObject * sql_batch_get (SqlBatch * self, const gchar * id); +void sql_batch_add (SqlBatch * self, const gchar * id, SqlObject * item); +void sql_batch_add_from_param (SqlBatch * self, const gchar * id, GvnParam * param); +void sql_batch_add_from_value (SqlBatch * self, const gchar * id, const GValue * value); +void sql_batch_remove (SqlBatch * self, const gchar * id); +void sql_batch_merge (SqlBatch * self, SqlBatch * batch); +void sql_batch_changed (SqlBatch * self); +void sql_batch_freeze (SqlBatch * self); +void sql_batch_unfreeze (SqlBatch * self); #endif \ No newline at end of file diff --git a/sql/sql-value.c b/sql/sql-value.c index 1d06023..5a7216d 100644 --- a/sql/sql-value.c +++ b/sql/sql-value.c @@ -63,7 +63,10 @@ static void sql_value_render (SqlValue * obj, SqlRender * render) sql_render_printf (render, "'%c'", g_value_get_schar (value)); break; case G_TYPE_INT: - sql_render_printf (render, "%i", g_value_get_int (value)); + sql_render_printf (render, "%d", g_value_get_int (value)); + break; + case G_TYPE_INT64: + sql_render_printf (render, "%lld", g_value_get_int64 (value)); break; case G_TYPE_UINT: sql_render_printf (render, "%u", g_value_get_uint (value)); diff --git a/vn/column/vn-column-spin.c b/vn/column/vn-column-spin.c index 56314c1..ee92b30 100644 --- a/vn/column/vn-column-spin.c +++ b/vn/column/vn-column-spin.c @@ -210,8 +210,14 @@ static void vn_column_spin_init (VnColumnSpin * obj) { GtkCellRenderer * cell = gtk_cell_renderer_spin_new (); - obj->adjustment = gtk_adjustment_new (0.0, G_MININT, G_MAXINT, 0.0, 1.0, 0.0); - g_object_set (cell, "adjustment", obj->adjustment, NULL); + obj->adjustment = gtk_adjustment_new (0.0, G_MININT, G_MAXINT, 0.0, 1.0, 0.0); + + g_object_set (cell + ,"adjustment", obj->adjustment + ,"xalign", 1.0 + ,"alignment", PANGO_ALIGN_RIGHT + ,NULL + ); obj->format = NULL; diff --git a/vn/field/vn-completion.c b/vn/field/vn-completion.c index dd6e8b6..43dfa50 100644 --- a/vn/field/vn-completion.c +++ b/vn/field/vn-completion.c @@ -93,7 +93,7 @@ static void vn_completion_cb_status_changed (DbModel * model, static void vn_completion_cb_changed (GtkEditable * entry, VnCompletion * obj) { const gchar * text = gtk_entry_get_text (GTK_ENTRY (entry)); - + if (obj->invalid) { obj->invalid = FALSE; @@ -124,7 +124,7 @@ static void vn_completion_cb_changed (GtkEditable * entry, VnCompletion * obj) static void vn_completion_iter_changed (VnCompletion * obj, DbIter * iter) { const GValue * value = db_model_get_value (obj->model, iter, 0, NULL); - + if (value) VN_FIELD_GET_CLASS (obj)->value_changed (VN_FIELD (obj), value); diff --git a/vn/vn-column.c b/vn/vn-column.c index 6fe5c95..3af0a80 100644 --- a/vn/vn-column.c +++ b/vn/vn-column.c @@ -76,7 +76,8 @@ static void vn_column_data_func (GtkTreeViewColumn * col, GtkCellRenderer * cell else background = NULL; - g_object_set (cell, "cell-background-rgba", background, NULL); + if (background) + g_object_set (cell, "cell-background-rgba", background, NULL); if (obj->style_func) obj->style_func (VN_COLUMN (col), cell, iter, &value); @@ -420,7 +421,7 @@ static void vn_column_set_property (VnColumn * obj, guint id, case PROP_STYLE_FUNC: obj->style_func = g_value_get_pointer (value); break; - default: + default: G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, id, pspec); } } diff --git a/vn/vn-handler.c b/vn/vn-handler.c index b40df20..35d8254 100644 --- a/vn/vn-handler.c +++ b/vn/vn-handler.c @@ -473,7 +473,9 @@ static void vn_handler_init (VnHandler * obj) obj->buttons = GTK_WIDGET (g_object_new (GTK_TYPE_BUTTON_BOX ,"layout-style", GTK_BUTTONBOX_EXPAND ,"homogeneous", FALSE - ,NULL)); + ,"halign", GTK_ALIGN_END + ,NULL + )); context = gtk_widget_get_style_context (obj->buttons); provider = gtk_css_provider_get_default ();