From e092946ec5215b714f008e8d4e15b566b805fa9f Mon Sep 17 00:00:00 2001 From: Juan Ferrer Toribio Date: Wed, 16 Jul 2014 16:12:36 +0200 Subject: [PATCH] GvnParam: - Ahora es una interfaz en vez de una clase. SqlValue, DbParam, DbCalc, VnField: - Implementan la interfaz GvnParam. VnField: - Se ha afinado su funcionamiento. VnLogin: - Mejorada integracion con GApplication (Aun quedan cosas por hacer). --- db/db-calc.c | 139 ++++++--- db/db-calc.h | 8 +- db/db-iterator.c | 605 +++++++++++++++++++-------------------- db/db-iterator.h | 68 ++--- db/db-model-holder.c | 18 +- db/db-model-holder.h | 14 +- db/db-model.c | 14 + db/db-model.h | 1 + db/db-param.c | 267 +++++++++++------ db/db-param.h | 23 +- gvn/gvn-param.c | 437 ++++------------------------ gvn/gvn-param.h | 84 ++---- main/main.c | 14 +- sql/parser/gram.y | 2 +- sql/sql-value.c | 220 +++++++------- sql/sql-value.h | 11 +- vn/field/vn-combo.c | 153 +++++----- vn/field/vn-completion.c | 156 +++++----- vn/field/vn-http-image.c | 95 +++--- vn/gui/login.glade | 14 +- vn/vn-field.c | 521 +++++++++++++++++---------------- vn/vn-field.h | 48 ++-- vn/vn-login.c | 96 ++++--- vn/vn-login.h | 3 +- 24 files changed, 1440 insertions(+), 1571 deletions(-) diff --git a/db/db-calc.c b/db/db-calc.c index fa703cb..f6f57f2 100644 --- a/db/db-calc.c +++ b/db/db-calc.c @@ -18,6 +18,8 @@ #include "db-calc.h" #include "db-row.h" +static void db_calc_param_init (GvnParamInterface * iface); + /** * SECTION: db-calc * @short_description: the result of an operation made over a column or between @@ -37,8 +39,10 @@ * needed with the #DbModel fields, in the latter case, custom data can also be * passed. **/ - -G_DEFINE_TYPE (DbCalc, db_calc, GVN_TYPE_PARAM); +G_DEFINE_TYPE_WITH_CODE (DbCalc, db_calc, G_TYPE_OBJECT, + G_IMPLEMENT_INTERFACE (GVN_TYPE_PARAM, + db_calc_param_init) +); /** * db_calc_new: @@ -80,6 +84,51 @@ DbCalc * db_calc_new_with_func (DbModel * model, DbCalcType type, DbCalcFunc fun //+++++++++++++++++++++++++++++++++++++++++++++++++++ Private +static void db_calc_put_value (DbCalc * self, const GValue * value) +{ + gvn_value_copy (value, self->value); + g_signal_emit_by_name (self, "value-changed", value); + + if (self->master) + gvn_param_request_value (self->master, value, NULL); +} + +static const GValue * db_calc_get_value (DbCalc * self) +{ + return self->value; +} + +static gboolean db_calc_request_value (DbCalc * self, const GValue * value, GError ** err) +{ + return gvn_param_spec_validate (self->spec, value, err); +} + +static GvnParam * db_calc_get_master (DbCalc * self) +{ + return self->master; +} + +static void db_calc_set_master (DbCalc * self, GvnParam * master) +{ + if (self->master) + g_clear_object (&self->master); + if (master) + self->master = g_object_ref_sink (master); +} + +static const GvnParamSpec * db_calc_get_spec (DbCalc * self) +{ + return self->spec; +} + +static GvnParamStatus db_calc_get_status (DbCalc * self) +{ + if (self->model && db_model_is_ready (self->model)) + return GVN_PARAM_STATUS_OK; + + return GVN_PARAM_STATUS_BUSY; +} + static gdouble db_calc_value_to_double (const GValue * v) { switch (G_VALUE_TYPE (v)) @@ -172,7 +221,7 @@ static void db_calc_refresh (DbCalc * self) else g_value_init (&val, GVN_TYPE_NULL); - GVN_PARAM_GET_CLASS (self)->put_value (GVN_PARAM (self), &val); + db_calc_put_value (self, &val); g_value_unset (&val); } @@ -207,7 +256,7 @@ static void db_calc_on_update (DbModel * model, DbIter * iter, DbCalc * self) self->count--; g_value_unset (&value); g_value_set_double (g_value_init (&value, G_TYPE_DOUBLE), current); - GVN_PARAM_GET_CLASS (self)->put_value (GVN_PARAM (self), &value); + db_calc_put_value (self, &value); } g_value_unset (&value); @@ -234,7 +283,7 @@ static void db_calc_on_update_after (DbModel * model, DbIter * iter, DbCalc * se self->count++; g_value_unset (&value); g_value_set_double (g_value_init (&value, G_TYPE_DOUBLE), current); - GVN_PARAM_GET_CLASS (self)->put_value (GVN_PARAM (self), &value); + db_calc_put_value (self, &value); } g_value_unset (&value); @@ -302,7 +351,9 @@ void db_calc_set_model (DbCalc * self, DbModel * model) enum { - PROP_MODEL = 1 + PROP_VALUE = 1 + ,PROP_MASTER + ,PROP_MODEL ,PROP_TYPE ,PROP_FUNC ,PROP_DATA @@ -315,6 +366,12 @@ static void db_calc_set_property (DbCalc * self, guint id, { switch (id) { + case PROP_VALUE: + db_calc_request_value (self, g_value_get_boxed (value), NULL); + break; + case PROP_MASTER: + db_calc_set_master (self, g_value_get_object (value)); + break; case PROP_MODEL: db_calc_set_model (self, g_value_get_object (value)); break; @@ -347,6 +404,12 @@ static void db_calc_get_property (DbCalc * self, guint id, { switch (id) { + case PROP_VALUE: + g_value_set_boxed (value, self->value); + break; + case PROP_MASTER: + g_value_set_object (value, self->master); + break; case PROP_MODEL: g_value_set_object (value, self->model); break; @@ -372,8 +435,7 @@ static void db_calc_get_property (DbCalc * self, guint id, static void db_calc_init (DbCalc * self) { - GvnParamSpec * spec; - + self->master = NULL; self->model = NULL; self->type = 0; self->func = NULL; @@ -381,58 +443,62 @@ static void db_calc_init (DbCalc * self) self->column_index = -1; self->column_name = NULL; self->count = 0; + self->spec = gvn_param_spec_new_with_attrs (G_TYPE_DOUBLE, FALSE, TRUE, NULL); - spec = gvn_param_spec_new_with_attrs (G_TYPE_DOUBLE, FALSE, TRUE, NULL); - GVN_PARAM_GET_CLASS (self)->set_spec (GVN_PARAM (self), spec); + self->value = g_new0 (GValue, 1); + g_value_init (self->value, GVN_TYPE_NULL); } static void db_calc_finalize (DbCalc * self) { db_calc_set_model (self, NULL); + db_calc_set_master (self, NULL); + g_value_unset (self->value); + gvn_param_spec_free (self->spec); + g_free (self->value); g_free (self->column_name); G_OBJECT_CLASS (db_calc_parent_class)->finalize (G_OBJECT (self)); } -static void db_calc_class_init (DbCalcClass * k) +static void db_calc_class_init (DbCalcClass * klass) { - GObjectClass * klass = G_OBJECT_CLASS (k); - klass->finalize = (GObjectFinalizeFunc) db_calc_finalize; - klass->set_property = (GObjectSetPropertyFunc) db_calc_set_property; - klass->get_property = (GObjectGetPropertyFunc) db_calc_get_property; + GObjectClass * k = G_OBJECT_CLASS (klass); + k->finalize = (GObjectFinalizeFunc) db_calc_finalize; + k->set_property = (GObjectSetPropertyFunc) db_calc_set_property; + k->get_property = (GObjectGetPropertyFunc) db_calc_get_property; - g_object_class_install_property (klass, PROP_MODEL - ,g_param_spec_object ("model" + g_object_class_override_property (k, PROP_VALUE, "value"); + g_object_class_override_property (k, PROP_MASTER, "master"); + + g_object_class_install_property (k, PROP_MODEL, + g_param_spec_object ("model" ,_("Model") ,_("The model where the operations will be applied") ,DB_TYPE_MODEL ,G_PARAM_READWRITE) ); - - g_object_class_install_property (klass, PROP_TYPE - ,g_param_spec_enum ("type" + g_object_class_install_property (k, PROP_TYPE, + g_param_spec_enum ("type" ,_("Operation type") ,_("The type of the operation applied over the function") ,DB_TYPE_CALC_TYPE ,DB_CALC_TYPE_SUM ,G_PARAM_READWRITE) ); - - g_object_class_install_property (klass, PROP_FUNC - ,g_param_spec_pointer ("function" + g_object_class_install_property (k, PROP_FUNC, + g_param_spec_pointer ("function" ,_("Function") ,_("The function to execute") ,G_PARAM_READWRITE) ); - - g_object_class_install_property (klass, PROP_DATA - ,g_param_spec_pointer ("data" + g_object_class_install_property (k, PROP_DATA, + g_param_spec_pointer ("data" ,_("Data") ,_("The user provided data for the function") ,G_PARAM_READWRITE) ); - - g_object_class_install_property (klass, PROP_COLUMN_INDEX - ,g_param_spec_int ("column-index" + g_object_class_install_property (k, PROP_COLUMN_INDEX, + g_param_spec_int ("column-index" ,_("Column index") ,_("A column to apply the operations over it") ,-1 @@ -440,9 +506,8 @@ static void db_calc_class_init (DbCalcClass * k) ,-1 ,G_PARAM_READWRITE) ); - - g_object_class_install_property (klass, PROP_COLUMN_NAME - ,g_param_spec_string ("column-name" + g_object_class_install_property (k, PROP_COLUMN_NAME, + g_param_spec_string ("column-name" ,_("Column name") ,_("A column name to apply the operations over it") ,NULL @@ -450,6 +515,16 @@ static void db_calc_class_init (DbCalcClass * k) ); } +static void db_calc_param_init (GvnParamInterface * iface) +{ + iface->get_value = (GvnParamGetValueFunc) db_calc_get_value; + iface->request_value = (GvnParamRequestValueFunc) db_calc_request_value; + iface->get_master = (GvnParamGetMasterFunc) db_calc_get_master; + iface->set_master = (GvnParamSetMasterFunc) db_calc_set_master; + iface->get_spec = (GvnParamGetSpecFunc) db_calc_get_spec; + iface->get_status = (GvnParamGetStatusFunc) db_calc_get_status; +} + GType db_calc_type_get_type () { static GType type = 0; diff --git a/db/db-calc.h b/db/db-calc.h index de49f8e..4ce5c38 100644 --- a/db/db-calc.h +++ b/db/db-calc.h @@ -67,8 +67,10 @@ DbCalcType; struct _DbCalc { - GvnParam parent; - + GObject parent; + GValue * value; + GvnParam * master; + GvnParamSpec * spec; DbModel * model; DbCalcType type; DbCalcFunc func; @@ -81,7 +83,7 @@ struct _DbCalc struct _DbCalcClass { /* */ - GvnParamClass klass; + GObjectClass klass; }; GType db_calc_get_type (); diff --git a/db/db-iterator.c b/db/db-iterator.c index 2ebc14f..6d05ced 100644 --- a/db/db-iterator.c +++ b/db/db-iterator.c @@ -18,7 +18,9 @@ #include "db-iterator.h" #include "db-model-holder.h" -#define IS_READY(obj) (obj->model && db_model_get_status (obj->model) == DB_MODEL_STATUS_READY) +#define IS_READY(self) (self->model && db_model_is_ready (self->model)) + +static void db_iterator_model_holder_init (DbModelHolderInterface * iface); /** * SECTION:db-iterator @@ -28,9 +30,6 @@ * The #DbIterator manages a connection with a data base. The function * db_iterator_new() creates a new #DbIterator. */ - -static void db_iterator_model_holder_init (DbModelHolderInterface * iface); - G_DEFINE_TYPE_WITH_CODE (DbIterator, db_iterator, G_TYPE_OBJECT, G_IMPLEMENT_INTERFACE (DB_TYPE_MODEL_HOLDER, db_iterator_model_holder_init) @@ -62,186 +61,180 @@ DbIterator * db_iterator_new (DbModel * model) //+++++++++++++++++++++++++++++++++++++++++++++++++++ Private -static void db_iterator_unref_param (DbIterator * obj, DbParam * param) +static void db_iterator_unref_param (DbIterator * self, DbParam * param) { - obj->params = g_list_remove (obj->params, param); + self->params = g_list_remove (self->params, param); } /* * #DbIterator instances call this function every time line in * the model is changed. */ -static void db_iterator_row_num_changed (DbIterator * obj) +static void db_iterator_row_num_changed (DbIterator * self) { - gint new_row = obj->row; + if (self->row_selected) + self->row = db_model_get_path (self->model, &self->iter); + else if (self->selected || !self->remember_selection) + self->row = -1; - 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); - } + g_signal_emit (self, signals[ROW_NUM_CHANGED], 0); } /* * #DbIterator instances call this function every time the data of the params * mustbe updated. */ -static void db_iterator_iter_changed (DbIterator * obj) +static void db_iterator_iter_changed (DbIterator * self) { - db_iterator_row_num_changed (obj); - g_signal_emit (obj, signals[ITER_CHANGED], 0); + db_iterator_row_num_changed (self); + g_signal_emit (self, signals[ITER_CHANGED], 0); } -static void db_iterator_unselect (DbIterator * obj) +static void db_iterator_unselect (DbIterator * self) { - if (obj->selected) + if (self->selected) { - g_hash_table_destroy (obj->selected); - obj->selected = NULL; + g_hash_table_destroy (self->selected); + self->selected = NULL; } } -static void db_iterator_set_iter (DbIterator * obj, DbIter * iter) +static void db_iterator_set_iter (DbIterator * self, DbIter * iter) { if (iter) { - obj->row_selected = TRUE; - obj->iter = *iter; - db_iterator_iter_changed (obj); + self->row_selected = TRUE; + self->iter = *iter; + db_iterator_iter_changed (self); } - else if (obj->row_selected) + else if (self->row_selected) { - obj->row_selected = FALSE; - db_iterator_iter_changed (obj); + self->row_selected = FALSE; + db_iterator_iter_changed (self); } - db_iterator_unselect (obj); + db_iterator_unselect (self); } /* * Function called when row is inserted on the model. */ -static void db_iterator_on_model_line_inserted (DbModel * model, DbIter * iter, DbIterator * obj) +static void db_iterator_on_model_line_inserted (DbModel * model, DbIter * iter, DbIterator * self) { - g_signal_emit (obj, signals[DATA_CHANGED], 0); + g_signal_emit (self, signals[DATA_CHANGED], 0); } /* * Function called when row is updated on the model. */ -static void db_iterator_on_model_line_updated_after (DbModel * model, DbIter * iter, DbIterator * obj) +static void db_iterator_on_model_line_updated_after (DbModel * model, DbIter * iter, DbIterator * self) { - if (obj->row_selected && db_iter_compare (iter, &obj->iter)) - db_iterator_iter_changed (obj); + if (self->row_selected && db_iter_compare (iter, &self->iter)) + db_iterator_iter_changed (self); - g_signal_emit (obj, signals[DATA_CHANGED], 0); + g_signal_emit (self, signals[DATA_CHANGED], 0); } /* * Function called when row is deleted on the model. */ -static void db_iterator_on_model_line_deleted (DbModel * model, gint row, DbIterator * obj) +static void db_iterator_on_model_line_deleted (DbModel * model, gint row, DbIterator * self) { - if (obj->row_selected && row == obj->row) + if (self->row_selected && row == self->row) { DbIter iter; if (db_model_get_iter (model, &iter, row + 1) || db_model_get_iter (model, &iter, row - 1)) - db_iterator_set_iter (obj, &iter); + db_iterator_set_iter (self, &iter); else - db_iterator_set_iter (obj, NULL); + db_iterator_set_iter (self, NULL); } } -static void db_iterator_on_model_line_deleted_after (DbModel * model, gint row, DbIterator * obj) +static void db_iterator_on_model_line_deleted_after (DbModel * model, gint row, DbIterator * self) { - if (obj->row_selected || obj->selected) - db_iterator_row_num_changed (obj); + if (self->row_selected || self->selected) + db_iterator_row_num_changed (self); - g_signal_emit (obj, signals[DATA_CHANGED], 0); + g_signal_emit (self, signals[DATA_CHANGED], 0); } /* * Function called when model rows are reordered. */ static void db_iterator_on_model_lines_reordered (DbModel * model, - gint column, gint * new_order, DbIterator * obj) + gint column, gint * new_order, DbIterator * self) { - if (obj->row_selected || obj->selected) - db_iterator_row_num_changed (obj); + if (self->row_selected || self->selected) + db_iterator_row_num_changed (self); } /* * Function called when model status changes. */ -static void db_iterator_on_model_status_changed (DbModel * model, DbModelStatus status, DbIterator * obj) +static void db_iterator_on_model_status_changed (DbModel * model, DbModelStatus status, DbIterator * self) { if (status == DB_MODEL_STATUS_READY) { DbIter iter; gint nrows = db_model_get_nrows (model); - g_signal_emit (obj, signals[STATUS_CHANGED], 0, IS_READY(obj)); + g_signal_emit (self, signals[STATUS_CHANGED], 0, IS_READY(self)); - if (obj->row >= 0 && obj->row < nrows - && db_model_get_iter (model, &iter, obj->row)) - db_iterator_set_iter (obj, &iter); + if (self->row >= 0 && self->row < nrows + && db_model_get_iter (model, &iter, self->row)) + db_iterator_set_iter (self, &iter); else - db_iterator_set_iter (obj, NULL); + db_iterator_set_iter (self, NULL); } else { - db_iterator_set_iter (obj, NULL); - g_signal_emit (obj, signals[STATUS_CHANGED], 0, IS_READY(obj)); + db_iterator_set_iter (self, NULL); + g_signal_emit (self, signals[STATUS_CHANGED], 0, IS_READY(self)); } } /* * Function called when model operations are done. */ -static void db_iterator_on_model_operations_done (DbModel * model, DbIterator * obj) +static void db_iterator_on_model_operations_done (DbModel * model, DbIterator * self) { - g_signal_emit (obj, signals[OPERATIONS_DONE], 0); + g_signal_emit (self, signals[OPERATIONS_DONE], 0); } -static void db_iterator_set_model_mode (DbIterator * obj) +static void db_iterator_set_model_mode (DbIterator * self) { - if (obj->mode == DB_ITERATOR_MODE_ON_CHANGE) - db_model_set_mode (obj->model, DB_MODEL_MODE_ON_CHANGE); + if (self->mode == DB_ITERATOR_MODE_ON_CHANGE) + db_model_set_mode (self->model, DB_MODEL_MODE_ON_CHANGE); else - db_model_set_mode (obj->model, DB_MODEL_MODE_ON_DEMAND); + db_model_set_mode (self->model, DB_MODEL_MODE_ON_DEMAND); } /* * Sets the model used as a data source by iterator. */ -static void db_iterator_set_model (DbIterator * obj, DbModel * model) +static void db_iterator_set_model (DbIterator * self, DbModel * model) { if (!model) return; - if (!obj->model) + if (!self->model) { - obj->model = g_object_ref (model); - g_object_connect (obj->model - ,"signal::lines-reordered", db_iterator_on_model_lines_reordered, obj - ,"signal::line-inserted", db_iterator_on_model_line_inserted, obj - ,"signal-after::line-updated", db_iterator_on_model_line_updated_after, obj - ,"signal::line-deleted", db_iterator_on_model_line_deleted, obj - ,"signal-after::line-deleted", db_iterator_on_model_line_deleted_after, obj - ,"signal::status-changed", db_iterator_on_model_status_changed, obj - ,"signal::operations-done", db_iterator_on_model_operations_done, obj + self->model = g_object_ref (model); + g_object_connect (self->model + ,"signal::lines-reordered", db_iterator_on_model_lines_reordered, self + ,"signal::line-inserted", db_iterator_on_model_line_inserted, self + ,"signal-after::line-updated", db_iterator_on_model_line_updated_after, self + ,"signal::line-deleted", db_iterator_on_model_line_deleted, self + ,"signal-after::line-deleted", db_iterator_on_model_line_deleted_after, self + ,"signal::status-changed", db_iterator_on_model_status_changed, self + ,"signal::operations-done", db_iterator_on_model_operations_done, self ,NULL ); - db_iterator_set_model_mode (obj); + db_iterator_set_model_mode (self); db_iterator_on_model_status_changed (model, - db_model_get_status (model), obj); + db_model_get_status (model), self); } else g_warning ("DbIterator: Can't reassign the 'model' property"); @@ -250,9 +243,9 @@ static void db_iterator_set_model (DbIterator * obj, DbModel * model) /* * Check if the iterator has any selected row, otherwise issues a message. */ -static gboolean db_iterator_check_row_selected (DbIterator * obj) +static gboolean db_iterator_check_row_selected (DbIterator * self) { - if (obj->row_selected) + if (self->row_selected) return TRUE; g_warning ("DbIterator: Row not selected"); @@ -263,212 +256,212 @@ static gboolean db_iterator_check_row_selected (DbIterator * obj) /** * db_iterator_get_row: - * @obj: a #DbIterator + * @self: a #DbIterator * * Gets the selected row number. * * Return value: the row number **/ -gint db_iterator_get_row (DbIterator * obj) +gint db_iterator_get_row (DbIterator * self) { - g_return_val_if_fail (DB_IS_ITERATOR (obj), -1); + g_return_val_if_fail (DB_IS_ITERATOR (self), -1); - if (obj->row_selected) - return obj->row; + if (self->row_selected) + return self->row; else return -1; } /** * db_iterator_get_model: - * @obj: a #DbIterator + * @self: a #DbIterator * * Gets the model used as a data source by iterator. * * Return value: (transfer none): the #DbModel **/ -DbModel * db_iterator_get_model (DbIterator * obj) +DbModel * db_iterator_get_model (DbIterator * self) { - g_return_val_if_fail (DB_IS_ITERATOR (obj), NULL); + g_return_val_if_fail (DB_IS_ITERATOR (self), NULL); - return obj->model; + return self->model; } /** * db_iterator_is_ready: - * @obj: a #DbIterator + * @self: a #DbIterator * * Gets if the iterator is ready. * * Return value: %TRUE if the iterator and its model are ready, %FALSE otherwise. **/ -gboolean db_iterator_is_ready (DbIterator * obj) +gboolean db_iterator_is_ready (DbIterator * self) { - g_return_val_if_fail (DB_IS_ITERATOR (obj), FALSE); + g_return_val_if_fail (DB_IS_ITERATOR (self), FALSE); - return IS_READY (obj); + return IS_READY (self); } /** * db_iterator_get_mode: - * @obj: a #DbIterator + * @self: a #DbIterator * * Gets the mode in which the iterator is working. * * Return value: the #DbIteratorMode **/ -DbIteratorMode db_iterator_get_mode (DbIterator * obj) +DbIteratorMode db_iterator_get_mode (DbIterator * self) { - g_return_val_if_fail (DB_IS_ITERATOR (obj), 0); + g_return_val_if_fail (DB_IS_ITERATOR (self), 0); - return obj->mode; + return self->mode; } /** * db_iterator_set_mode: - * @obj: a #DbIterator + * @self: a #DbIterator * @mode: the #DbIteratorMode mode * * Sets the mode in which the iterator should work. **/ -void db_iterator_set_mode (DbIterator * obj, DbIteratorMode mode) +void db_iterator_set_mode (DbIterator * self, DbIteratorMode mode) { - g_return_if_fail (DB_IS_ITERATOR (obj)); + g_return_if_fail (DB_IS_ITERATOR (self)); - obj->mode = mode; + self->mode = mode; - if (obj->model) - db_iterator_set_model_mode (obj); + if (self->model) + db_iterator_set_model_mode (self); } /** * db_iterator_get_iter: - * @obj: a #DbIterator + * @self: a #DbIterator * @iter: (allow-none) (out): return location for selected row iter, or %NULL. * * Gets the currently selected iter. * * Return value: %TRUE if any row is selected, %FALSE otherwise. **/ -gboolean db_iterator_get_iter (DbIterator * obj, DbIter * iter) +gboolean db_iterator_get_iter (DbIterator * self, DbIter * iter) { - g_return_val_if_fail (DB_IS_ITERATOR (obj), FALSE); + g_return_val_if_fail (DB_IS_ITERATOR (self), FALSE); - if (!obj->row_selected) + if (!self->row_selected) return FALSE; - *iter = obj->iter; + *iter = self->iter; return TRUE; } /** * db_iterator_select_iter: - * @obj: a #DbIterator + * @self: a #DbIterator * @iter: a #DbIter * * Adds a new #DbIter to the current selection. */ -void db_iterator_select_iter (DbIterator * obj, DbIter * iter) +void db_iterator_select_iter (DbIterator * self, DbIter * iter) { gint pos; - g_return_if_fail (DB_IS_ITERATOR (obj)); - g_return_if_fail (IS_READY (obj)); + g_return_if_fail (DB_IS_ITERATOR (self)); + g_return_if_fail (IS_READY (self)); if (!iter) return; - if (!obj->selected) - obj->selected = g_hash_table_new_full (g_int_hash, g_int_equal, + if (!self->selected) + self->selected = g_hash_table_new_full (g_int_hash, g_int_equal, NULL, (GDestroyNotify) db_iter_free); - obj->iter = *iter; - obj->row_selected = FALSE; - g_signal_emit (obj, signals[ROW_NUM_CHANGED], 0); - pos = db_model_get_path (obj->model, iter); + self->iter = *iter; + self->row_selected = FALSE; + g_signal_emit (self, signals[ROW_NUM_CHANGED], 0); + pos = db_model_get_path (self->model, iter); - if (!g_hash_table_contains (obj->selected, &pos)) - g_hash_table_insert (obj->selected, &pos, db_iter_copy (iter)); + if (!g_hash_table_contains (self->selected, &pos)) + g_hash_table_insert (self->selected, &pos, db_iter_copy (iter)); } /** * db_iterator_move_iter: - * @obj: a #DbIterator + * @self: a #DbIterator * @iter: a #DbIter * * Moves the iterator cursor to the specified iter, if model is ready. **/ -void db_iterator_move_iter (DbIterator * obj, DbIter * iter) +void db_iterator_move_iter (DbIterator * self, DbIter * iter) { - g_return_if_fail (DB_IS_ITERATOR (obj)); - g_return_if_fail (IS_READY (obj)); - g_return_if_fail (obj->model); + g_return_if_fail (DB_IS_ITERATOR (self)); + g_return_if_fail (IS_READY (self)); + g_return_if_fail (self->model); - if (obj->row_selected && db_iter_compare (&obj->iter, iter)) + if (self->row_selected && db_iter_compare (&self->iter, iter)) return; - if (obj->mode != DB_ITERATOR_MODE_ON_DEMAND) + if (self->mode != DB_ITERATOR_MODE_ON_DEMAND) { - if (db_model_get_row_operations (obj->model, &obj->iter) == DB_MODEL_ROW_OP_INSERT) - db_model_reverse_operations (obj->model); + if (db_model_get_row_operations (self->model, &self->iter) == DB_MODEL_ROW_OP_INSERT) + db_model_reverse_operations (self->model); - db_model_perform_operations (obj->model, FALSE); + db_model_perform_operations (self->model, FALSE); } - db_iterator_set_iter (obj, iter); + db_iterator_set_iter (self, iter); } /** * db_iterator_move_first: - * @obj: a #DbIterator + * @self: a #DbIterator * * Moves the iterator cursor to the first row. **/ -void db_iterator_move_first (DbIterator * obj) +void db_iterator_move_first (DbIterator * self) { DbIter iter; - g_return_if_fail (DB_IS_ITERATOR (obj)); - g_return_if_fail (obj->model); + g_return_if_fail (DB_IS_ITERATOR (self)); + g_return_if_fail (self->model); - if (db_model_get_iter_first (obj->model, &iter)) - db_iterator_move_iter (obj, &iter); + if (db_model_get_iter_first (self->model, &iter)) + db_iterator_move_iter (self, &iter); } /** * db_iterator_move_last: - * @obj: a #DbIterator + * @self: a #DbIterator * * Moves the iterator cursor to the last row. **/ -void db_iterator_move_last (DbIterator * obj) +void db_iterator_move_last (DbIterator * self) { DbIter iter; - g_return_if_fail (DB_IS_ITERATOR (obj)); - g_return_if_fail (obj->model); + g_return_if_fail (DB_IS_ITERATOR (self)); + g_return_if_fail (self->model); - if (db_model_get_last (obj->model, &iter)) - db_iterator_move_iter (obj, &iter); + if (db_model_get_last (self->model, &iter)) + db_iterator_move_iter (self, &iter); } /** * db_iterator_move_previous: - * @obj: a #DbIterator + * @self: a #DbIterator * * Moves the iterator cursor to the previous row, or displays a message if no * exists. If no selected row, attempts to move the cursor to the first row. **/ -void db_iterator_move_previous (DbIterator * obj) +void db_iterator_move_previous (DbIterator * self) { - g_return_if_fail (DB_IS_ITERATOR (obj)); + g_return_if_fail (DB_IS_ITERATOR (self)); - if (obj->row_selected) + if (self->row_selected) { - DbIter iter = obj->iter; + DbIter iter = self->iter; - if (db_model_iter_prev (obj->model, &iter)) - db_iterator_move_iter (obj, &iter); + if (db_model_iter_prev (self->model, &iter)) + db_iterator_move_iter (self, &iter); else g_warning ( "Can't move the cursor to the previous " @@ -476,26 +469,26 @@ void db_iterator_move_previous (DbIterator * obj) ); } else - db_iterator_move_first (obj); + db_iterator_move_first (self); } /** * db_iterator_move_next: - * @obj: a #DbIterator + * @self: a #DbIterator * * Moves the iterator cursor to the next row, or displays a message if no exists. * If no selected row, attempts to move the cursor to the first row. **/ -void db_iterator_move_next (DbIterator * obj) +void db_iterator_move_next (DbIterator * self) { - g_return_if_fail (DB_IS_ITERATOR (obj)); + g_return_if_fail (DB_IS_ITERATOR (self)); - if (obj->row_selected) + if (self->row_selected) { - DbIter iter = obj->iter; + DbIter iter = self->iter; - if (db_model_iter_next (obj->model, &iter)) - db_iterator_move_iter (obj, &iter); + if (db_model_iter_next (self->model, &iter)) + db_iterator_move_iter (self, &iter); else g_warning ( "Can't move the cursor to the next " @@ -503,112 +496,112 @@ void db_iterator_move_next (DbIterator * obj) ); } else - db_iterator_move_first (obj); + db_iterator_move_first (self); } /** * db_iterator_move_to: - * @obj: a #DbIterator + * @self: a #DbIterator * @move: a #DbIteratorMove * * Moves the iterator cursor to the predefined position. **/ -void db_iterator_move_to (DbIterator * obj, DbIteratorMove move) +void db_iterator_move_to (DbIterator * self, DbIteratorMove move) { switch (move) { case DB_ITERATOR_MOVE_FIRST: - db_iterator_move_first (obj); + db_iterator_move_first (self); break; case DB_ITERATOR_MOVE_PREVIOUS: - db_iterator_move_previous (obj); + db_iterator_move_previous (self); break; case DB_ITERATOR_MOVE_NEXT: - db_iterator_move_next (obj); + db_iterator_move_next (self); break; case DB_ITERATOR_MOVE_LAST: - db_iterator_move_last (obj); + db_iterator_move_last (self); break; } } /** * db_iterator_insert: - * @obj: a #DbIterator + * @self: a #DbIterator * * Inserts a new row in the model and moves the iter to it, if inserted. * successfully. **/ -void db_iterator_insert (DbIterator * obj) +void db_iterator_insert (DbIterator * self) { DbIter iter; - g_return_if_fail (DB_IS_ITERATOR (obj)); - g_return_if_fail (obj->model); + g_return_if_fail (DB_IS_ITERATOR (self)); + g_return_if_fail (self->model); - if (obj->mode != DB_ITERATOR_MODE_ON_DEMAND) + if (self->mode != DB_ITERATOR_MODE_ON_DEMAND) { - if (db_model_get_row_operations (obj->model, &obj->iter) == DB_MODEL_ROW_OP_INSERT) + if (db_model_get_row_operations (self->model, &self->iter) == DB_MODEL_ROW_OP_INSERT) return; - db_model_perform_operations (obj->model, FALSE); + db_model_perform_operations (self->model, FALSE); } - if (db_model_insert (obj->model, &iter)) - db_iterator_set_iter (obj, &iter); + if (db_model_insert (self->model, &iter)) + db_iterator_set_iter (self, &iter); } /** * db_iterator_delete: - * @obj: a #DbIterator + * @self: a #DbIterator * * Deletes the currently selected row from the model, if any. **/ -void db_iterator_delete (DbIterator * obj) +void db_iterator_delete (DbIterator * self) { - g_return_if_fail (DB_IS_ITERATOR (obj)); + g_return_if_fail (DB_IS_ITERATOR (self)); - if (obj->row_selected) + if (self->row_selected) { - db_model_delete (obj->model, &obj->iter); + db_model_delete (self->model, &self->iter); - if (obj->mode != DB_ITERATOR_MODE_ON_DEMAND) - db_model_perform_operations (obj->model, FALSE); + if (self->mode != DB_ITERATOR_MODE_ON_DEMAND) + db_model_perform_operations (self->model, FALSE); } - else if (obj->selected) + else if (self->selected) { - GList * l, * list = g_hash_table_get_values (obj->selected); + GList * l, * list = g_hash_table_get_values (self->selected); for (l = list; l; l = l->next) - db_model_delete (obj->model, l->data); + db_model_delete (self->model, l->data); - if (obj->mode != DB_ITERATOR_MODE_ON_DEMAND) - db_model_perform_operations (obj->model, FALSE); + if (self->mode != DB_ITERATOR_MODE_ON_DEMAND) + db_model_perform_operations (self->model, FALSE); - db_iterator_unselect (obj); + db_iterator_unselect (self); } } /** * db_iterator_refresh: - * @obj: a #DbIterator + * @self: a #DbIterator * * Refresh the data of the model handled by iterator. **/ -void db_iterator_refresh (DbIterator * obj) +void db_iterator_refresh (DbIterator * self) { - g_return_if_fail (DB_IS_ITERATOR (obj)); + g_return_if_fail (DB_IS_ITERATOR (self)); - if (obj->model) + if (self->model) { - db_model_refresh (obj->model); - db_iterator_unselect (obj); + db_model_refresh (self->model); + db_iterator_unselect (self); } } /** * db_iterator_get_spec: - * @obj: a #DbIterator + * @self: a #DbIterator * @column: the column index. * * Gets the spec from the model of the specified column index. @@ -616,19 +609,19 @@ void db_iterator_refresh (DbIterator * obj) * Return value: (transfer none) (allow-none): a #GvnParamSpec or %NULL if * can't get it because the model isn't ready. **/ -const GvnParamSpec * db_iterator_get_spec (DbIterator * obj, gint column) +const GvnParamSpec * db_iterator_get_spec (DbIterator * self, gint column) { - g_return_val_if_fail (DB_IS_ITERATOR (obj), NULL); + g_return_val_if_fail (DB_IS_ITERATOR (self), NULL); - if (IS_READY (obj)) - return db_model_get_spec (obj->model, column); + if (IS_READY (self)) + return db_model_get_spec (self->model, column); else return NULL; } /** * db_iterator_get_value: - * @obj: a #DbIterator + * @self: a #DbIterator * @column: the column index. * * Gets the value of the specified column index. @@ -636,19 +629,19 @@ const GvnParamSpec * db_iterator_get_spec (DbIterator * obj, gint column) * Return value: (transfer none) (allow-none): the value or %NULL if * can't get it because the model isn't ready. **/ -const GValue * db_iterator_get_value (DbIterator * obj, gint column) +const GValue * db_iterator_get_value (DbIterator * self, gint column) { - g_return_val_if_fail (DB_IS_ITERATOR (obj), NULL); + g_return_val_if_fail (DB_IS_ITERATOR (self), NULL); - if (obj->row_selected) - return db_model_get_value (obj->model, &obj->iter, column, NULL); + if (self->row_selected) + return db_model_get_value (self->model, &self->iter, column, NULL); return NULL; } /** * db_iterator_get_column_index: - * @obj: a #DbIterator + * @self: a #DbIterator * @name: the name of a column of iterator. * * Retrieves the position in the query of the column called @name. @@ -656,74 +649,78 @@ const GValue * db_iterator_get_value (DbIterator * obj, gint column) * Return value: the position of the column with name @name or -1 if there isn't * a column called name or if name is %NULL. **/ -gint db_iterator_get_column_index (DbIterator * obj, const gchar * name) +gint db_iterator_get_column_index (DbIterator * self, const gchar * name) { - g_return_val_if_fail (DB_IS_ITERATOR (obj), -1); - g_return_val_if_fail (IS_READY (obj), -1); + g_return_val_if_fail (DB_IS_ITERATOR (self), -1); + g_return_val_if_fail (IS_READY (self), -1); - return db_model_get_column_index (obj->model, name); + return db_model_get_column_index (self->model, name); } /** * db_iterator_set_value: - * @obj: a #DbIterator + * @self: a #DbIterator * @column: the column index. * @value: a #GValue with the new value. * @err: (out) (allow-none): the return location for a #GError or %NULL. * * Sets the value of the specified column index. + * + * Return value: %TRUE if the value was changed, %FALSE otherwise **/ -void db_iterator_set_value (DbIterator * obj, gint column, const GValue * value, GError ** err) +gboolean db_iterator_set_value (DbIterator * self, gint column, const GValue * value, GError ** err) { - g_return_if_fail (DB_IS_ITERATOR (obj)); + g_return_val_if_fail (DB_IS_ITERATOR (self), FALSE); - if (db_iterator_check_row_selected (obj)) - db_model_set_value (obj->model, &obj->iter, column, value, err); + if (db_iterator_check_row_selected (self)) + return db_model_set_value (self->model, &self->iter, column, value, err); + + return FALSE; } /** * db_iterator_add_param: - * @obj: a #DbIterator + * @self: a #DbIterator * @param: the param to add. * * Adds a #DbParam to the list of iterator params. **/ -void db_iterator_add_param (DbIterator * obj, DbParam * param) +void db_iterator_add_param (DbIterator * self, DbParam * param) { - g_return_if_fail (DB_IS_ITERATOR (obj)); + g_return_if_fail (DB_IS_ITERATOR (self)); g_return_if_fail (DB_IS_PARAM (param)); - db_param_set_iterator (param, obj); + db_param_set_iterator (param, self); g_object_weak_ref (G_OBJECT (param), - (GWeakNotify) db_iterator_unref_param, obj); - obj->params = g_list_prepend (obj->params, param); + (GWeakNotify) db_iterator_unref_param, self); + self->params = g_list_prepend (self->params, param); } /** * db_iterator_get_param: - * @obj: a #DbIterator + * @self: a #DbIterator * @column: the column name * * Creates a parameter for the specified column index and returns it. * * Return value: (transfer none): a #GvnParam **/ -GvnParam * db_iterator_get_param (DbIterator * obj, const gchar * column) +GvnParam * db_iterator_get_param (DbIterator * self, const gchar * column) { GList * n; GvnParam * param; - g_return_val_if_fail (DB_IS_ITERATOR (obj), NULL); + g_return_val_if_fail (DB_IS_ITERATOR (self), NULL); g_return_val_if_fail (column, NULL); - for (n = obj->params; n; n = n->next) + for (n = self->params; n; n = n->next) if (!g_strcmp0 (db_param_get_column_name (n->data), column)) break; if (!n) { param = db_param_new (column); - db_iterator_add_param (obj, DB_PARAM (param)); + db_iterator_add_param (self, DB_PARAM (param)); } else param = n->data; @@ -733,171 +730,171 @@ GvnParam * db_iterator_get_param (DbIterator * obj, const gchar * column) /** * db_iterator_get_params: - * @obj: a #DbIterator + * @self: a #DbIterator * * Gets a list of params linked with the iterator. The returned list shoud be freed. * * Return value: (element-type Db.Param) (transfer container): the #GList **/ -GList * db_iterator_get_params (DbIterator * obj) +GList * db_iterator_get_params (DbIterator * self) { - g_return_val_if_fail (DB_IS_ITERATOR (obj), NULL); + g_return_val_if_fail (DB_IS_ITERATOR (self), NULL); - return g_list_copy (obj->params); + return g_list_copy (self->params); } /** * db_iterator_bind_param: - * @obj: a #DbIterator + * @self: a #DbIterator * @column: the column index. * @param: the column index. * * Binds the param to the specified column index. If you want to link the same * param several times you should use the db_iterator_get_param function. **/ -void db_iterator_bind_param (DbIterator * obj, const gchar * column, GvnParam * param) +void db_iterator_bind_param (DbIterator * self, const gchar * column, GvnParam * param) { - g_return_if_fail (DB_IS_ITERATOR (obj)); - g_return_if_fail (GVN_IS_PARAM (obj)); + g_return_if_fail (DB_IS_ITERATOR (self)); + g_return_if_fail (GVN_IS_PARAM (self)); gvn_param_set_master (param, - db_iterator_get_param (obj, column) + db_iterator_get_param (self, column) ); } /** * db_iterator_link: - * @obj: a #DbIterator + * @self: a #DbIterator * @field: the field name in the iterator statement * @src: the source #DbIterator * @column: the column number of @src * * Links the iterator with another iterator parameter. **/ -void db_iterator_link (DbIterator * obj, const gchar * field, DbIterator * src, const gchar * column) +void db_iterator_link (DbIterator * self, const gchar * field, DbIterator * src, const gchar * column) { - g_return_if_fail (DB_IS_ITERATOR (obj)); + g_return_if_fail (DB_IS_ITERATOR (self)); g_return_if_fail (DB_IS_ITERATOR (src)); g_return_if_fail (field); - db_iterator_link_with_param (obj, field, + db_iterator_link_with_param (self, field, db_iterator_get_param (src, column)); } /** * db_iterator_link_with_param: - * @obj: a #DbIterator + * @self: a #DbIterator * @field: the field name in the iterator statement * @param: the #GvnParam * * Links the iterator with a parameter. **/ -void db_iterator_link_with_param (DbIterator * obj, const gchar * field, GvnParam * param) +void db_iterator_link_with_param (DbIterator * self, const gchar * field, GvnParam * param) { - g_return_if_fail (DB_IS_ITERATOR (obj)); + g_return_if_fail (DB_IS_ITERATOR (self)); g_return_if_fail (GVN_IS_PARAM (param)); - g_return_if_fail (obj->model); + g_return_if_fail (self->model); g_return_if_fail (field); - db_model_set_default_value_from_param (obj->model, field, param, TRUE); + db_model_set_default_value_from_param (self->model, field, param, TRUE); } /** * db_iterator_get_nrows: - * @obj: a #DbIterator + * @self: a #DbIterator * * Gets the number of rows in the model pointed by the iterator. * * Return value: the number of rows **/ -gint db_iterator_get_nrows (DbIterator * obj) +gint db_iterator_get_nrows (DbIterator * self) { - g_return_val_if_fail (DB_IS_ITERATOR (obj), 0); + g_return_val_if_fail (DB_IS_ITERATOR (self), 0); - if (obj->model) - return db_model_get_nrows (obj->model); + if (self->model) + return db_model_get_nrows (self->model); return 0; } /** * db_iterator_get_update_flags: - * @obj: a #DbIterator + * @self: a #DbIterator * * Gets the flags that indicate how a model can be modified. * * Return value: the flags **/ -DbModelUpdateFlags db_iterator_get_update_flags (DbIterator * obj) +DbModelUpdateFlags db_iterator_get_update_flags (DbIterator * self) { - g_return_val_if_fail (DB_IS_ITERATOR (obj), 0); + g_return_val_if_fail (DB_IS_ITERATOR (self), 0); - if (obj->model) - return db_model_get_update_flags (obj->model); + if (self->model) + return db_model_get_update_flags (self->model); return 0; } /** * db_iterator_perform_operations: - * @obj: a #DbIterator + * @self: a #DbIterator * * Performs all pending operations on the model. **/ -void db_iterator_perform_operations (DbIterator * obj) +void db_iterator_perform_operations (DbIterator * self) { - g_return_if_fail (DB_IS_ITERATOR (obj)); + g_return_if_fail (DB_IS_ITERATOR (self)); - if (obj->model) - db_model_perform_operations (obj->model, FALSE); + if (self->model) + db_model_perform_operations (self->model, FALSE); } /** * db_iterator_reverse_operations: - * @obj: a #DbIterator + * @self: a #DbIterator * * Reverses all pending operations on the model. **/ -void db_iterator_reverse_operations (DbIterator * obj) +void db_iterator_reverse_operations (DbIterator * self) { - g_return_if_fail (DB_IS_ITERATOR (obj)); + g_return_if_fail (DB_IS_ITERATOR (self)); - if (obj->model) - db_model_reverse_operations (obj->model); + if (self->model) + db_model_reverse_operations (self->model); } /** * db_iterator_get_pending_operations: - * @obj: a #DbIterator + * @self: a #DbIterator * * Gets pending operations to perform in the current row. * * Return value: the pending operations **/ -DbModelRowOp db_iterator_get_pending_operations (DbIterator * obj) +DbModelRowOp db_iterator_get_pending_operations (DbIterator * self) { - g_return_val_if_fail (DB_IS_ITERATOR (obj), 0); + g_return_val_if_fail (DB_IS_ITERATOR (self), 0); - if (obj->model && (obj->row_selected || obj->selected)) - return db_model_get_row_operations (obj->model, &obj->iter); + if (self->model && (self->row_selected || self->selected)) + return db_model_get_row_operations (self->model, &self->iter); return 0; } /** * db_iterator_has_pending_operations: - * @obj: a #DbIterator + * @self: a #DbIterator * * Checks for pending operations to perform. * * Return value: %TRUE if there are pending operations, %FALSE otherwise **/ -gboolean db_iterator_has_pending_operations (DbIterator * obj) +gboolean db_iterator_has_pending_operations (DbIterator * self) { - g_return_val_if_fail (DB_IS_ITERATOR (obj), FALSE); + g_return_val_if_fail (DB_IS_ITERATOR (self), FALSE); - if (obj->model) - return db_model_has_pending_operations (obj->model); + if (self->model) + return db_model_has_pending_operations (self->model); return FALSE; } @@ -911,84 +908,84 @@ enum ,PROP_REMEMBER_SELECTION }; -static void db_iterator_set_property (DbIterator * obj, guint id, +static void db_iterator_set_property (DbIterator * self, guint id, const GValue * value, GParamSpec * pspec) { switch (id) { case PROP_MODEL: - db_iterator_set_model (obj, g_value_get_object (value)); + db_iterator_set_model (self, g_value_get_object (value)); break; case PROP_MODE: - db_iterator_set_mode (obj, g_value_get_enum (value)); + db_iterator_set_mode (self, g_value_get_enum (value)); break; case PROP_REMEMBER_SELECTION: - obj->remember_selection = g_value_get_boolean (value); - db_iterator_row_num_changed (obj); + self->remember_selection = g_value_get_boolean (value); + db_iterator_row_num_changed (self); break; default: - G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, id, pspec); + G_OBJECT_WARN_INVALID_PROPERTY_ID (self, id, pspec); } } -static void db_iterator_get_property (DbIterator * obj, guint id, +static void db_iterator_get_property (DbIterator * 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_MODE: - g_value_set_enum (value, obj->mode); + g_value_set_enum (value, self->mode); break; case PROP_REMEMBER_SELECTION: - g_value_set_boolean (value, obj->remember_selection); + g_value_set_boolean (value, self->remember_selection); break; default: - G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, id, pspec); + G_OBJECT_WARN_INVALID_PROPERTY_ID (self, id, pspec); } } //+++++++++++++++++++++++++++++++++++++++++++++++++++ Class -static void db_iterator_init (DbIterator * obj) +static void db_iterator_init (DbIterator * self) { - obj->model = NULL; - obj->params = NULL; - obj->row = 0; - obj->row_selected = FALSE; - obj->selected = NULL; + self->model = NULL; + self->params = NULL; + self->row = 0; + self->row_selected = FALSE; + self->selected = NULL; } -static void db_iterator_finalize (DbIterator * obj) +static void db_iterator_finalize (DbIterator * self) { GList * n; - for (n = obj->params; n; n = n->next) + for (n = self->params; n; n = n->next) g_object_weak_unref (n->data, - (GWeakNotify) db_iterator_unref_param, obj); + (GWeakNotify) db_iterator_unref_param, self); - g_list_free (obj->params); + g_list_free (self->params); - db_iterator_unselect (obj); + db_iterator_unselect (self); - if (obj->model) + if (self->model) { - g_object_disconnect (obj->model - ,"any_signal", db_iterator_on_model_line_inserted, obj - ,"any_signal", db_iterator_on_model_line_updated_after, obj - ,"any_signal", db_iterator_on_model_line_deleted, obj - ,"any_signal", db_iterator_on_model_line_deleted_after, obj - ,"any_signal", db_iterator_on_model_lines_reordered, obj - ,"any_signal", db_iterator_on_model_status_changed, obj - ,"any_signal", db_iterator_on_model_operations_done, obj + g_object_disconnect (self->model + ,"any_signal", db_iterator_on_model_line_inserted, self + ,"any_signal", db_iterator_on_model_line_updated_after, self + ,"any_signal", db_iterator_on_model_line_deleted, self + ,"any_signal", db_iterator_on_model_line_deleted_after, self + ,"any_signal", db_iterator_on_model_lines_reordered, self + ,"any_signal", db_iterator_on_model_status_changed, self + ,"any_signal", db_iterator_on_model_operations_done, self ,NULL ); - g_object_unref (obj->model); + g_object_unref (self->model); } - G_OBJECT_CLASS (db_iterator_parent_class)->finalize (G_OBJECT (obj)); + G_OBJECT_CLASS (db_iterator_parent_class)->finalize (G_OBJECT (self)); } static void db_iterator_class_init (DbIteratorClass * klass) diff --git a/db/db-iterator.h b/db/db-iterator.h index e2ce309..b5be454 100644 --- a/db/db-iterator.h +++ b/db/db-iterator.h @@ -21,11 +21,11 @@ #include "db-model.h" #define DB_TYPE_ITERATOR (db_iterator_get_type ()) -#define DB_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST (obj, DB_TYPE_ITERATOR, DbIterator)) -#define DB_IS_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE (obj, DB_TYPE_ITERATOR)) +#define DB_ITERATOR(self) (G_TYPE_CHECK_INSTANCE_CAST (self, DB_TYPE_ITERATOR, DbIterator)) +#define DB_IS_ITERATOR(self) (G_TYPE_CHECK_INSTANCE_TYPE (self, DB_TYPE_ITERATOR)) #define DB_ITERATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST (klass, DB_TYPE_ITERATOR, DbIteratorClass)) #define DB_IS_ITERATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE (klass, DB_TYPE_ITERATOR)) -#define DB_ITERATOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS (obj, DB_TYPE_ITERATOR, DbIteratorClass)) +#define DB_ITERATOR_GET_CLASS(self) (G_TYPE_INSTANCE_GET_CLASS (self, DB_TYPE_ITERATOR, DbIteratorClass)) #define DB_TYPE_ITERATOR_MODE (db_iterator_mode_get_type ()) @@ -94,36 +94,36 @@ GType db_iterator_get_type (); GType db_iterator_mode_get_type () G_GNUC_CONST; DbIterator * db_iterator_new (DbModel * model); -gboolean db_iterator_is_ready (DbIterator * obj); -DbIteratorMode db_iterator_get_mode (DbIterator * obj); -void db_iterator_set_mode (DbIterator * obj, DbIteratorMode mode); -gint db_iterator_get_row (DbIterator * obj); -gboolean db_iterator_get_iter (DbIterator * obj, DbIter * iter); -void db_iterator_select_iter (DbIterator * obj, DbIter * iter); -void db_iterator_move_iter (DbIterator * obj, DbIter * iter); -void db_iterator_move_first (DbIterator * obj); -void db_iterator_move_last (DbIterator * obj); -void db_iterator_move_previous (DbIterator * obj); -void db_iterator_move_next (DbIterator * obj); -void db_iterator_move_to (DbIterator * obj, DbIteratorMove move); -void db_iterator_refresh (DbIterator * obj); -const GvnParamSpec * db_iterator_get_spec (DbIterator * obj, gint column); -const GValue * db_iterator_get_value (DbIterator * obj, gint column); -gint db_iterator_get_column_index (DbIterator * obj, const gchar * name); -void db_iterator_set_value (DbIterator * obj, gint column, const GValue * value, GError ** err); -void db_iterator_delete (DbIterator * obj); -void db_iterator_insert (DbIterator * obj); -void db_iterator_add_param (DbIterator * obj, DbParam * param); -GvnParam * db_iterator_get_param (DbIterator * obj, const gchar * column); -GList * db_iterator_get_params (DbIterator * obj); -void db_iterator_bind_param (DbIterator * obj, const gchar * column, GvnParam * param); -void db_iterator_link (DbIterator * obj, const gchar * field, DbIterator * src, const gchar * column); -void db_iterator_link_with_param (DbIterator * obj, const gchar * field, GvnParam * param); -gint db_iterator_get_nrows (DbIterator * obj); -DbModelUpdateFlags db_iterator_get_update_flags (DbIterator * obj); -void db_iterator_reverse_operations (DbIterator * obj); -void db_iterator_perform_operations (DbIterator * obj); -DbModelRowOp db_iterator_get_pending_operations (DbIterator * obj); -gboolean db_iterator_has_pending_operations (DbIterator * obj); +gboolean db_iterator_is_ready (DbIterator * self); +DbIteratorMode db_iterator_get_mode (DbIterator * self); +void db_iterator_set_mode (DbIterator * self, DbIteratorMode mode); +gint db_iterator_get_row (DbIterator * self); +gboolean db_iterator_get_iter (DbIterator * self, DbIter * iter); +void db_iterator_select_iter (DbIterator * self, DbIter * iter); +void db_iterator_move_iter (DbIterator * self, DbIter * iter); +void db_iterator_move_first (DbIterator * self); +void db_iterator_move_last (DbIterator * self); +void db_iterator_move_previous (DbIterator * self); +void db_iterator_move_next (DbIterator * self); +void db_iterator_move_to (DbIterator * self, DbIteratorMove move); +void db_iterator_refresh (DbIterator * self); +const GvnParamSpec * db_iterator_get_spec (DbIterator * self, gint column); +const GValue * db_iterator_get_value (DbIterator * self, gint column); +gint db_iterator_get_column_index (DbIterator * self, const gchar * name); +gboolean db_iterator_set_value (DbIterator * self, gint column, const GValue * value, GError ** err); +void db_iterator_delete (DbIterator * self); +void db_iterator_insert (DbIterator * self); +void db_iterator_add_param (DbIterator * self, DbParam * param); +GvnParam * db_iterator_get_param (DbIterator * self, const gchar * column); +GList * db_iterator_get_params (DbIterator * self); +void db_iterator_bind_param (DbIterator * self, const gchar * column, GvnParam * param); +void db_iterator_link (DbIterator * self, const gchar * field, DbIterator * src, const gchar * column); +void db_iterator_link_with_param (DbIterator * self, const gchar * field, GvnParam * param); +gint db_iterator_get_nrows (DbIterator * self); +DbModelUpdateFlags db_iterator_get_update_flags (DbIterator * self); +void db_iterator_reverse_operations (DbIterator * self); +void db_iterator_perform_operations (DbIterator * self); +DbModelRowOp db_iterator_get_pending_operations (DbIterator * self); +gboolean db_iterator_has_pending_operations (DbIterator * self); #endif \ No newline at end of file diff --git a/db/db-model-holder.c b/db/db-model-holder.c index 6cdaed0..f4a3c2a 100644 --- a/db/db-model-holder.c +++ b/db/db-model-holder.c @@ -33,33 +33,33 @@ G_DEFINE_INTERFACE (DbModelHolder, db_model_holder, G_TYPE_INVALID); /** * db_model_holder_get_model: - * @obj: a #DbModelHolder + * @self: a #DbModelHolder * * Gets the model used by holder. * * Return value:(transfer none): the #DbModel **/ -DbModel * db_model_holder_get_model (DbModelHolder * obj) +DbModel * db_model_holder_get_model (DbModelHolder * self) { - g_return_val_if_fail (DB_IS_MODEL_HOLDER (obj), NULL); + g_return_val_if_fail (DB_IS_MODEL_HOLDER (self), NULL); - return DB_MODEL_HOLDER_GET_INTERFACE (obj)->get_model (obj); + return DB_MODEL_HOLDER_GET_INTERFACE (self)->get_model (self); } /** * db_model_holder_set_model: - * @obj: a #DbModelHolder + * @self: a #DbModelHolder * @model:(allow-none): the #DbModel * * Sets the model used by holder. If @model is NULL, then it will unset the * model. **/ -void db_model_holder_set_model (DbModelHolder * obj, DbModel * model) +void db_model_holder_set_model (DbModelHolder * self, DbModel * model) { - g_return_if_fail (DB_IS_MODEL_HOLDER (obj)); - g_return_if_fail (DB_IS_MODEL (obj)); + g_return_if_fail (DB_IS_MODEL_HOLDER (self)); + g_return_if_fail (DB_IS_MODEL (self)); - DB_MODEL_HOLDER_GET_INTERFACE (obj)->set_model (obj, model); + DB_MODEL_HOLDER_GET_INTERFACE (self)->set_model (self, model); } //+++++++++++++++++++++++++++++++++++++++++++++++++++ Class diff --git a/db/db-model-holder.h b/db/db-model-holder.h index 60e32cc..7a8e158 100644 --- a/db/db-model-holder.h +++ b/db/db-model-holder.h @@ -21,15 +21,15 @@ #include "db-model.h" #define DB_TYPE_MODEL_HOLDER (db_model_holder_get_type ()) -#define DB_MODEL_HOLDER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), DB_TYPE_MODEL_HOLDER, DbModelHolder)) -#define DB_IS_MODEL_HOLDER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), DB_TYPE_MODEL_HOLDER)) -#define DB_MODEL_HOLDER_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), DB_TYPE_MODEL_HOLDER, DbModelHolderInterface)) +#define DB_MODEL_HOLDER(self) (G_TYPE_CHECK_INSTANCE_CAST ((self), DB_TYPE_MODEL_HOLDER, DbModelHolder)) +#define DB_IS_MODEL_HOLDER(self) (G_TYPE_CHECK_INSTANCE_TYPE ((self), DB_TYPE_MODEL_HOLDER)) +#define DB_MODEL_HOLDER_GET_INTERFACE(self) (G_TYPE_INSTANCE_GET_INTERFACE ((self), DB_TYPE_MODEL_HOLDER, DbModelHolderInterface)) typedef struct _DbModelHolder DbModelHolder; typedef struct _DbModelHolderInterface DbModelHolderInterface; -typedef DbModel * (* DbModelHolderGetModelFunc) (DbModelHolder * obj); -typedef void (* DbModelHolderSetModelFunc) (DbModelHolder * obj, DbModel * model); +typedef DbModel * (* DbModelHolderGetModelFunc) (DbModelHolder * self); +typedef void (* DbModelHolderSetModelFunc) (DbModelHolder * self, DbModel * model); struct _DbModelHolder; @@ -42,7 +42,7 @@ struct _DbModelHolderInterface }; GType db_model_holder_get_type (); -DbModel * db_model_holder_get_model (DbModelHolder * obj); -void db_model_holder_set_model (DbModelHolder * obj, DbModel * model); +DbModel * db_model_holder_get_model (DbModelHolder * self); +void db_model_holder_set_model (DbModelHolder * self, DbModel * model); #endif diff --git a/db/db-model.c b/db/db-model.c index 3eee29e..3ed580d 100644 --- a/db/db-model.c +++ b/db/db-model.c @@ -1353,6 +1353,20 @@ DbModelStatus db_model_get_status (DbModel * self) return self->priv->status; } +/** + * db_model_is_ready: + * @self: a #DbModel + * + * Checks if the model is ready. + * + * Return value: %TRUE if the model is ready, %FALSE otherwise + **/ +gboolean db_model_is_ready (DbModel * self) +{ + g_return_val_if_fail (DB_IS_MODEL (self), FALSE); + return self->priv->status == DB_MODEL_STATUS_READY; +} + /** * db_model_get_mode: * @self: a #DbModel diff --git a/db/db-model.h b/db/db-model.h index dbcbd0f..204392b 100644 --- a/db/db-model.h +++ b/db/db-model.h @@ -196,6 +196,7 @@ void db_model_set_stmt (DbModel * self, SqlStmt * stmt); void db_model_add_pre_stmt (DbModel * self, SqlStmt * stmt); void db_model_add_post_stmt (DbModel * self, SqlStmt * stmt); DbModelStatus db_model_get_status (DbModel * self); +gboolean db_model_is_ready (DbModel * self); const gchar * db_model_get_main_table (DbModel * self); DbModelUpdateFlags db_model_get_update_flags (DbModel * self); void db_model_request_update_flags (DbModel * self diff --git a/db/db-param.c b/db/db-param.c index e5abdba..8c87888 100644 --- a/db/db-param.c +++ b/db/db-param.c @@ -17,6 +17,9 @@ #include "db-param.h" +static void db_param_param_init (GvnParamInterface * iface); +static void db_param_on_master_value_changed (GvnParam * master, const GValue * value, DbParam * self); + /** * SECTION: db-param * @Short_description: representation of the value of a field @@ -24,8 +27,10 @@ * * This class represents the value of a field in a #DbIterator. **/ - -G_DEFINE_TYPE (DbParam, db_param, GVN_TYPE_PARAM); +G_DEFINE_TYPE_WITH_CODE (DbParam, db_param, G_TYPE_OBJECT, + G_IMPLEMENT_INTERFACE (GVN_TYPE_PARAM, + db_param_param_init) +); /** * db_param_new: @@ -33,7 +38,7 @@ G_DEFINE_TYPE (DbParam, db_param, GVN_TYPE_PARAM); * * Creates a new #DbParam. * - * Return value: the new #DbParam + * Return value: (transfer full): the new #DbParam **/ GvnParam * db_param_new (const gchar * column_name) { @@ -46,7 +51,7 @@ GvnParam * db_param_new (const gchar * column_name) * * Creates a new #DbParam. * - * Return value: the new #DbParam + * Return value: (transfer full): the new #DbParam **/ GvnParam * db_param_new_with_index (guint column_index) { @@ -55,212 +60,284 @@ GvnParam * db_param_new_with_index (guint column_index) //+++++++++++++++++++++++++++++++++++++++++++++++++++ Private -static void db_param_on_value_changed (DbParam * obj, const GValue * value, gpointer data) +static void db_param_put_value (DbParam * self, const GValue * value) { - db_iterator_set_value (obj->iterator, obj->column_index, value, NULL); -} + if (!gvn_value_ccopy (value, self->value)) + return; -static void db_param_on_iterator_status_changed (DbIterator * iterator, gboolean ready, DbParam * obj) -{ - GvnParamClass * klass = GVN_PARAM_GET_CLASS (obj); + g_signal_emit_by_name (self, "value-changed", value); - if (ready) + if (self->master && self->change_master) { - if (obj->column_name) - obj->column_index = db_iterator_get_column_index (obj->iterator, obj->column_name); - - klass->set_spec (GVN_PARAM (obj), - db_iterator_get_spec (obj->iterator, obj->column_index)); + self->change_master = FALSE; + gvn_param_request_value (self->master, value, NULL); + self->change_master = TRUE; } } -static void db_param_on_iterator_iter_changed (DbIterator * iterator, DbParam * obj) +static const GValue * db_param_get_value (DbParam * self) { - const GValue * value; - GvnParamClass * klass = GVN_PARAM_GET_CLASS (obj); + return self->value; +} - if (db_iterator_get_row (obj->iterator) != -1 && obj->column_index != -1) +static gboolean db_param_request_value (DbParam * self, const GValue * value, GError ** err) +{ + return db_iterator_set_value (self->iterator, self->column_index, value, err); +} + +static void db_param_on_master_value_changed (GvnParam * master, const GValue * value, DbParam * self) +{ + if (self->change_master) { - klass->set_status (GVN_PARAM (obj), GVN_PARAM_STATUS_OK); - value = db_iterator_get_value (obj->iterator, obj->column_index); + self->change_master = FALSE; + gvn_param_set_value (GVN_PARAM (self), value); + self->change_master = TRUE; + } +} + +static GvnParam * db_param_get_master (DbParam * self) +{ + return self->master; +} + +static void db_param_set_master (DbParam * self, GvnParam * master) +{ + if (self->master) + { + g_signal_handlers_disconnect_by_func (self->master, + db_param_on_master_value_changed, self); + g_clear_object (&self->master); + } + if (master) + { + self->master = g_object_ref_sink (master); + g_signal_connect (master, "value-changed", + G_CALLBACK (db_param_on_master_value_changed), self); + db_param_on_master_value_changed (master, + gvn_param_get_value (master), self); + } +} + +static const GvnParamSpec * db_param_get_spec (DbParam * self) +{ + if (self->column_index != -1) + return db_iterator_get_spec (self->iterator, self->column_index); + + return NULL; +} + +static GvnParamStatus db_param_get_status (DbParam * self) +{ + if (db_iterator_get_row (self->iterator) != -1 && self->column_index != -1) + return GVN_PARAM_STATUS_OK; + + return GVN_PARAM_STATUS_BUSY; +} + +static void db_param_on_iterator_status_changed (DbIterator * iterator, gboolean ready, DbParam * self) +{ + if (ready && self->column_name) + self->column_index = db_iterator_get_column_index (self->iterator, self->column_name); + + g_signal_emit_by_name (self, "spec-changed"); +} + +static void db_param_on_iterator_iter_changed (DbIterator * iterator, DbParam * self) +{ + g_signal_emit_by_name (self, "status-changed"); + + if (db_iterator_get_row (self->iterator) != -1 && self->column_index != -1) + { + const GValue * value = db_iterator_get_value (self->iterator, self->column_index); + db_param_put_value (self, value); } else - { - klass->set_status (GVN_PARAM (obj), GVN_PARAM_STATUS_BUSY); - value = NULL; - } - - g_signal_handlers_block_by_func (obj, db_param_on_value_changed, NULL); - - if (!value) { GValue tmp_value = G_VALUE_INIT; g_value_init (&tmp_value, GVN_TYPE_NULL); - klass->put_value (GVN_PARAM (obj), &tmp_value); + db_param_put_value (self, &tmp_value); g_value_unset (&tmp_value); } - else - klass->put_value (GVN_PARAM (obj), value); - - g_signal_handlers_unblock_by_func (obj, db_param_on_value_changed, NULL); } //+++++++++++++++++++++++++++++++++++++++++++++++++++ Public /** * db_param_get_column_index: - * @obj: a #DbParam + * @self: a #DbParam * * Gets the iterator column referenced by the param. * * Return value: the column index. **/ -guint db_param_get_column_index (DbParam * obj) +guint db_param_get_column_index (DbParam * self) { - g_return_val_if_fail (DB_IS_PARAM (obj), 0); + g_return_val_if_fail (DB_IS_PARAM (self), 0); - return obj->column_index; + return self->column_index; } /** * db_param_get_column_name: - * @obj: a #DbParam + * @self: a #DbParam * * Gets the iterator column referenced by the param. * * Return value: the column name. **/ -const gchar * db_param_get_column_name (DbParam * obj) +const gchar * db_param_get_column_name (DbParam * self) { - g_return_val_if_fail (DB_IS_PARAM (obj), 0); + g_return_val_if_fail (DB_IS_PARAM (self), 0); - return obj->column_name; + return self->column_name; } /** * db_param_set_iterator: - * @obj: a #DbParam + * @self: a #DbParam * @iterator: the #DbIterator * * Sets the iterator that updates the param value, this property can be set if * the parameter does not have a iterator associated yet. **/ -void db_param_set_iterator (DbParam * obj, DbIterator * iterator) +void db_param_set_iterator (DbParam * self, DbIterator * iterator) { - g_return_if_fail (DB_IS_PARAM (obj)); + g_return_if_fail (DB_IS_PARAM (self)); g_return_if_fail (DB_IS_ITERATOR (iterator)); - g_return_if_fail (!obj->iterator); + g_return_if_fail (!self->iterator); - obj->iterator = g_object_ref (iterator); + self->iterator = g_object_ref (iterator); g_object_connect (iterator - ,"signal::iter-changed", db_param_on_iterator_iter_changed, obj - ,"signal::status-changed", db_param_on_iterator_status_changed, obj + ,"signal::iter-changed", db_param_on_iterator_iter_changed, self + ,"signal::status-changed", db_param_on_iterator_status_changed, self ,NULL ); - db_param_on_iterator_status_changed (obj->iterator, - db_iterator_is_ready (iterator), obj); - db_param_on_iterator_iter_changed (obj->iterator, obj); + db_param_on_iterator_status_changed (self->iterator, + db_iterator_is_ready (iterator), self); + db_param_on_iterator_iter_changed (self->iterator, self); } //+++++++++++++++++++++++++++++++++++++++++++++++++++ Properties enum { - PROP_ITERATOR = 1 + PROP_VALUE = 1 + ,PROP_MASTER + ,PROP_ITERATOR ,PROP_COLUMN_INDEX ,PROP_COLUMN_NAME }; -static void db_param_set_property (DbParam * obj, guint property_id, +static void db_param_set_property (DbParam * self, guint property_id, const GValue * value, GParamSpec * pspec) { switch (property_id) { + case PROP_VALUE: + db_param_request_value (self, g_value_get_boxed (value), NULL); + break; + case PROP_MASTER: + db_param_set_master (self, g_value_get_object (value)); + break; case PROP_ITERATOR: - db_param_set_iterator (obj, g_value_get_object (value)); + db_param_set_iterator (self, g_value_get_object (value)); break; case PROP_COLUMN_INDEX: - obj->column_index = g_value_get_int (value); + self->column_index = g_value_get_int (value); break; case PROP_COLUMN_NAME: - g_free (obj->column_name); - obj->column_name = g_value_dup_string (value); + g_free (self->column_name); + self->column_name = g_value_dup_string (value); break; default: - G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, property_id, pspec); + G_OBJECT_WARN_INVALID_PROPERTY_ID (self, property_id, pspec); } } -static void db_param_get_property (DbParam * obj, guint property_id, +static void db_param_get_property (DbParam * self, guint property_id, GValue * value, GParamSpec * pspec) { switch (property_id) { + case PROP_VALUE: + g_value_set_boxed (value, self->value); + break; + case PROP_MASTER: + g_value_set_object (value, self->master); + break; case PROP_ITERATOR: - g_value_set_object (value, obj->iterator); + g_value_set_object (value, self->iterator); break; case PROP_COLUMN_INDEX: - g_value_set_int (value, obj->column_index); + g_value_set_int (value, self->column_index); break; case PROP_COLUMN_NAME: - g_value_set_string (value, obj->column_name); + g_value_set_string (value, self->column_name); break; default: - G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, property_id, pspec); + G_OBJECT_WARN_INVALID_PROPERTY_ID (self, property_id, pspec); } } //+++++++++++++++++++++++++++++++++++++++++++++++++++ Class -static void db_param_init (DbParam * obj) +static void db_param_init (DbParam * self) { - obj->column_index = -1; - obj->column_name = NULL; - obj->iterator = NULL; - g_signal_connect (obj, "value-changed", - G_CALLBACK (db_param_on_value_changed), NULL); + self->master = NULL; + self->change_master = TRUE; + self->column_index = -1; + self->column_name = NULL; + self->iterator = NULL; + + self->value = g_new0 (GValue, 1); + g_value_init (self->value, GVN_TYPE_NULL); } -static void db_param_finalize (DbParam * obj) +static void db_param_finalize (DbParam * self) { - if (obj->iterator) + db_param_set_master (self, NULL); + + if (self->iterator) { - g_object_disconnect (obj->iterator - ,"any_signal", db_param_on_iterator_iter_changed, obj - ,"any_signal", db_param_on_iterator_status_changed, obj + g_object_disconnect (self->iterator + ,"any_signal", db_param_on_iterator_iter_changed, self + ,"any_signal", db_param_on_iterator_status_changed, self ,NULL ); - g_clear_object (&obj->iterator); + g_clear_object (&self->iterator); } - g_signal_handlers_disconnect_by_func (obj, - db_param_on_value_changed, NULL); - g_free (obj->column_name); - G_OBJECT_CLASS (db_param_parent_class)->finalize (G_OBJECT (obj)); + g_value_unset (self->value); + g_free (self->value); + g_free (self->column_name); + G_OBJECT_CLASS (db_param_parent_class)->finalize (G_OBJECT (self)); } -static void db_param_class_init (DbParamClass * k) +static void db_param_class_init (DbParamClass * klass) { - GObjectClass * klass = G_OBJECT_CLASS (k); - klass->finalize = (GObjectFinalizeFunc) db_param_finalize; - klass->set_property = (GObjectSetPropertyFunc) db_param_set_property; - klass->get_property = (GObjectGetPropertyFunc) db_param_get_property; + GObjectClass * k = G_OBJECT_CLASS (klass); + k->finalize = (GObjectFinalizeFunc) db_param_finalize; + k->set_property = (GObjectSetPropertyFunc) db_param_set_property; + k->get_property = (GObjectGetPropertyFunc) db_param_get_property; - g_object_class_install_property (klass, PROP_ITERATOR, + g_object_class_override_property (k, PROP_VALUE, "value"); + g_object_class_override_property (k, PROP_MASTER, "master"); + + g_object_class_install_property (k, PROP_ITERATOR, g_param_spec_object ("iterator" ,_("Iterator") ,_("The iterator owner of param") ,DB_TYPE_ITERATOR ,G_PARAM_READWRITE )); - g_object_class_install_property (klass, PROP_COLUMN_INDEX, + g_object_class_install_property (k, PROP_COLUMN_INDEX, g_param_spec_int ("column-index" ,_("Column index") ,_("The referenced column index") - ,-1 ,1024 ,-1 + ,-1 ,G_MAXINT ,-1 ,G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE )); - g_object_class_install_property (klass, PROP_COLUMN_NAME, + g_object_class_install_property (k, PROP_COLUMN_NAME, g_param_spec_string ("column-name" ,_("Column name") ,_("The referenced column name") @@ -268,3 +345,13 @@ static void db_param_class_init (DbParamClass * k) ,G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE )); } + +static void db_param_param_init (GvnParamInterface * iface) +{ + iface->get_value = (GvnParamGetValueFunc) db_param_get_value; + iface->request_value = (GvnParamRequestValueFunc) db_param_request_value; + iface->get_master = (GvnParamGetMasterFunc) db_param_get_master; + iface->set_master = (GvnParamSetMasterFunc) db_param_set_master; + iface->get_spec = (GvnParamGetSpecFunc) db_param_get_spec; + iface->get_status = (GvnParamGetStatusFunc) db_param_get_status; +} diff --git a/db/db-param.h b/db/db-param.h index a3cb575..4b7b109 100644 --- a/db/db-param.h +++ b/db/db-param.h @@ -21,11 +21,11 @@ #include #define DB_TYPE_PARAM (db_param_get_type ()) -#define DB_PARAM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), DB_TYPE_PARAM, DbParam)) -#define DB_IS_PARAM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), DB_TYPE_PARAM)) -#define DB_PARAM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), DB_TYPE_PARAM, DbParamClass)) -#define DB_IS_PARAM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), DB_TYPE_PARAM)) -#define DB_PARAM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), DB_TYPE_PARAM, DbParamClass)) +#define DB_PARAM(self) (G_TYPE_CHECK_INSTANCE_CAST (self, DB_TYPE_PARAM, DbParam)) +#define DB_IS_PARAM(self) (G_TYPE_CHECK_INSTANCE_TYPE (self, DB_TYPE_PARAM)) +#define DB_PARAM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST (klass, DB_TYPE_PARAM, DbParamClass)) +#define DB_IS_PARAM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE (klass, DB_TYPE_PARAM)) +#define DB_PARAM_GET_CLASS(self) (G_TYPE_INSTANCE_GET_CLASS (self, DB_TYPE_PARAM, DbParamClass)) typedef struct _DbParam DbParam; typedef struct _DbParamClass DbParamClass; @@ -34,23 +34,26 @@ typedef struct _DbParamClass DbParamClass; struct _DbParam { - GvnParam parent; + GObject parent; DbIterator * iterator; gint column_index; gchar * column_name; + GValue * value; + GvnParam * master; + gboolean change_master; }; struct _DbParamClass { /* */ - GvnParamClass parent; + GObjectClass parent; }; GType db_param_get_type (); GvnParam * db_param_new (const gchar * column_name); GvnParam * db_param_new_with_index (guint column_index); -guint db_param_get_column_index (DbParam * obj); -const gchar * db_param_get_column_name (DbParam * obj); -void db_param_set_iterator (DbParam * obj, DbIterator * iterator); +guint db_param_get_column_index (DbParam * self); +const gchar * db_param_get_column_name (DbParam * self); +void db_param_set_iterator (DbParam * self, DbIterator * iterator); #endif \ No newline at end of file diff --git a/gvn/gvn-param.c b/gvn/gvn-param.c index 94e92fd..7c92399 100644 --- a/gvn/gvn-param.c +++ b/gvn/gvn-param.c @@ -24,7 +24,7 @@ * @Short_description: * @Title: GvnParam **/ -G_DEFINE_TYPE (GvnParam, gvn_param, G_TYPE_INITIALLY_UNOWNED); +G_DEFINE_INTERFACE (GvnParam, gvn_param, G_TYPE_OBJECT); enum { VALUE_CHANGED @@ -35,396 +35,132 @@ enum { static guint signals[LAST_SIGNAL] = {0}; -/** - * gvn_param_new: - * - * Creates a new #GvnParam. - * - * Return value: the new #GvnParam - **/ -GvnParam * gvn_param_new () -{ - return g_object_new (GVN_TYPE_PARAM, NULL); -} - -/** - * gvn_param_new_with_spec: - * @spec: the spec of param. - * - * Creates a new #GvnParam. - * - * Return value: the new #GvnParam - **/ -GvnParam * gvn_param_new_with_spec (const GvnParamSpec * spec) -{ - return g_object_new (GVN_TYPE_PARAM, "spec", spec, NULL); -} - -//+++++++++++++++++++++++++++++++++++++++++++++++++++ Private - -static void gvn_param_set_status (GvnParam * obj, GvnParamStatus status) -{ - obj->status = status; - g_signal_emit (obj, signals[STATUS_CHANGED], 0, status); -} - -static void gvn_param_set_error (GvnParam * obj, GError * error) -{ - g_clear_error (&obj->error); - obj->error = error; - gvn_param_set_status (obj, GVN_PARAM_STATUS_ERROR); -} - -static void gvn_param_set_spec (GvnParam * obj, const GvnParamSpec * spec) -{ - GSList * n; - - if (obj->mode == GVN_PARAM_MASTER) - for (n = obj->slaves; n; n = n->next) - gvn_param_spec_merge (GVN_PARAM (n->data)->spec, spec); - - gvn_param_spec_unset (obj->spec); - gvn_param_spec_merge (obj->spec, spec); - g_signal_emit (obj, signals[SPEC_CHANGED], 0); -} - -static void gvn_param_put_value (GvnParam * obj, const GValue * value) -{ - if (gvn_param_spec_ccopy_value (obj->spec, value, obj->value)) - { - GError * tmp_err = NULL; - - if (obj->mode == GVN_PARAM_SLAVE) - { - if (!gvn_param_set_value (obj->master, obj->value, &tmp_err)) - gvn_param_set_error (obj, tmp_err); - } - else if (obj->mode == GVN_PARAM_MASTER) - { - GSList * n; - - for (n = obj->slaves; n; n = n->next) - if (!gvn_param_set_value (n->data, obj->value, &tmp_err)) - gvn_param_set_error (n->data, tmp_err); - } - - gvn_param_value_changed (obj); - } -} - //+++++++++++++++++++++++++++++++++++++++++++++++++++ Public /** * gvn_param_get_value: - * @param: a #GvnParam where be took the value + * @self: a #GvnParam where be took the value * * Gets the value of param. * * Return value: (transfer none): the #GValue **/ -const GValue * gvn_param_get_value (GvnParam * obj) +const GValue * gvn_param_get_value (GvnParam * self) { - g_return_val_if_fail (GVN_IS_PARAM (obj), NULL); - return obj->value; + g_return_val_if_fail (GVN_IS_PARAM (self), NULL); + + return GVN_PARAM_GET_INTERFACE (self)->get_value (self); } /** - * gvn_param_set_value: - * @param: #GvnParam object where @value wants to be validated. + * gvn_param_request_value: + * @self: #GvnParam object where @value wants to be validated. * @value: new value. * @err: (out) (allow-none): the return location for an allocated @GError, or * NULL to ignore errors. * - * Sets @value into @param. + * Sets @value into @self. * * Return value: %TRUE if assigment is valid, %FALSE otherwise. **/ -gboolean gvn_param_set_value (GvnParam * obj, const GValue * value, GError ** err) +gboolean gvn_param_request_value (GvnParam * self, const GValue * value, GError ** err) { - g_return_val_if_fail (GVN_IS_PARAM (obj), FALSE); + g_return_val_if_fail (GVN_IS_PARAM (self), FALSE); g_return_val_if_fail (G_IS_VALUE (value), FALSE); - - if (gvn_param_spec_validate (obj->spec, value, err)) - { - gvn_param_put_value (obj, value); - return TRUE; - } - - return FALSE; + + return GVN_PARAM_GET_INTERFACE (self)->request_value (self, value, err); } /** - * gvn_param_get_spec: - * @param: #GvnParam object + * gvn_param_set_value: + * @self: #GvnParam object where @value wants to be validated. + * @value: new value. * - * Gets the #GvnParamSpec of @obj - * - * Return value: (transfer none): the #GvnParamSpec + * Sets @value into @self. **/ -const GvnParamSpec * gvn_param_get_spec (GvnParam * obj) +void gvn_param_set_value (GvnParam * self, const GValue * value) { - g_return_val_if_fail (GVN_IS_PARAM (obj), NULL); - - return obj->spec; + g_return_val_if_fail (GVN_IS_PARAM (self), FALSE); + g_return_val_if_fail (G_IS_VALUE (value), FALSE); + + gvn_param_request_value (self, value, NULL); } /** * gvn_param_get_master: - * @sparam: a #GvnParam where be took the value + * @self: a #GvnParam where be took the value * - * Gets the master param of @obj + * Gets the master param of @self * * Return value: (transfer none): the master #GvnParam or %NULL if it haven't. **/ -GvnParam * gvn_param_get_master (GvnParam * obj) +GvnParam * gvn_param_get_master (GvnParam * self) { - g_return_val_if_fail (GVN_IS_PARAM (obj), NULL); + g_return_val_if_fail (GVN_IS_PARAM (self), NULL); - return obj->master; + return GVN_PARAM_GET_INTERFACE (self)->get_master (self); } /** - * gvn_param_bind: - * @src: #GvnParam object - * @dst: #GvnParam master + * gvn_param_set_master: + * @self: #GvnParam object + * @master: #GvnParam master * * Sets @dst as a master of @src **/ -void gvn_param_set_master (GvnParam * obj, GvnParam * master) +void gvn_param_set_master (GvnParam * self, GvnParam * master) { - g_return_if_fail (GVN_IS_PARAM (obj)); - g_return_if_fail (GVN_IS_PARAM (master) || !master); - g_return_if_fail (obj->mode != GVN_PARAM_MASTER); - g_return_if_fail (obj->mode != GVN_PARAM_SLAVE || !master); - g_return_if_fail (!master || master->mode != GVN_PARAM_SLAVE); - - if (master) - { - obj->master = g_object_ref_sink (master); - obj->mode = GVN_PARAM_SLAVE; - - master->slaves = g_slist_prepend (master->slaves, obj); - master->mode = GVN_PARAM_MASTER; - } - else - { - if (obj->mode == GVN_PARAM_SLAVE) - { - GSList ** slaves = &obj->master->slaves; - - if (!(*slaves = g_slist_remove (*slaves, obj))) - master->mode = GVN_PARAM_FREE; - } - - g_clear_object (&obj->master); - obj->mode = GVN_PARAM_FREE; - } + g_return_val_if_fail (GVN_IS_PARAM (self), NULL); + g_return_val_if_fail (GVN_IS_PARAM (master), NULL); + + GVN_PARAM_GET_INTERFACE (self)->set_master (self, master); +} + +/** + * gvn_param_get_spec: + * @self: #GvnParam object + * + * Gets the #GvnParamSpec of @self + * + * Return value: (transfer none): the #GvnParamSpec + **/ +const GvnParamSpec * gvn_param_get_spec (GvnParam * self) +{ + g_return_val_if_fail (GVN_IS_PARAM (self), NULL); + + return GVN_PARAM_GET_INTERFACE (self)->get_spec (self); } /** * gvn_param_get_status: - * @obj: #GvnParam object + * @self: #GvnParam object * - * Gets the status of @obj + * Gets the status of @self * * Return value: the current status of the param. **/ -GvnParamStatus gvn_param_get_status (GvnParam * obj) +GvnParamStatus gvn_param_get_status (GvnParam * self) { - g_return_val_if_fail (GVN_IS_PARAM (obj), GVN_PARAM_STATUS_OK); + g_return_val_if_fail (GVN_IS_PARAM (self), GVN_PARAM_STATUS_OK); - return obj->status; -} - -/** - * gvn_param_get_error: - * @obj: #GvnParam object - * - * Gets the error of @obj - * - * Return value: the current error of the param. - **/ -const GError * gvn_param_get_error (GvnParam * obj) -{ - g_return_val_if_fail (GVN_IS_PARAM (obj), NULL); - - return obj->error; -} - -/** - * gvn_param_get_null: - * @param: the #GvnParam - **/ -gboolean gvn_param_get_null (GvnParam * obj) -{ - g_return_val_if_fail (GVN_IS_PARAM (obj), FALSE); - - return gvn_param_spec_get_null (obj->spec); -} - -/** - * gvn_param_get_editable: - * @param: the #GvnParam - **/ -gboolean gvn_param_get_editable (GvnParam * obj) -{ - g_return_val_if_fail (GVN_IS_PARAM (obj), FALSE); - - return gvn_param_spec_get_editable (obj->spec); -} - -/** - * gvn_param_get_default: - * @obj: the #GvnParam - **/ -const GValue * gvn_param_get_default (GvnParam * obj) -{ - g_return_val_if_fail (GVN_IS_PARAM (obj), NULL); - - return gvn_param_spec_get_default (obj->spec); -} - -/** - * gvn_param_set_to_default: - * @obj: the #GvnParam - **/ -void gvn_param_set_to_default (GvnParam * obj) -{ - g_return_if_fail (GVN_IS_PARAM (obj)); - - gvn_param_set_value (obj, - gvn_param_spec_get_default (obj->spec), NULL); + return GVN_PARAM_GET_INTERFACE (self)->get_status (self); } /** * gvn_param_value_changed: - * @obj: a #GvnParam + * @self: a #GvnParam * * Emits the "value-changed" signal for that param. **/ -void gvn_param_value_changed (GvnParam * obj) +void gvn_param_value_changed (GvnParam * self) { - g_signal_emit (obj, signals[VALUE_CHANGED], 0, obj->value); + g_signal_emit (self, signals[VALUE_CHANGED], 0, gvn_param_get_value (self)); } -//+++++++++++++++++++++++++++++++++++++++++++++++++++ Properties - -enum -{ - PROP_VALUE = 1 - ,PROP_MASTER - ,PROP_MODE - ,PROP_STATUS - ,PROP_SPEC - ,PROP_GTYPE - ,PROP_EDITABLE - ,PROP_NULL - ,PROP_DEFAULT -}; - -static void gvn_param_set_property (GvnParam * obj, guint property_id, - const GValue * value, GParamSpec * pspec) -{ - switch (property_id) - { - case PROP_VALUE: - gvn_param_set_value (obj, g_value_get_boxed (value), NULL); - break; - case PROP_MASTER: - gvn_param_set_master (obj, g_value_get_object (value)); - break; - case PROP_SPEC: - gvn_param_spec_merge (obj->spec, g_value_get_boxed (value)); - break; - case PROP_GTYPE: - gvn_param_spec_set_gtype (obj->spec, g_value_get_gtype (value)); - break; - case PROP_EDITABLE: - gvn_param_spec_set_editable (obj->spec, g_value_get_boolean (value)); - break; - case PROP_NULL: - gvn_param_spec_set_null (obj->spec, g_value_get_boolean (value)); - break; - case PROP_DEFAULT: - gvn_param_spec_set_default (obj->spec, g_value_get_boxed (value)); - break; - default: - G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, property_id, pspec); - } -} - -static void gvn_param_get_property (GvnParam * obj, guint property_id, - GValue * value, GParamSpec * pspec) -{ - switch (property_id) - { - case PROP_VALUE: - g_value_set_boxed (value, obj->value); - break; - case PROP_MASTER: - g_value_set_object (value, obj->master); - break; - case PROP_MODE: - g_value_set_int (value, obj->mode); - break; - case PROP_STATUS: - g_value_set_boolean (value, obj->status); - break; - case PROP_SPEC: - g_value_set_boxed (value, obj->spec); - break; - case PROP_GTYPE: - g_value_set_gtype (value, gvn_param_spec_get_gtype (obj->spec)); - break; - case PROP_EDITABLE: - g_value_set_boolean (value, gvn_param_spec_get_editable (obj->spec)); - break; - case PROP_NULL: - g_value_set_boolean (value, gvn_param_spec_get_null (obj->spec)); - break; - case PROP_DEFAULT: - g_value_set_boxed (value, gvn_param_spec_get_default (obj->spec)); - break; - default: - G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, property_id, pspec); - } -} //+++++++++++++++++++++++++++++++++++++++++++++++++++ Class -static void gvn_param_init (GvnParam * obj) +static void gvn_param_default_init (GvnParamInterface * iface) { - obj->error = NULL; - obj->master = NULL; - obj->slaves = NULL; - obj->mode = GVN_PARAM_FREE; - obj->status = GVN_PARAM_STATUS_OK; - obj->spec = gvn_param_spec_new (); - - obj->value = g_new0 (GValue, 1); - g_value_init (obj->value, GVN_TYPE_NULL); -} - -static void gvn_param_finalize (GvnParam * obj) -{ - gvn_param_set_master (obj, NULL); - gvn_param_spec_free (obj->spec); - g_clear_error (&obj->error); - g_value_unset (obj->value); - g_free (obj->value); - G_OBJECT_CLASS (gvn_param_parent_class)->finalize (G_OBJECT (obj)); -} - -static void gvn_param_class_init (GvnParamClass * klass) -{ - GObjectClass * k = G_OBJECT_CLASS (klass); - k->finalize = (GObjectFinalizeFunc) gvn_param_finalize; - k->set_property = (GObjectSetPropertyFunc) gvn_param_set_property; - k->get_property = (GObjectGetPropertyFunc) gvn_param_get_property; - klass->put_value = gvn_param_put_value; - klass->set_spec = gvn_param_set_spec; - klass->set_status = gvn_param_set_status; - klass->set_error = gvn_param_set_error; - signals[VALUE_CHANGED] = g_signal_new ("value-changed", GVN_TYPE_PARAM, G_SIGNAL_RUN_FIRST, 0, NULL, NULL, g_cclosure_marshal_VOID__BOXED, G_TYPE_NONE, 1, G_TYPE_VALUE @@ -438,67 +174,18 @@ static void gvn_param_class_init (GvnParamClass * klass) g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0 ); - g_object_class_install_property (k, PROP_VALUE, + g_object_interface_install_property (iface, g_param_spec_boxed ("value" ,_("Value") ,_("The value of the param") ,G_TYPE_VALUE ,G_PARAM_READWRITE )); - g_object_class_install_property (k, PROP_MASTER, + g_object_interface_install_property (iface, g_param_spec_object ("master" ,_("Master") - ,_("The master GvnParam of this parameter") + ,_("The master parameter") ,GVN_TYPE_PARAM ,G_PARAM_READWRITE )); - g_object_class_install_property (k, PROP_MODE, - g_param_spec_uint ("mode" - ,_("Mode") - ,_("The mode of the parameter") - ,0 ,256 ,GVN_PARAM_FREE - ,G_PARAM_READABLE - )); - g_object_class_install_property (k, PROP_STATUS, - g_param_spec_uint ("status" - ,_("Status") - ,_("The current status of the parameter") - ,0 ,256 ,GVN_PARAM_STATUS_OK - ,G_PARAM_READABLE - )); - g_object_class_install_property (k, PROP_SPEC, - g_param_spec_boxed ("spec" - ,_("Spec") - ,_("The spec of the parameter") - ,GVN_TYPE_PARAM_SPEC - ,G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE - )); - g_object_class_install_property (k, PROP_GTYPE, - g_param_spec_gtype ("gtype" - ,_("Glib Type") - ,_("The type of the value") - ,G_TYPE_NONE - ,G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE - )); - g_object_class_install_property (k, PROP_EDITABLE, - g_param_spec_boolean ("editable" - ,_("Editable") - ,_("Whether the param value can be modified") - ,TRUE - ,G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE - )); - g_object_class_install_property (k, PROP_NULL, - g_param_spec_boolean ("null" - ,_("Null") - ,_("Whether the param value can be of type GVN_TYPE_NULL") - ,TRUE - ,G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE - )); - g_object_class_install_property (k, PROP_DEFAULT, - g_param_spec_boxed ("default" - ,_("Default Value") - ,_("The default value") - ,G_TYPE_VALUE - ,G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE - )); } diff --git a/gvn/gvn-param.h b/gvn/gvn-param.h index d36fa34..c07aae7 100644 --- a/gvn/gvn-param.h +++ b/gvn/gvn-param.h @@ -23,29 +23,21 @@ #define GVN_PARAM_LOG_DOMAIN (g_quark_from_string ("GvnParam")) -#define GVN_TYPE_PARAM (gvn_param_get_type ()) -#define GVN_PARAM(obj) (G_TYPE_CHECK_INSTANCE_CAST (obj, GVN_TYPE_PARAM, GvnParam)) -#define GVN_IS_PARAM(obj) (G_TYPE_CHECK_INSTANCE_TYPE (obj, GVN_TYPE_PARAM)) -#define GVN_PARAM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS (obj, GVN_TYPE_PARAM, GvnParamClass)) +#define GVN_TYPE_PARAM (gvn_param_get_type ()) +#define GVN_PARAM(self) (G_TYPE_CHECK_INSTANCE_CAST (self, GVN_TYPE_PARAM, GvnParam)) +#define GVN_IS_PARAM(self) (G_TYPE_CHECK_INSTANCE_TYPE (self, GVN_TYPE_PARAM)) +#define GVN_PARAM_GET_INTERFACE(self) (G_TYPE_INSTANCE_GET_INTERFACE (self, GVN_TYPE_PARAM, GvnParamInterface)) typedef struct _GvnParam GvnParam; -typedef struct _GvnParamClass GvnParamClass; +typedef struct _GvnParamInterface GvnParamInterface; +typedef enum _GvnParamStatus GvnParamStatus; -/** - * GvnParamMode: - * @GVN_PARAM_FREE: It is not set. - * @GVN_PARAM_SLAVE: It is set as slave. - * @GVN_PARAM_MASTER: It is set as master. - * - * The mode in which is Binded. - **/ -typedef enum -{ - GVN_PARAM_FREE - ,GVN_PARAM_SLAVE - ,GVN_PARAM_MASTER -} -GvnParamMode; +typedef const GValue * (* GvnParamGetValueFunc) (GvnParam * self); +typedef gboolean (* GvnParamRequestValueFunc) (GvnParam * self, const GValue * value, GError ** err); +typedef GvnParam * (* GvnParamGetMasterFunc) (GvnParam * self); +typedef void (* GvnParamSetMasterFunc) (GvnParam * self, GvnParam * master); +typedef const GvnParamSpec * (* GvnParamGetSpecFunc) (GvnParam * self); +typedef GvnParamStatus (* GvnParamGetStatusFunc) (GvnParam * self); /** * GvnParamStatus: @@ -55,55 +47,39 @@ GvnParamMode; * * The status of the param. **/ -typedef enum +enum _GvnParamStatus { GVN_PARAM_STATUS_OK ,GVN_PARAM_STATUS_BUSY ,GVN_PARAM_STATUS_ERROR -} -GvnParamStatus; +}; /** * GvnParam: * @slaves: (element-type Gvn.Param): **/ -struct _GvnParam -{ - GInitiallyUnowned parent; - GValue * value; - GError * error; - GvnParamStatus status; - GvnParamSpec * spec; - GvnParamMode mode; - GvnParam * master; - GSList * slaves; -}; +struct _GvnParam; -struct _GvnParamClass +struct _GvnParamInterface { /* */ GInitiallyUnownedClass parent; - void (* put_value) (GvnParam * obj, const GValue * value); - void (* set_spec) (GvnParam * obj, const GvnParamSpec * spec); - void (* set_status) (GvnParam * obj, GvnParamStatus status); - void (* set_error) (GvnParam * obj, GError * error); + GvnParamGetValueFunc get_value; + GvnParamRequestValueFunc request_value; + GvnParamGetMasterFunc get_master; + GvnParamSetMasterFunc set_master; + GvnParamGetSpecFunc get_spec; + GvnParamGetStatusFunc get_status; }; GType gvn_param_get_type (); -GvnParam * gvn_param_new (); -GvnParam * gvn_param_new_with_spec (const GvnParamSpec * spec); -const GValue * gvn_param_get_value (GvnParam * param); -gboolean gvn_param_set_value (GvnParam * param, const GValue * value, GError ** err); -const GvnParamSpec * gvn_param_get_spec (GvnParam * param); -GType gvn_param_get_gtype (GvnParam * param); -gboolean gvn_param_get_null (GvnParam * param); -gboolean gvn_param_get_editable (GvnParam * param); -const GValue * gvn_param_get_default (GvnParam * obj); -void gvn_param_set_to_default (GvnParam * obj); -GvnParam * gvn_param_get_master (GvnParam * sparam); -void gvn_param_set_master (GvnParam * sparam, GvnParam * dparam); -void gvn_param_value_changed (GvnParam * obj); -GvnParamStatus gvn_param_get_status (GvnParam * obj); -const GError * gvn_param_get_error (GvnParam * obj); +const GValue * gvn_param_get_value (GvnParam * self); +gboolean gvn_param_request_value (GvnParam * self, const GValue * value, GError ** err); +void gvn_param_set_value (GvnParam * self, const GValue * value); +GvnParam * gvn_param_get_master (GvnParam * self); +void gvn_param_set_master (GvnParam * self, GvnParam * master); +const GvnParamSpec * gvn_param_get_spec (GvnParam * self); +GvnParamStatus gvn_param_get_status (GvnParam * self); +void gvn_param_value_changed (GvnParam * self); #endif \ No newline at end of file diff --git a/main/main.c b/main/main.c index 12c56d6..9da3a71 100644 --- a/main/main.c +++ b/main/main.c @@ -21,6 +21,10 @@ int main (int argc, char * argv[]) { + gint status = 0; + GtkApplication * app; + VnLogin * login; + #ifdef ENABLE_NLS setlocale (LC_ALL, ""); bindtextdomain (GETTEXT_PACKAGE, _HEDERA_LOCALE_DIR); @@ -34,9 +38,13 @@ int main (int argc, char * argv[]) gvn_type_init (); gtk_init (&argc, &argv); + + app = gtk_application_new ("apps.hedera", G_APPLICATION_FLAGS_NONE); + login = vn_login_new (app); - VnLogin * login = vn_login_new ("apps.hedera"); - vn_login_run (login); + if (g_application_register (G_APPLICATION (app), NULL, NULL)) + status = g_application_run (G_APPLICATION (app), argc, argv); + g_object_unref (login); - return 0; + return status; } diff --git a/sql/parser/gram.y b/sql/parser/gram.y index 16fc328..5e09c40 100644 --- a/sql/parser/gram.y +++ b/sql/parser/gram.y @@ -517,7 +517,7 @@ operation(A) ::= MINUS expr(X). [SIGN] SqlObject * minus = sql_value_new (); g_value_init (&value, G_TYPE_INT); g_value_set_int (&value, -1); - sql_value_set_value (SQL_VALUE (minus), &value); + gvn_param_set_value (GVN_PARAM (minus), &value); A = create_operation (X, minus, SQL_OPERATION_TYPE_MULTIPLICATION); } diff --git a/sql/sql-value.c b/sql/sql-value.c index 5a7216d..72a2bf7 100644 --- a/sql/sql-value.c +++ b/sql/sql-value.c @@ -18,6 +18,9 @@ #include #include "sql-value.h" +static void sql_value_param_init (GvnParamInterface * iface); +static void sql_value_on_master_value_changed (GvnParam * master, const GValue * value, SqlValue * self); + /** * SECTION: sql-value * @Short_description: generic value @@ -26,7 +29,10 @@ * A generic value that can be used in operations (#SqlOperation) and of course * in any place where an #SqlExpr can be used. **/ -G_DEFINE_TYPE (SqlValue, sql_value, SQL_TYPE_EXPR); +G_DEFINE_TYPE_WITH_CODE (SqlValue, sql_value, SQL_TYPE_EXPR, + G_IMPLEMENT_INTERFACE (GVN_TYPE_PARAM, + sql_value_param_init) +); SqlObject * sql_value_new () { @@ -37,7 +43,7 @@ SqlObject * sql_value_new_with_param (GvnParam * param) { g_return_val_if_fail (GVN_IS_PARAM (param), NULL); - return g_object_new (SQL_TYPE_VALUE, "param", param, NULL); + return g_object_new (SQL_TYPE_VALUE, "master", param, NULL); } SqlObject * sql_value_new_with_value (const GValue * value) @@ -49,9 +55,79 @@ SqlObject * sql_value_new_with_value (const GValue * value) //+++++++++++++++++++++++++++++++++++++++++++++++++++ Private -static void sql_value_render (SqlValue * obj, SqlRender * render) +static void sql_value_put_value (SqlValue * self, const GValue * value) { - GValue * value = obj->value; + if (!gvn_value_ccopy (value, self->value)) + return; + + g_signal_emit_by_name (self, "value-changed", value); + g_signal_emit_by_name (self, "changed"); + + if (self->master && self->change_master) + { + self->change_master = FALSE; + gvn_param_request_value (self->master, value, NULL); + self->change_master = TRUE; + } +} + +static const GValue * sql_value_get_value (SqlValue * self) +{ + return self->value; +} + +static gboolean sql_value_request_value (SqlValue * self, const GValue * value, GError ** err) +{ + sql_value_put_value (self, value); + return TRUE; +} + +static void sql_value_on_master_value_changed (GvnParam * master, const GValue * value, SqlValue * self) +{ + if (self->change_master) + { + self->change_master = FALSE; + gvn_param_set_value (GVN_PARAM (self), value); + self->change_master = TRUE; + } +} + +static GvnParam * sql_value_get_master (SqlValue * self) +{ + return self->master; +} + +static void sql_value_set_master (SqlValue * self, GvnParam * master) +{ + if (self->master) + { + g_signal_handlers_disconnect_by_func (self->master, + sql_value_on_master_value_changed, self); + g_clear_object (&self->master); + } + if (master) + { + self->master = g_object_ref_sink (master); + g_signal_connect (master, "value-changed", + G_CALLBACK (sql_value_on_master_value_changed), self); + sql_value_on_master_value_changed (master, + gvn_param_get_value (master), self); + } +} + +static const GvnParamSpec * sql_value_get_spec (SqlValue * self) +{ + return NULL; +} + +static GvnParamStatus sql_value_get_status (SqlValue * self) +{ + return GVN_PARAM_STATUS_OK; +} + +static void sql_value_render (SqlValue * self, SqlRender * render) +{ + GValue * value = self->value; GType type = G_VALUE_TYPE (value); switch (type) @@ -115,123 +191,66 @@ static void sql_value_render (SqlValue * obj, SqlRender * render) } } -static gboolean sql_value_is_ready (SqlValue * obj) +static gboolean sql_value_is_ready (SqlValue * self) { - return !gvn_value_is_null (obj->value); -} - -static void sql_value_put_value (SqlValue * obj, const GValue * value) -{ - if (gvn_value_ccopy (value, obj->value)) - g_signal_emit_by_name (obj, "changed"); -} - -static void sql_value_cb_value_changed (GvnParam * param, const GValue * value, SqlValue * obj) -{ - sql_value_put_value (obj, value); -} - -//+++++++++++++++++++++++++++++++++++++++++++++++++++ Public - -const GValue * sql_value_get_value (SqlValue * obj) -{ - g_return_val_if_fail (SQL_IS_VALUE (obj), NULL); - - return obj->value; -} - -void sql_value_set_value (SqlValue * obj, const GValue * value) -{ - g_return_if_fail (SQL_IS_VALUE (obj)); - g_return_if_fail (!obj->param); - - sql_value_put_value (obj, value); -} - -void sql_value_set_param (SqlValue * obj, GvnParam * param) -{ - g_return_if_fail (SQL_IS_VALUE (obj)); - g_return_if_fail (GVN_IS_PARAM (param) || !param); - - if (obj->param) - { - g_signal_handlers_disconnect_by_func (obj->param, - sql_value_cb_value_changed, obj); - g_clear_object (&obj->param); - } - if (param) - { - obj->param = g_object_ref_sink (param); - g_signal_connect (param, "value-changed", - G_CALLBACK (sql_value_cb_value_changed), obj); - sql_value_put_value (obj, gvn_param_get_value (param)); - } -} - -/** - * sql_value_get_param: - * Return value: (transfer none): - **/ -GvnParam * sql_value_get_param (SqlValue * self) -{ - g_return_if_fail (SQL_IS_VALUE (self)); - - return self->param; + return !gvn_value_is_null (self->value); } //+++++++++++++++++++++++++++++++++++++++++++++++++++ Properties enum { - PROP_PARAM = 1 - ,PROP_VALUE + PROP_VALUE = 1 + ,PROP_MASTER }; -static void sql_value_set_property (SqlValue * obj, guint id, const GValue * value, GParamSpec * pspec) +static void sql_value_set_property (SqlValue * self, guint id, const GValue * value, GParamSpec * pspec) { switch (id) { - case PROP_PARAM: - sql_value_set_param (obj, g_value_get_object (value)); - break; case PROP_VALUE: - sql_value_set_value (obj, g_value_get_boxed (value)); + sql_value_put_value (self, g_value_get_boxed (value)); + break; + case PROP_MASTER: + sql_value_set_master (self, g_value_get_object (value)); break; default: - G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, id, pspec); + G_OBJECT_WARN_INVALID_PROPERTY_ID (self, id, pspec); } } -static void sql_value_get_property (SqlValue * obj, guint id, GValue * value, GParamSpec * pspec) +static void sql_value_get_property (SqlValue * self, guint id, GValue * value, GParamSpec * pspec) { switch (id) { - case PROP_PARAM: - g_value_set_object (value, obj->param); - break; case PROP_VALUE: - g_value_set_boxed (value, obj->value); + g_value_set_boxed (value, self->value); + break; + case PROP_MASTER: + g_value_set_object (value, self->master); break; default: - G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, id, pspec); + G_OBJECT_WARN_INVALID_PROPERTY_ID (self, id, pspec); } } //+++++++++++++++++++++++++++++++++++++++++++++++++++ Class -static void sql_value_init (SqlValue * obj) +static void sql_value_init (SqlValue * self) { - obj->param = NULL; - obj->value = g_new0 (GValue, 1); - g_value_init (obj->value, GVN_TYPE_NULL); + self->master = NULL; + self->change_master = TRUE; + + self->value = g_new0 (GValue, 1); + g_value_init (self->value, GVN_TYPE_NULL); } -static void sql_value_finalize (SqlValue * obj) +static void sql_value_finalize (SqlValue * self) { - sql_value_set_param (obj, NULL); - g_value_unset (obj->value); - g_free (obj->value); - G_OBJECT_CLASS (sql_value_parent_class)->finalize (G_OBJECT (obj)); + sql_value_set_master (self, NULL); + g_value_unset (self->value); + g_free (self->value); + G_OBJECT_CLASS (sql_value_parent_class)->finalize (G_OBJECT (self)); } static void sql_value_class_init (SqlValueClass * klass) @@ -243,17 +262,16 @@ static void sql_value_class_init (SqlValueClass * klass) SQL_OBJECT_CLASS (klass)->render = (SqlRenderFunc) sql_value_render; SQL_OBJECT_CLASS (klass)->is_ready = (SqlObjectIsReadyFunc) sql_value_is_ready; - g_object_class_install_property (k, PROP_PARAM, - g_param_spec_object ("param" - ,_("Param") - ,_("The param which is linked") - ,GVN_TYPE_PARAM, G_PARAM_READWRITE - )); - - g_object_class_install_property (k, PROP_VALUE, - g_param_spec_boxed ("value" - ,_("Value") - ,_("The value") - ,G_TYPE_VALUE, G_PARAM_READWRITE - )); + g_object_class_override_property (k, PROP_VALUE, "value"); + g_object_class_override_property (k, PROP_MASTER, "master"); +} + +static void sql_value_param_init (GvnParamInterface * iface) +{ + iface->get_value = (GvnParamGetValueFunc) sql_value_get_value; + iface->request_value = (GvnParamRequestValueFunc) sql_value_request_value; + iface->get_master = (GvnParamGetMasterFunc) sql_value_get_master; + iface->set_master = (GvnParamSetMasterFunc) sql_value_set_master; + iface->get_spec = (GvnParamGetSpecFunc) sql_value_get_spec; + iface->get_status = (GvnParamGetStatusFunc) sql_value_get_status; } diff --git a/sql/sql-value.h b/sql/sql-value.h index 9e48b5a..a17230b 100644 --- a/sql/sql-value.h +++ b/sql/sql-value.h @@ -22,8 +22,8 @@ #include "sql-expr.h" #define SQL_TYPE_VALUE (sql_value_get_type ()) -#define SQL_VALUE(obj) (G_TYPE_CHECK_INSTANCE_CAST (obj, SQL_TYPE_VALUE, SqlValue)) -#define SQL_IS_VALUE(obj) (G_TYPE_CHECK_INSTANCE_TYPE (obj, SQL_TYPE_VALUE)) +#define SQL_VALUE(self) (G_TYPE_CHECK_INSTANCE_CAST (self, SQL_TYPE_VALUE, SqlValue)) +#define SQL_IS_VALUE(self) (G_TYPE_CHECK_INSTANCE_TYPE (self, SQL_TYPE_VALUE)) typedef struct _SqlValue SqlValue; typedef struct _SqlValueClass SqlValueClass; @@ -32,7 +32,8 @@ struct _SqlValue { SqlExpr parent; GValue * value; - GvnParam * param; + GvnParam * master; + gboolean change_master; }; struct _SqlValueClass @@ -45,9 +46,5 @@ GType sql_value_get_type (); SqlObject * sql_value_new (); SqlObject * sql_value_new_with_value (const GValue * value); SqlObject * sql_value_new_with_param (GvnParam * param); -const GValue * sql_value_get_value (SqlValue * obj); -void sql_value_set_value (SqlValue * obj, const GValue * value); -GvnParam * sql_value_get_param (SqlValue * self); -void sql_value_set_param (SqlValue * obj, GvnParam * param); #endif diff --git a/vn/field/vn-combo.c b/vn/field/vn-combo.c index a27a166..a6c48ca 100644 --- a/vn/field/vn-combo.c +++ b/vn/field/vn-combo.c @@ -52,87 +52,87 @@ VnField * vn_combo_new (DbModel * model) //+++++++++++++++++++++++++++++++++++++++++++++++++++ Private -static void vn_combo_cb_changed (GtkComboBox * combo, VnCombo * obj) +static void vn_combo_on_changed (GtkComboBox * combo, VnCombo * self) { GtkTreeIter iter; GValue value = G_VALUE_INIT; if (gtk_combo_box_get_active_iter (combo, &iter)) - gtk_tree_model_get_value (obj->tree, &iter, obj->index_column, &value); + gtk_tree_model_get_value (self->tree, &iter, self->index_column, &value); else g_value_init (&value, GVN_TYPE_NULL); - VN_FIELD_GET_CLASS (obj)->value_changed (VN_FIELD (obj), &value); + VN_FIELD_GET_CLASS (self)->value_changed (VN_FIELD (self), &value); g_value_unset (&value); } -static void vn_combo_on_model_ready (VnCombo * obj, const GValue * value) +static void vn_combo_on_model_ready (VnCombo * self, const GValue * value) { DbIter iter; - g_signal_handlers_block_by_func (obj->combo, - vn_combo_cb_changed, obj); + g_signal_handlers_block_by_func (self->combo, + vn_combo_on_changed, self); if (!gvn_value_is_null (value) - && db_model_search_value (obj->model, obj->index_column, &iter, value)) + && db_model_search_value (self->model, self->index_column, &iter, value)) { GtkTreeIter tree_iter; vn_gtk_tree_iter_from_db_iter (&tree_iter, &iter); - gtk_combo_box_set_active_iter (obj->combo, &tree_iter); + gtk_combo_box_set_active_iter (self->combo, &tree_iter); } else - gtk_combo_box_set_active_iter (obj->combo, NULL); + gtk_combo_box_set_active_iter (self->combo, NULL); - g_signal_handlers_unblock_by_func (obj->combo, - vn_combo_cb_changed, obj); + g_signal_handlers_unblock_by_func (self->combo, + vn_combo_on_changed, self); } -static void vn_combo_set_value (VnCombo * obj, const GValue * value) +static void vn_combo_set_value (VnCombo * self, const GValue * value) { - if (obj->model && db_model_get_status (obj->model) == DB_MODEL_STATUS_READY) - vn_combo_on_model_ready (obj, value); + if (self->model && db_model_get_status (self->model) == DB_MODEL_STATUS_READY) + vn_combo_on_model_ready (self, value); } -static void vn_combo_cb_status_changed (DbModel * model, DbModelStatus status, VnCombo * obj) +static void vn_combo_on_status_changed (DbModel * model, DbModelStatus status, VnCombo * self) { if (status == DB_MODEL_STATUS_READY) { - gtk_combo_box_set_model (obj->combo, obj->tree); - vn_combo_on_model_ready (obj, vn_field_get_value (VN_FIELD (obj))); + gtk_combo_box_set_model (self->combo, self->tree); + vn_combo_on_model_ready (self, gvn_param_get_value (GVN_PARAM (self))); - db_model_use_null_row (model, vn_field_get_null (VN_FIELD (obj))); + db_model_use_null_row (model, vn_field_get_null (VN_FIELD (self))); } else - gtk_combo_box_set_model (obj->combo, NULL); + gtk_combo_box_set_model (self->combo, NULL); } -static DbModel * vn_combo_get_model (VnCombo * obj) +static DbModel * vn_combo_get_model (VnCombo * self) { - return obj->model; + return self->model; } -static void vn_combo_set_model (VnCombo * obj, DbModel * model) +static void vn_combo_set_model (VnCombo * self, DbModel * model) { - g_return_if_fail (VN_IS_COMBO (obj)); + g_return_if_fail (VN_IS_COMBO (self)); g_return_if_fail (DB_IS_MODEL (model) || !model); - if (obj->model) + if (self->model) { - g_signal_handlers_disconnect_by_func (obj->model, - vn_combo_cb_status_changed, obj); - g_clear_object (&obj->model); - g_clear_object (&obj->tree); + g_signal_handlers_disconnect_by_func (self->model, + vn_combo_on_status_changed, self); + g_clear_object (&self->model); + g_clear_object (&self->tree); } if (model) { - obj->tree = GTK_TREE_MODEL (vn_grid_model_new (model)); - obj->model = g_object_ref (model); + self->tree = GTK_TREE_MODEL (vn_grid_model_new (model)); + self->model = g_object_ref (model); g_signal_connect (model, "status-changed", - G_CALLBACK (vn_combo_cb_status_changed), obj); - vn_combo_cb_status_changed (model, - db_model_get_status (model), obj); + G_CALLBACK (vn_combo_on_status_changed), self); + vn_combo_on_status_changed (model, + db_model_get_status (model), self); } } @@ -140,64 +140,64 @@ static void vn_combo_set_model (VnCombo * obj, DbModel * model) /** * vn_combo_get_index_column: - * @obj: a #VnCombo + * @self: a #VnCombo * * Gets the combo column index. * * Return value: the column **/ -guint vn_combo_get_index_column (VnCombo * obj) +guint vn_combo_get_index_column (VnCombo * self) { - g_return_val_if_fail (VN_IS_COMBO (obj), 0); + g_return_val_if_fail (VN_IS_COMBO (self), 0); - return obj->index_column; + return self->index_column; } /** * vn_combo_set_index_column: - * @obj: a #VnCombo + * @self: a #VnCombo * @column: the column * * Sets the column index used by combo. **/ -void vn_combo_set_index_column (VnCombo * obj, guint column) +void vn_combo_set_index_column (VnCombo * self, guint column) { - g_return_if_fail (VN_IS_COMBO (obj)); + g_return_if_fail (VN_IS_COMBO (self)); - obj->index_column = column; - vn_combo_set_value (obj, vn_field_get_value (VN_FIELD (obj))); + self->index_column = column; + vn_combo_set_value (self, gvn_param_get_value (GVN_PARAM (self))); } /** * vn_combo_get_show_column: - * @obj: a #VnCombo + * @self: a #VnCombo * * Gets the column shown by combo. * * Return value: the column **/ -guint vn_combo_get_show_column (VnCombo * obj) +guint vn_combo_get_show_column (VnCombo * self) { - g_return_val_if_fail (VN_IS_COMBO (obj), 0); + g_return_val_if_fail (VN_IS_COMBO (self), 0); - return obj->show_column; + return self->show_column; } /** * vn_combo_set_show_column: - * @obj: a #VnCombo + * @self: a #VnCombo * @column: the column * * Sets the column shown by combo. **/ -void vn_combo_set_show_column (VnCombo * obj, guint column) +void vn_combo_set_show_column (VnCombo * self, guint column) { - g_return_if_fail (VN_IS_COMBO (obj)); + g_return_if_fail (VN_IS_COMBO (self)); - obj->show_column = column; - gtk_cell_layout_clear_attributes (GTK_CELL_LAYOUT (obj->combo), obj->cell); - gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (obj->combo), - obj->cell, "text", (gint) obj->show_column); + self->show_column = column; + gtk_cell_layout_clear_attributes (GTK_CELL_LAYOUT (self->combo), self->cell); + gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (self->combo), + self->cell, "text", (gint) self->show_column); } //+++++++++++++++++++++++++++++++++++++++++++++++++++ Properties @@ -209,66 +209,67 @@ enum ,PROP_MODEL }; -static void vn_combo_set_property (VnCombo * obj, guint property_id, +static void vn_combo_set_property (VnCombo * self, guint property_id, const GValue * value, GParamSpec * pspec) { switch (property_id) { case PROP_INDEX_COLUMN: - vn_combo_set_index_column (obj, g_value_get_uint (value)); + vn_combo_set_index_column (self, g_value_get_uint (value)); break; case PROP_SHOW_COLUMN: - vn_combo_set_show_column (obj, g_value_get_uint (value)); + vn_combo_set_show_column (self, g_value_get_uint (value)); break; case PROP_MODEL: - vn_combo_set_model (obj, g_value_get_object (value)); + vn_combo_set_model (self, g_value_get_object (value)); break; default: - G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, property_id, pspec); + G_OBJECT_WARN_INVALID_PROPERTY_ID (self, property_id, pspec); } } -static void vn_combo_get_property (VnCombo * obj, guint property_id, +static void vn_combo_get_property (VnCombo * self, guint property_id, GValue * value, GParamSpec * pspec) { switch (property_id) { case PROP_INDEX_COLUMN: - g_value_set_uint (value, obj->index_column); + g_value_set_uint (value, self->index_column); break; case PROP_SHOW_COLUMN: - g_value_set_uint (value, obj->show_column); + g_value_set_uint (value, self->show_column); break; case PROP_MODEL: - g_value_set_object (value, obj->model); + g_value_set_object (value, self->model); break; default: - G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, property_id, pspec); + G_OBJECT_WARN_INVALID_PROPERTY_ID (self, property_id, pspec); } } //+++++++++++++++++++++++++++++++++++++++++++++++++++ Class -static void vn_combo_init (VnCombo * obj) +static void vn_combo_init (VnCombo * self) { - obj->tree = NULL; - obj->model = NULL; + self->tree = NULL; + self->model = NULL; - obj->combo = GTK_COMBO_BOX (gtk_combo_box_new ()); - g_signal_connect (obj->combo, "changed", - G_CALLBACK (vn_combo_cb_changed), obj); - gtk_container_add (GTK_CONTAINER (obj), GTK_WIDGET (obj->combo)); + self->combo = GTK_COMBO_BOX (gtk_combo_box_new ()); + g_signal_connect (self->combo, "changed", + G_CALLBACK (vn_combo_on_changed), self); + gtk_container_add (GTK_CONTAINER (self), GTK_WIDGET (self->combo)); - obj->cell = gtk_cell_renderer_text_new (); - gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (obj->combo), obj->cell, TRUE); + self->cell = gtk_cell_renderer_text_new (); + gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (self->combo), self->cell, TRUE); - VN_FIELD (obj)->field = GTK_WIDGET (obj->combo); + VN_FIELD_GET_CLASS (self)->set_widget (VN_FIELD (self), + GTK_WIDGET (self->combo)); } -static void vn_combo_finalize (VnCombo * obj) +static void vn_combo_finalize (VnCombo * self) { - vn_combo_set_model (obj, NULL); - G_OBJECT_CLASS (vn_combo_parent_class)->finalize (G_OBJECT (obj)); + vn_combo_set_model (self, NULL); + G_OBJECT_CLASS (vn_combo_parent_class)->finalize (G_OBJECT (self)); } static void vn_combo_class_init (VnComboClass * klass) diff --git a/vn/field/vn-completion.c b/vn/field/vn-completion.c index 43dfa50..d8d0a01 100644 --- a/vn/field/vn-completion.c +++ b/vn/field/vn-completion.c @@ -20,7 +20,7 @@ #include #include -#define set_icon(obj,icon_name) (gtk_entry_set_icon_from_icon_name (obj->entry, GTK_ENTRY_ICON_SECONDARY, icon_name)) +#define set_icon(self,icon_name) (gtk_entry_set_icon_from_icon_name (self->entry, GTK_ENTRY_ICON_SECONDARY, icon_name)) /** * SECTION:vn-completion @@ -57,16 +57,16 @@ VnField * vn_completion_new (DbModel * model, const gchar * field) //+++++++++++++++++++++++++++++++++++++++++++++++++++ Private -static void vn_completion_cb_status_changed (DbModel * model, - DbModelStatus status, VnCompletion * obj) +static void vn_completion_on_status_changed (DbModel * model, + DbModelStatus status, VnCompletion * self) { const gchar * icon_name; if (status == DB_MODEL_STATUS_READY) { GtkTreeModel * tree = GTK_TREE_MODEL (vn_grid_model_new (model)); - gtk_entry_completion_set_model (obj->completion, tree); - g_signal_emit_by_name (obj->entry, "changed"); + gtk_entry_completion_set_model (self->completion, tree); + g_signal_emit_by_name (self->entry, "changed"); g_object_unref (tree); icon_name = NULL; } @@ -84,63 +84,63 @@ static void vn_completion_cb_status_changed (DbModel * model, icon_name = NULL; } - gtk_entry_completion_set_model (obj->completion, NULL); + gtk_entry_completion_set_model (self->completion, NULL); } - set_icon (obj, icon_name); + set_icon (self, icon_name); } -static void vn_completion_cb_changed (GtkEditable * entry, VnCompletion * obj) +static void vn_completion_on_changed (GtkEditable * entry, VnCompletion * self) { const gchar * text = gtk_entry_get_text (GTK_ENTRY (entry)); - if (obj->invalid) + if (self->invalid) { - obj->invalid = FALSE; - set_icon (obj, NULL); + self->invalid = FALSE; + set_icon (self, NULL); } - if (obj->model && strlen (text) == 1 - && (!obj->last_match || g_strcmp0 (text, obj->last_match))) + if (self->model && strlen (text) == 1 + && (!self->last_match || g_strcmp0 (text, self->last_match))) { gchar * pattern; GValue value = G_VALUE_INIT; - set_icon (obj, "edit-find-symbolic"); + set_icon (self, "edit-find-symbolic"); - g_free (obj->last_match); - obj->last_match = g_strdup (text); + g_free (self->last_match); + self->last_match = g_strdup (text); pattern = g_strconcat (text, "%", NULL); g_value_init (&value, G_TYPE_STRING); g_value_set_string (&value, pattern); - sql_value_set_value (SQL_VALUE (obj->value), &value); + gvn_param_set_value (GVN_PARAM (self->value), &value); g_value_unset (&value); g_free (pattern); } } -static void vn_completion_iter_changed (VnCompletion * obj, DbIter * iter) +static void vn_completion_iter_changed (VnCompletion * self, DbIter * iter) { - const GValue * value = db_model_get_value (obj->model, iter, 0, NULL); + const GValue * value = db_model_get_value (self->model, iter, 0, NULL); if (value) - VN_FIELD_GET_CLASS (obj)->value_changed (VN_FIELD (obj), value); + VN_FIELD_GET_CLASS (self)->value_changed (VN_FIELD (self), value); - set_icon (obj, "gtk-apply"); + set_icon (self, "gtk-apply"); } -static void vn_completion_cb_activate (GtkEntry * entry, VnCompletion * obj) +static void vn_completion_on_activate (GtkEntry * entry, VnCompletion * self) { gboolean ok = FALSE; const gchar * text = gtk_entry_get_text (entry); if (text && g_strcmp0 (text, "")) { - DbModel * model = obj->model; + DbModel * model = self->model; - if (db_model_get_column_type (model, obj->column) == G_TYPE_STRING) + if (db_model_get_column_type (model, self->column) == G_TYPE_STRING) { DbIter iter; const GValue * v; @@ -148,12 +148,12 @@ static void vn_completion_cb_activate (GtkEntry * entry, VnCompletion * obj) if (db_model_get_iter_first (model, &iter)) { do { - v = db_model_get_value (model, &iter, obj->column, NULL); + v = db_model_get_value (model, &iter, self->column, NULL); if (!gvn_value_is_null (v) && !g_ascii_strcasecmp (g_value_get_string (v), text)) { - vn_completion_iter_changed (obj, &iter); + vn_completion_iter_changed (self, &iter); ok = TRUE; } } @@ -167,38 +167,38 @@ static void vn_completion_cb_activate (GtkEntry * entry, VnCompletion * obj) GValue value = G_VALUE_INIT; g_value_init (&value, GVN_TYPE_NULL); - VN_FIELD_GET_CLASS (obj)->value_changed (VN_FIELD (obj), &value); + VN_FIELD_GET_CLASS (self)->value_changed (VN_FIELD (self), &value); g_value_unset (&value); if (g_strcmp0 (text, "")) { - obj->invalid = TRUE; - set_icon (obj, "edit-delete"); + self->invalid = TRUE; + set_icon (self, "edit-delete"); } else - set_icon (obj, NULL); + set_icon (self, NULL); } } static gboolean vn_completion_match_selected (GtkEntryCompletion * completion, - GtkTreeModel * model, GtkTreeIter * tree_iter, VnCompletion * obj) + GtkTreeModel * model, GtkTreeIter * tree_iter, VnCompletion * self) { DbIter iter; vn_gtk_tree_iter_to_db_iter (tree_iter, &iter); - vn_completion_iter_changed (obj, &iter); + vn_completion_iter_changed (self, &iter); return FALSE; } -static void vn_completion_substitute (VnCompletion * obj) +static void vn_completion_substitute (VnCompletion * self) { SqlObject * field; SqlObject * like; SqlBatch * batch; SqlList * operands; - if (!(obj->model && obj->field)) + if (!(self->model && self->field)) return; like = sql_operation_new (SQL_OPERATION_TYPE_LIKE); @@ -206,38 +206,38 @@ static void vn_completion_substitute (VnCompletion * obj) operands = sql_list_new (SQL_TYPE_EXPR); g_object_set (like, "operands", operands, NULL); - field = sql_field_new (obj->field); + field = sql_field_new (self->field); sql_list_add (operands, field); - obj->value = sql_value_new (); - sql_list_add (operands, obj->value); + self->value = sql_value_new (); + sql_list_add (operands, self->value); batch = sql_batch_new (); sql_batch_add (batch, "field", field); sql_batch_add (batch, "filter", like); - db_model_set_batch (obj->model, batch); + db_model_set_batch (self->model, batch); } -static void vn_completion_set_field (VnCompletion * obj, gchar * field) +static void vn_completion_set_field (VnCompletion * self, gchar * field) { - obj->field = field; - vn_completion_substitute (obj); + self->field = field; + vn_completion_substitute (self); } //+++++++++++++++++++++++++++++++++++++++++++++++++ DbModelHolder implementation -static DbModel * vn_completion_get_model (VnCompletion * obj) +static DbModel * vn_completion_get_model (VnCompletion * self) { - return obj->model; + return self->model; } -static void vn_completion_set_model (VnCompletion * obj, DbModel * model) +static void vn_completion_set_model (VnCompletion * self, DbModel * model) { - obj->model = model; - g_signal_connect (obj->model, "status-changed", - G_CALLBACK (vn_completion_cb_status_changed), obj); + self->model = model; + g_signal_connect (self->model, "status-changed", + G_CALLBACK (vn_completion_on_status_changed), self); - vn_completion_substitute (obj); + vn_completion_substitute (self); } //+++++++++++++++++++++++++++++++++++++++++++++++++++ Properties @@ -248,74 +248,76 @@ enum ,PROP_FIELD }; -static void vn_completion_set_property (VnCompletion * obj, guint property_id, +static void vn_completion_set_property (VnCompletion * self, guint property_id, const GValue * value, GParamSpec * pspec) { switch (property_id) { case PROP_MODEL: - vn_completion_set_model (obj, g_value_dup_object (value)); + vn_completion_set_model (self, g_value_dup_object (value)); break; case PROP_FIELD: - vn_completion_set_field (obj, g_value_dup_string (value)); + vn_completion_set_field (self, g_value_dup_string (value)); break; default: - G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, property_id, pspec); + G_OBJECT_WARN_INVALID_PROPERTY_ID (self, property_id, pspec); } } -static void vn_completion_get_property (VnCompletion * obj, guint property_id, +static void vn_completion_get_property (VnCompletion * self, guint property_id, GValue * value, GParamSpec * pspec) { switch (property_id) { case PROP_MODEL: - g_value_set_object (value, obj->model); + g_value_set_object (value, self->model); break; default: - G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, property_id, pspec); + G_OBJECT_WARN_INVALID_PROPERTY_ID (self, property_id, pspec); } } //+++++++++++++++++++++++++++++++++++++++++++++++++++ Class -static void vn_completion_init (VnCompletion * obj) +static void vn_completion_init (VnCompletion * self) { GtkEntryCompletion * completion; - obj->field = NULL; - obj->last_match = NULL; - obj->invalid = FALSE; - obj->column = 1; + self->field = NULL; + self->last_match = NULL; + self->invalid = FALSE; + self->column = 1; - obj->entry = GTK_ENTRY (gtk_entry_new ()); - gtk_entry_set_icon_sensitive (obj->entry, GTK_ENTRY_ICON_SECONDARY, FALSE); - g_object_connect (obj->entry, - "signal::changed", vn_completion_cb_changed, obj - ,"signal::activate", vn_completion_cb_activate, obj + self->entry = GTK_ENTRY (gtk_entry_new ()); + gtk_entry_set_icon_sensitive (self->entry, GTK_ENTRY_ICON_SECONDARY, FALSE); + g_object_connect (self->entry, + "signal::changed", vn_completion_on_changed, self + ,"signal::activate", vn_completion_on_activate, self ,NULL ); - gtk_container_add (GTK_CONTAINER (obj), GTK_WIDGET (obj->entry)); - VN_FIELD (obj)->field = GTK_WIDGET (obj->entry); + gtk_container_add (GTK_CONTAINER (self), GTK_WIDGET (self->entry)); completion = gtk_entry_completion_new (); gtk_entry_completion_set_minimum_key_length (completion, 1); - gtk_entry_completion_set_text_column (completion, obj->column); + gtk_entry_completion_set_text_column (completion, self->column); gtk_entry_completion_set_inline_selection (completion, FALSE); // gtk_entry_completion_set_inline_completion (completion, TRUE); g_signal_connect (completion, "match-selected", - G_CALLBACK (vn_completion_match_selected), obj); - gtk_entry_set_completion (obj->entry, completion); - obj->completion = completion; + G_CALLBACK (vn_completion_match_selected), self); + gtk_entry_set_completion (self->entry, completion); + self->completion = completion; + + VN_FIELD_GET_CLASS (self)->set_widget (VN_FIELD (self), + GTK_WIDGET (self->entry)); } -static void vn_completion_finalize (VnCompletion * obj) +static void vn_completion_finalize (VnCompletion * self) { - g_free (obj->field); - g_free (obj->last_match); - g_object_unref (obj->completion); - g_object_unref (obj->model); - G_OBJECT_CLASS (vn_completion_parent_class)->finalize (G_OBJECT (obj)); + g_free (self->field); + g_free (self->last_match); + g_object_unref (self->completion); + g_object_unref (self->model); + G_OBJECT_CLASS (vn_completion_parent_class)->finalize (G_OBJECT (self)); } static void vn_completion_class_init (VnCompletionClass * klass) diff --git a/vn/field/vn-http-image.c b/vn/field/vn-http-image.c index 4821b90..a4787a8 100644 --- a/vn/field/vn-http-image.c +++ b/vn/field/vn-http-image.c @@ -25,9 +25,9 @@ */ #define SET_ICON(img, msg) \ g_object_set \ - (obj->priv->image, "icon-name", img, \ + (self->priv->image, "icon-name", img, \ "icon-size", GTK_ICON_SIZE_MENU, NULL); \ - gtk_widget_set_tooltip_text (GTK_WIDGET (obj->priv->image), msg) + gtk_widget_set_tooltip_text (GTK_WIDGET (self->priv->image), msg) /** * SECTION: vn-http-image @@ -65,22 +65,22 @@ VnField * vn_http_image_new (DbFileLoader * loader, const gchar * name) return g_object_new (VN_TYPE_HTTP_IMAGE, "name", name, "loader", loader, NULL); } -static void vn_http_image_cb_error (VnHttpImage * obj, const GError * error) +static void vn_http_image_on_error (VnHttpImage * self, const GError * error) { gchar * msg = error ? error->message : _("Undefined error"); - const gchar * name = g_value_get_string (vn_field_get_value (VN_FIELD (obj))); - g_warning ("VnHttpImage (%s%s): %s", obj->priv->path, name, msg); + const gchar * name = g_value_get_string (gvn_param_get_value (GVN_PARAM (self))); + g_warning ("VnHttpImage (%s%s): %s", self->priv->path, name, msg); SET_ICON ("missing-image", msg); - g_object_unref (obj); + g_object_unref (self); } -static void vn_http_image_cb_download - (DbFileLoader * fl, GBytes * bytes, const GError * error, VnHttpImage * obj) +static void vn_http_image_on_download + (DbFileLoader * fl, GBytes * bytes, const GError * error, VnHttpImage * self) { - gtk_widget_set_tooltip_text (GTK_WIDGET (obj->priv->image), NULL); + gtk_widget_set_tooltip_text (GTK_WIDGET (self->priv->image), NULL); if (error) - vn_http_image_cb_error (obj, error); + vn_http_image_on_error (self, error); else if (bytes) { gsize len; @@ -92,33 +92,33 @@ static void vn_http_image_cb_download && gdk_pixbuf_loader_close (loader, &err)) { GdkPixbuf * pixbuf = gdk_pixbuf_loader_get_pixbuf (loader); - gtk_image_set_from_pixbuf (obj->priv->image, pixbuf); - obj->priv->bytes = g_bytes_ref (bytes); + gtk_image_set_from_pixbuf (self->priv->image, pixbuf); + self->priv->bytes = g_bytes_ref (bytes); } else { - vn_http_image_cb_error (obj, err); + vn_http_image_on_error (self, err); g_error_free (err); } g_object_unref (loader); } - g_object_unref (obj); + g_object_unref (self); } /* -static void vn_http_image_cb_upload - (DbFileLoader * loader, GBytes * data, GError * error, VnHttpImage * obj) +static void vn_http_image_on_upload + (DbFileLoader * loader, GBytes * data, GError * error, VnHttpImage * self) {} */ -static void vn_http_image_set_value (VnHttpImage * obj, const GValue * value) +static void vn_http_image_set_value (VnHttpImage * self, const GValue * value) { - gchar * full_path = g_strconcat (obj->priv->path, "/", + gchar * full_path = g_strconcat (self->priv->path, "/", g_value_get_string (value), NULL); SET_ICON ("view-refresh", _("Loading")); - db_file_loader_download (obj->priv->loader, full_path, - (DbFileLoaderCallbackFunc) vn_http_image_cb_download, g_object_ref (obj)); + db_file_loader_download (self->priv->loader, full_path, + (DbFileLoaderCallbackFunc) vn_http_image_on_download, g_object_ref (self)); g_free (full_path); } @@ -131,69 +131,70 @@ enum ,PROP_BYTES }; -static void vn_http_image_set_property (VnHttpImage * obj, guint id, +static void vn_http_image_set_property (VnHttpImage * self, guint id, const GValue * value, GParamSpec * pspec) { switch (id) { case PROP_PATH: - g_free (obj->priv->path); - obj->priv->path = g_value_dup_string (value); + g_free (self->priv->path); + self->priv->path = g_value_dup_string (value); break; case PROP_LOADER: - if (obj->priv->loader) + if (self->priv->loader) g_warning (_("File loader already set")); else - obj->priv->loader = g_value_dup_object (value); + self->priv->loader = g_value_dup_object (value); break; default: - G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, id, pspec); + G_OBJECT_WARN_INVALID_PROPERTY_ID (self, id, pspec); } } -static void vn_http_image_get_property (VnHttpImage * obj, guint id, +static void vn_http_image_get_property (VnHttpImage * self, guint id, GValue * value, GParamSpec * pspec) { switch (id) { case PROP_PATH: - g_value_set_string (value, obj->priv->path); + g_value_set_string (value, self->priv->path); break; case PROP_LOADER: - g_value_set_object (value, obj->priv->loader); + g_value_set_object (value, self->priv->loader); break; case PROP_BYTES: - g_value_set_boxed (value, obj->priv->bytes); + g_value_set_boxed (value, self->priv->bytes); default: - G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, id, pspec); + G_OBJECT_WARN_INVALID_PROPERTY_ID (self, id, pspec); } } //+++++++++++++++++++++++++++++++++++++++++++++++++++ Class -static void vn_http_image_init (VnHttpImage * obj) +static void vn_http_image_init (VnHttpImage * self) { - obj->priv = G_TYPE_INSTANCE_GET_PRIVATE - (obj, VN_TYPE_HTTP_IMAGE, VnHttpImagePrivate); + self->priv = G_TYPE_INSTANCE_GET_PRIVATE + (self, VN_TYPE_HTTP_IMAGE, VnHttpImagePrivate); - obj->priv->path = g_strdup (""); - obj->priv->loader = NULL; - obj->priv->image = g_object_ref_sink (GTK_IMAGE (gtk_image_new ())); + self->priv->path = g_strdup (""); + self->priv->loader = NULL; + self->priv->image = g_object_ref_sink (GTK_IMAGE (gtk_image_new ())); //Se usará para subir imagenes y cambiar nombres, o abrir un menu contextual -// g_signal_connect (obj, "event", G_CALLBACK (vn_http_image_cb_event), obj); +// g_signal_connect (self, "event", G_CALLBACK (vn_http_image_on_event), self); SET_ICON ("missing-image", _("No image set")); - gtk_container_add (GTK_CONTAINER (obj), GTK_WIDGET (obj->priv->image)); - - VN_FIELD (obj)->field = GTK_WIDGET (obj->priv->image); + gtk_container_add (GTK_CONTAINER (self), GTK_WIDGET (self->priv->image)); + + VN_FIELD_GET_CLASS (self)->set_widget (VN_FIELD (self), + GTK_WIDGET (self->priv->image)); } -static void vn_http_image_finalize (VnHttpImage * obj) +static void vn_http_image_finalize (VnHttpImage * self) { - g_clear_object (&obj->priv->loader); - g_free (obj->priv->path); - g_bytes_unref (obj->priv->bytes); - g_object_unref (obj->priv->image); - G_OBJECT_CLASS (vn_http_image_parent_class)->finalize (G_OBJECT (obj)); + g_clear_object (&self->priv->loader); + g_free (self->priv->path); + g_bytes_unref (self->priv->bytes); + g_object_unref (self->priv->image); + G_OBJECT_CLASS (vn_http_image_parent_class)->finalize (G_OBJECT (self)); } static void vn_http_image_class_init (VnHttpImageClass * klass) diff --git a/vn/gui/login.glade b/vn/gui/login.glade index 2bae679..11f0282 100644 --- a/vn/gui/login.glade +++ b/vn/gui/login.glade @@ -10,7 +10,7 @@ False center ../image/icon.svg - + True @@ -111,8 +111,8 @@ ● edit-find-symbolic Press here to see the password - - + + 1 @@ -156,7 +156,7 @@ False True True - + False @@ -171,7 +171,7 @@ True True True - + @@ -217,7 +217,7 @@ True True True - + False @@ -232,7 +232,7 @@ True True True - + diff --git a/vn/vn-field.c b/vn/vn-field.c index 421b172..a9facaf 100644 --- a/vn/vn-field.c +++ b/vn/vn-field.c @@ -17,23 +17,20 @@ #include "vn-field.h" -static void vn_field_buildable_init (GtkBuildableIface * iface); +static void vn_field_param_init (GvnParamInterface * iface); +static void vn_field_buildable_init (GtkBuildableIface * iface); +static void vn_field_on_master_value_changed (GvnParam * master, const GValue * value, VnField * self); G_DEFINE_ABSTRACT_TYPE_WITH_CODE (VnField, vn_field, GTK_TYPE_EVENT_BOX, + G_IMPLEMENT_INTERFACE (GVN_TYPE_PARAM, + vn_field_param_init) G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE, vn_field_buildable_init) ); -enum { - VALUE_CHANGED - ,LAST_SIGNAL -}; - -static guint signals[LAST_SIGNAL] = {0}; - /** * VnFieldStyleFunc: - * @obj: a #VnField + * @self: a #VnField * @widget: the #GtkWidget held by the field * @value: (transfer none): the current value in the cell * @@ -42,199 +39,173 @@ static guint signals[LAST_SIGNAL] = {0}; //+++++++++++++++++++++++++++++++++++++++++++++++++++ Private -static void vn_field_spec_changed (VnField * obj) -{ - gvn_param_spec_unset (obj->spec); - gvn_param_spec_merge (obj->spec, obj->user_spec); - - if (obj->param) - gvn_param_spec_merge (obj->spec, - gvn_param_get_spec (obj->param)); -} - -static void vn_field_on_param_spec_changed (GvnParam * param, VnField * obj) -{ - vn_field_spec_changed (obj); -} - -static void vn_field_on_param_value_changed (GvnParam * param, const GValue * value, VnField * obj) -{ - obj->update_param = FALSE; - vn_field_set_value (obj, value); - obj->update_param = TRUE; -} - -static void vn_field_set_invalid (VnField * obj, const GError * err) +static void vn_field_set_invalid (VnField * self, const GError * err) { /* GdkRGBA color = {0.95, 0.8, 0.8, 1}; - gtk_widget_override_background_color (GTK_WIDGET (obj->field), + gtk_widget_override_background_color (GTK_WIDGET (self->widget), GTK_STATE_FLAG_NORMAL, &color); -*/} - -static void vn_field_on_param_status_changed (GvnParam * param, VnField * obj) -{ - switch (gvn_param_get_status (param)) - { - case GVN_PARAM_STATUS_OK: - gtk_widget_set_sensitive (obj->field, TRUE); - break; - case GVN_PARAM_STATUS_BUSY: - gtk_widget_set_sensitive (obj->field, FALSE); - break; - case GVN_PARAM_STATUS_ERROR: - vn_field_set_invalid (obj, gvn_param_get_error (param)); - break; - } +*/ } -static void vn_field_changed (VnField * obj) +static void vn_field_update_widget (VnField * self) { - if (obj->param && obj->update_param) + self->lock_changed_done = TRUE; + + if (VN_FIELD_GET_CLASS (self)->set_value) + VN_FIELD_GET_CLASS (self)->set_value (self, self->value); + + self->lock_changed_done = FALSE; +} + +static void vn_field_changed (VnField * self) +{ + g_signal_emit_by_name (self, "value-changed", self->value); + + if (self->master && self->change_master) { GError * err = NULL; - g_signal_handlers_block_by_func (obj->param, - vn_field_on_param_value_changed, obj); + self->change_master = FALSE; - if (!gvn_param_set_value (obj->param, obj->value, &err)) + if (!gvn_param_request_value (self->master, self->value, &err)) { - vn_field_set_invalid (obj, err); + vn_field_set_invalid (self, err); g_error_free (err); } - g_signal_handlers_unblock_by_func (obj->param, - vn_field_on_param_value_changed, obj); + self->change_master = TRUE; } - if (obj->style_func) - obj->style_func (obj, obj->field, obj->value); - - g_signal_emit (obj, signals[VALUE_CHANGED], 0, obj->value); + if (self->style_func) + self->style_func (self, self->widget, self->value); } -static void vn_field_value_changed (VnField * obj, const GValue * value) +static void vn_field_value_changed (VnField * self, const GValue * value) { GType type; gboolean changed; - if (obj->lock_changed_done) + if (self->lock_changed_done) return; - type = gvn_param_spec_get_gtype (obj->spec); + type = gvn_param_spec_get_gtype (self->spec); if (type != G_TYPE_NONE && !gvn_value_is_null (value)) { - if (G_VALUE_TYPE (obj->value) != type) + if (G_VALUE_TYPE (self->value) != type) { - g_value_unset (obj->value); - g_value_init (obj->value, type); + g_value_unset (self->value); + g_value_init (self->value, type); } - g_value_transform (value, obj->value); + g_value_transform (value, self->value); changed = TRUE; } else - changed = gvn_value_ccopy (value, obj->value); + changed = gvn_value_ccopy (value, self->value); if (changed) - vn_field_changed (obj); + vn_field_changed (self); } -static void vn_field_make_param (VnField * obj) +static void vn_field_spec_changed (VnField * self) { - GvnParam * param; + gvn_param_spec_unset (self->spec); + gvn_param_spec_merge (self->spec, self->user_spec); + + if (self->master) + gvn_param_spec_merge (self->spec, + gvn_param_get_spec (self->master)); - if (!obj->iterator || !obj->column_name) + g_signal_emit_by_name (self, "spec-changed"); +} + +static void vn_field_set_value (VnField * self, const GValue * value) +{ + if (!gvn_value_ccopy (value, self->value)) return; - param = db_iterator_get_param (obj->iterator, obj->column_name); - vn_field_set_param (obj, param); + vn_field_update_widget (self); + vn_field_changed (self); } -//+++++++++++++++++++++++++++++++++++++++++++++++++++ Public - -/** - * vn_field_get_value: - * @obj: the #VnField - * - * Gets the current field value. - * - * Return value: (transfer none): the #GValue - **/ -const GValue * vn_field_get_value (VnField * obj) +static const GValue * vn_field_get_value (VnField * self) { - return obj->value; + return self->value; } -/** - * vn_field_set_value: - * @obj: the #VnField - * @value: a #GValue - * - * Sets the field value. - **/ -void vn_field_set_value (VnField * obj, const GValue * value) +static gboolean vn_field_request_value (VnField * self, const GValue * value, GError ** err) { - g_return_if_fail (VN_IS_FIELD (obj)); - g_return_if_fail (G_IS_VALUE (value)); - - if (gvn_value_ccopy (value, obj->value)) + if (gvn_param_spec_validate (self->spec, value, err)) { - obj->lock_changed_done = TRUE; - VN_FIELD_GET_CLASS (obj)->set_value (obj, obj->value); - obj->lock_changed_done = FALSE; - vn_field_changed (obj); + vn_field_set_value (self, value); + return TRUE; + } + + return FALSE; +} + +static void vn_field_on_master_value_changed (GvnParam * master, const GValue * value, VnField * self) +{ + if (self->change_master) + { + self->change_master = FALSE; + vn_field_set_value (self, value); + self->change_master = TRUE; } } -/** - * vn_field_get_param: - * @obj: the #VnField - * - * Return value: (transfer none): -**/ -GvnParam * vn_field_get_param (VnField * obj) +static void vn_field_on_master_spec_changed (GvnParam * master, VnField * self) { - g_return_val_if_fail (VN_IS_FIELD (obj), NULL); - - return obj->param; + vn_field_spec_changed (self); } -/** - * vn_field_set_param: - * @obj: the #VnField - * @param: a #GvnParam - * - * Binds the field with a #GvnParam. - **/ -void vn_field_set_param (VnField * obj, GvnParam * param) +static void vn_field_on_master_status_changed (GvnParam * master, VnField * self) { - g_return_if_fail (VN_IS_FIELD (obj)); - g_return_if_fail (GVN_IS_PARAM (param) || !param); - - if (obj->param) + switch (gvn_param_get_status (master)) { - g_object_disconnect (obj->param - ,"any_signal", vn_field_on_param_value_changed, obj - ,"any_signal", vn_field_on_param_spec_changed, obj - ,"any_signal", vn_field_on_param_status_changed, obj - ,NULL - ); - g_clear_object (&obj->param); + case GVN_PARAM_STATUS_OK: + gtk_widget_set_sensitive (self->widget, TRUE); + break; + case GVN_PARAM_STATUS_BUSY: + gtk_widget_set_sensitive (self->widget, FALSE); + break; + case GVN_PARAM_STATUS_ERROR: +// vn_field_set_invalid (self, gvn_param_get_error (master)); + break; } - if (param) +} + +static GvnParam * vn_field_get_master (VnField * self) +{ + return self->master; +} + +void vn_field_set_master (VnField * self, GvnParam * master) +{ + if (self->master) { - obj->param = g_object_ref_sink (param); - g_object_connect (param - ,"signal::value-changed", vn_field_on_param_value_changed, obj - ,"signal::spec-changed", vn_field_on_param_spec_changed, obj - ,"signal::status-changed", vn_field_on_param_status_changed, obj + g_object_disconnect (self->master + ,"any_signal", vn_field_on_master_value_changed, self + ,"any_signal", vn_field_on_master_spec_changed, self + ,"any_signal", vn_field_on_master_status_changed, self ,NULL ); - vn_field_on_param_spec_changed (param, obj); - vn_field_on_param_value_changed (param, - gvn_param_get_value (param), obj); - vn_field_on_param_status_changed (param, obj); + g_clear_object (&self->master); + } + if (master) + { + self->master = g_object_ref_sink (master); + g_object_connect (master + ,"signal::value-changed", vn_field_on_master_value_changed, self + ,"signal::spec-changed", vn_field_on_master_spec_changed, self + ,"signal::status-changed", vn_field_on_master_status_changed, self + ,NULL + ); + vn_field_on_master_spec_changed (master, self); + vn_field_on_master_value_changed (master, + gvn_param_get_value (master), self); + vn_field_on_master_status_changed (master, self); } /* GFile * css = g_file_new_for_path ("vn/gui/style.css"); @@ -247,7 +218,7 @@ void vn_field_set_param (VnField * obj, GvnParam * param) if (gtk_css_provider_load_from_file (provider, css, &err)) { GtkStyleContext * style; - style = gtk_widget_get_style_context (GTK_WIDGET (obj->field)); + style = gtk_widget_get_style_context (GTK_WIDGET (self->widget)); gtk_style_context_add_provider (style, GTK_STYLE_PROVIDER (provider), GTK_STYLE_PROVIDER_PRIORITY_USER); gtk_style_context_add_class (style, "invalid"); @@ -265,152 +236,181 @@ void vn_field_set_param (VnField * obj, GvnParam * param) */ } +static const GvnParamSpec * vn_field_get_spec (VnField * self) +{ + return self->spec; +} + +static GvnParamStatus vn_field_get_status (VnField * self) +{ + return GVN_PARAM_STATUS_OK; +} + +static void vn_field_make_param (VnField * self) +{ + GvnParam * param; + + if (!self->iterator || !self->column_name) + return; + + param = db_iterator_get_param (self->iterator, self->column_name); + vn_field_set_master (self, param); +} + +static void vn_field_set_widget (VnField * self, GtkWidget * widget) +{ + self->widget = widget; + vn_field_update_widget (self); +} + +//+++++++++++++++++++++++++++++++++++++++++++++++++++ Public + /** * vn_field_get_gtype: - * @obj: the #VnField + * @self: the #VnField * * Gets the field type. * * Return value: the field type or %G_TYPE_NONE if it havent. **/ -GType vn_field_get_gtype (VnField * obj) +GType vn_field_get_gtype (VnField * self) { - g_return_val_if_fail (VN_IS_FIELD (obj), G_TYPE_INVALID); + g_return_val_if_fail (VN_IS_FIELD (self), G_TYPE_INVALID); - return gvn_param_spec_get_gtype (obj->spec); + return gvn_param_spec_get_gtype (self->spec); } /** * vn_field_set_gtype: - * @obj: the #VnField + * @self: the #VnField * @type: a valid #GType * * Sets the type of the field. When you set a value, it will be converted to * this type. **/ -void vn_field_set_gtype (VnField * obj, GType type) +void vn_field_set_gtype (VnField * self, GType type) { - g_return_if_fail (VN_IS_FIELD (obj)); + g_return_if_fail (VN_IS_FIELD (self)); - gvn_param_spec_set_gtype (obj->user_spec, type); - vn_field_spec_changed (obj); + gvn_param_spec_set_gtype (self->user_spec, type); + vn_field_spec_changed (self); } /** * vn_field_get_null: - * @obj: the #VnField + * @self: the #VnField * * If field allows values with %GVN_TYPE_NULL type. * * Return value: %TRUE if it can, %FALSE otherwise. **/ -gboolean vn_field_get_null (VnField * obj) +gboolean vn_field_get_null (VnField * self) { - g_return_val_if_fail (VN_IS_FIELD (obj), FALSE); + g_return_val_if_fail (VN_IS_FIELD (self), FALSE); - return gvn_param_spec_get_null (obj->spec); + return gvn_param_spec_get_null (self->spec); } /** * vn_field_set_null: - * @obj: the #VnField + * @self: the #VnField * @null: %TRUE if field should accept NULL values * * Sets if field allows values with %GVN_TYPE_NULL type. If param property of * the field is set, this attribute will be merged with the same #GvnParam * attribute, remaining the most restrictive. **/ -void vn_field_set_null (VnField * obj, gboolean null) +void vn_field_set_null (VnField * self, gboolean null) { - g_return_if_fail (VN_IS_FIELD (obj)); + g_return_if_fail (VN_IS_FIELD (self)); - gvn_param_spec_set_null (obj->user_spec, null); - vn_field_spec_changed (obj); + gvn_param_spec_set_null (self->user_spec, null); + vn_field_spec_changed (self); } /** * vn_field_get_editable: - * @obj: the #VnField + * @self: the #VnField * * Gets whether the field value can be modified. * * Return value: %TRUE if field value can be edited, %FALSE otherwise. **/ -gboolean vn_field_get_editable (VnField * obj) +gboolean vn_field_get_editable (VnField * self) { - g_return_val_if_fail (VN_IS_FIELD (obj), FALSE); + g_return_val_if_fail (VN_IS_FIELD (self), FALSE); - return gvn_param_spec_get_editable (obj->spec); + return gvn_param_spec_get_editable (self->spec); } /** * vn_field_set_editable: - * @obj: the #VnField + * @self: the #VnField * @editable: %TRUE if field can be editable * * Sets if field value can be modified. If param property of * the field is set, this attribute will be merged with the same #GvnParam * attribute, remaining the most restrictive. **/ -void vn_field_set_editable (VnField * obj, gboolean editable) +void vn_field_set_editable (VnField * self, gboolean editable) { - g_return_if_fail (VN_IS_FIELD (obj)); + g_return_if_fail (VN_IS_FIELD (self)); - gvn_param_spec_set_editable (obj->user_spec, editable); - vn_field_spec_changed (obj); + gvn_param_spec_set_editable (self->user_spec, editable); + vn_field_spec_changed (self); } /** * vn_field_get_default: - * @obj: the #VnField + * @self: the #VnField **/ -const GValue * vn_field_get_default (VnField * obj) +const GValue * vn_field_get_default (VnField * self) { - g_return_val_if_fail (VN_IS_FIELD (obj), NULL); + g_return_val_if_fail (VN_IS_FIELD (self), NULL); - return gvn_param_spec_get_default (obj->spec); + return gvn_param_spec_get_default (self->spec); } /** * vn_field_set_default: - * @obj: the #VnField + * @self: the #VnField * @def: the default #GValue * * Sets the default value of the field. **/ -void vn_field_set_default (VnField * obj, const GValue * def) +void vn_field_set_default (VnField * self, const GValue * def) { - g_return_if_fail (VN_IS_FIELD (obj)); + g_return_if_fail (VN_IS_FIELD (self)); - gvn_param_spec_set_default (obj->user_spec, def); - vn_field_spec_changed (obj); + gvn_param_spec_set_default (self->user_spec, def); + vn_field_spec_changed (self); } /** * vn_field_set_to_default: - * @obj: the #VnField + * @self: the #VnField **/ -void vn_field_set_to_default (VnField * obj) +void vn_field_set_to_default (VnField * self) { - g_return_if_fail (VN_IS_FIELD (obj)); + g_return_if_fail (VN_IS_FIELD (self)); - vn_field_set_value (obj, - gvn_param_spec_get_default (obj->spec)); + vn_field_set_value (self, + gvn_param_spec_get_default (self->spec)); } /** * vn_field_get_widget: - * @obj: the #VnField + * @self: the #VnField * - * Gets the internal widget of @obj. + * Gets the internal widget of @self. * * Return value: (transfer none): the widget **/ -GtkWidget * vn_field_get_widget (VnField * obj) +GtkWidget * vn_field_get_widget (VnField * self) { - g_return_if_fail (VN_IS_FIELD (obj)); + g_return_if_fail (VN_IS_FIELD (self)); - return obj->field; + return self->widget; } //+++++++++++++++++++++++++++++++++++++++++++++++++++ Buildable @@ -430,7 +430,7 @@ static GObject * vn_field_buildable_get_internal_child (GtkBuildable * buildable enum { PROP_VALUE = 1 - ,PROP_PARAM + ,PROP_MASTER ,PROP_ITERATOR ,PROP_COLUMN_NAME ,PROP_GTYPE @@ -440,122 +440,116 @@ enum ,PROP_STYLE_FUNC }; -static void vn_field_set_property (VnField * obj, guint id, +static void vn_field_set_property (VnField * self, guint id, const GValue * value, GParamSpec * pspec) { switch (id) { case PROP_VALUE: - vn_field_set_value (obj, g_value_get_boxed (value)); + vn_field_set_value (self, g_value_get_boxed (value)); break; - case PROP_PARAM: - vn_field_set_param (obj, g_value_get_object (value)); + case PROP_MASTER: + vn_field_set_master (self, g_value_get_object (value)); break; case PROP_ITERATOR: - g_clear_object (&obj->iterator); - obj->iterator = g_value_dup_object (value); - vn_field_make_param (obj); + g_clear_object (&self->iterator); + self->iterator = g_value_dup_object (value); + vn_field_make_param (self); break; case PROP_COLUMN_NAME: - g_free (obj->column_name); - obj->column_name = g_value_dup_string (value); - vn_field_make_param (obj); + g_free (self->column_name); + self->column_name = g_value_dup_string (value); + vn_field_make_param (self); break; case PROP_GTYPE: - vn_field_set_gtype (obj, g_value_get_gtype (value)); + vn_field_set_gtype (self, g_value_get_gtype (value)); break; case PROP_EDITABLE: - vn_field_set_editable (obj, g_value_get_boolean (value)); + vn_field_set_editable (self, g_value_get_boolean (value)); break; case PROP_NULL: - vn_field_set_null (obj, g_value_get_boolean (value)); + vn_field_set_null (self, g_value_get_boolean (value)); break; case PROP_DEFAULT: - vn_field_set_default (obj, g_value_get_boxed (value)); + vn_field_set_default (self, g_value_get_boxed (value)); break; case PROP_STYLE_FUNC: - obj->style_func = g_value_get_pointer (value); + self->style_func = g_value_get_pointer (value); break; default: - G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, id, pspec); + G_OBJECT_WARN_INVALID_PROPERTY_ID (self, id, pspec); } } -static void vn_field_get_property (VnField * obj, guint id, +static void vn_field_get_property (VnField * self, guint id, GValue * value, GParamSpec * pspec) { switch (id) { case PROP_VALUE: - g_value_set_boxed (value, obj->value); + g_value_set_boxed (value, self->value); break; - case PROP_PARAM: - g_value_set_object (value, obj->param); + case PROP_MASTER: + g_value_set_object (value, self->master); break; case PROP_ITERATOR: - g_value_set_object (value, obj->iterator); + g_value_set_object (value, self->iterator); break; case PROP_COLUMN_NAME: - g_value_set_string (value, obj->column_name); + g_value_set_string (value, self->column_name); break; case PROP_GTYPE: - g_value_set_gtype (value, vn_field_get_gtype (obj)); + g_value_set_gtype (value, vn_field_get_gtype (self)); break; case PROP_EDITABLE: - g_value_set_boolean (value, vn_field_get_editable (obj)); + g_value_set_boolean (value, vn_field_get_editable (self)); break; case PROP_NULL: - g_value_set_boolean (value, vn_field_get_null (obj)); + g_value_set_boolean (value, vn_field_get_null (self)); break; case PROP_DEFAULT: - g_value_set_boxed (value, vn_field_get_default (obj)); + g_value_set_boxed (value, vn_field_get_default (self)); break; case PROP_STYLE_FUNC: - g_value_set_pointer (value, obj->style_func); + g_value_set_pointer (value, self->style_func); break; default: - G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, id, pspec); + G_OBJECT_WARN_INVALID_PROPERTY_ID (self, id, pspec); } } //+++++++++++++++++++++++++++++++++++++++++++++++++++ Class -static void vn_field_init (VnField * obj) +static void vn_field_init (VnField * self) { GdkRGBA color = {0.0, 0.0, 0.0, 0.0}; - obj->param = NULL; - obj->update_param = TRUE; - obj->lock_changed_done = FALSE; - obj->user_spec = gvn_param_spec_new (); - obj->spec = gvn_param_spec_new (); - obj->iterator = NULL; - obj->column_name = NULL; - obj->style_func = NULL; + self->master = NULL; + self->change_master = TRUE; + self->lock_changed_done = FALSE; + self->user_spec = gvn_param_spec_new (); + self->spec = gvn_param_spec_new (); + self->iterator = NULL; + self->column_name = NULL; + self->style_func = NULL; - obj->value = g_new0 (GValue, 1); - g_value_init (obj->value, GVN_TYPE_NULL); + self->value = g_new0 (GValue, 1); + g_value_init (self->value, GVN_TYPE_NULL); - gtk_widget_override_background_color (GTK_WIDGET (obj), + gtk_widget_override_background_color (GTK_WIDGET (self), GTK_STATE_FLAG_NORMAL, &color); } -static void vn_field_finalize (VnField * obj) +static void vn_field_finalize (VnField * self) { - gvn_param_spec_free (obj->spec); - gvn_param_spec_free (obj->user_spec); - g_clear_object (&obj->iterator); - vn_field_set_param (obj, NULL); - g_value_unset (obj->value); - g_free (obj->value); - g_free (obj->column_name); - G_OBJECT_CLASS (vn_field_parent_class)->finalize (G_OBJECT (obj)); -} - -static void vn_field_buildable_init (GtkBuildableIface * iface) -{ - parent_buildable_iface = g_type_interface_peek_parent (iface); - iface->get_internal_child = vn_field_buildable_get_internal_child; + gvn_param_spec_free (self->spec); + gvn_param_spec_free (self->user_spec); + g_clear_object (&self->iterator); + vn_field_set_master (self, NULL); + g_value_unset (self->value); + g_free (self->value); + g_free (self->column_name); + G_OBJECT_CLASS (vn_field_parent_class)->finalize (G_OBJECT (self)); } static void vn_field_class_init (VnFieldClass * klass) @@ -565,26 +559,11 @@ static void vn_field_class_init (VnFieldClass * klass) k->set_property = (GObjectSetPropertyFunc) vn_field_set_property; k->get_property = (GObjectGetPropertyFunc) vn_field_get_property; klass->value_changed = vn_field_value_changed; + klass->set_widget = vn_field_set_widget; - signals[VALUE_CHANGED] = g_signal_new ("value-changed", - VN_TYPE_FIELD, G_SIGNAL_RUN_FIRST, 0, NULL, NULL, - g_cclosure_marshal_VOID__BOXED, G_TYPE_NONE, 1, G_TYPE_VALUE - ); + g_object_class_override_property (k, PROP_VALUE, "value"); + g_object_class_override_property (k, PROP_MASTER, "master"); - g_object_class_install_property (k, PROP_VALUE, - g_param_spec_boxed ("value" - ,_("Value") - ,_("The current value of the field") - ,G_TYPE_VALUE - ,G_PARAM_READWRITE - )); - g_object_class_install_property (k, PROP_PARAM, - g_param_spec_object ("param" - ,_("Parameter") - ,_("The param where the field can read/write its value") - ,GVN_TYPE_PARAM - ,G_PARAM_READWRITE - )); g_object_class_install_property (k, PROP_ITERATOR, g_param_spec_object ("iterator" ,_("Iterator") @@ -635,3 +614,19 @@ static void vn_field_class_init (VnFieldClass * klass) ,G_PARAM_CONSTRUCT | G_PARAM_READWRITE )); } + +static void vn_field_buildable_init (GtkBuildableIface * iface) +{ + parent_buildable_iface = g_type_interface_peek_parent (iface); + iface->get_internal_child = vn_field_buildable_get_internal_child; +} + +static void vn_field_param_init (GvnParamInterface * iface) +{ + iface->get_value = (GvnParamGetValueFunc) vn_field_get_value; + iface->request_value = (GvnParamRequestValueFunc) vn_field_request_value; + iface->get_master = (GvnParamGetMasterFunc) vn_field_get_master; + iface->set_master = (GvnParamSetMasterFunc) vn_field_set_master; + iface->get_spec = (GvnParamGetSpecFunc) vn_field_get_spec; + iface->get_status = (GvnParamGetStatusFunc) vn_field_get_status; +} diff --git a/vn/vn-field.h b/vn/vn-field.h index c0eea5d..c2c8eda 100644 --- a/vn/vn-field.h +++ b/vn/vn-field.h @@ -21,31 +21,32 @@ #include #include -#define VN_TYPE_FIELD (vn_field_get_type ()) -#define VN_FIELD(obj) (G_TYPE_CHECK_INSTANCE_CAST (obj, VN_TYPE_FIELD, VnField)) -#define VN_IS_FIELD(obj) (G_TYPE_CHECK_INSTANCE_TYPE (obj, VN_TYPE_FIELD)) -#define VN_FIELD_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST (klass, VN_TYPE_FIELD, VnFieldClass)) -#define VN_FIELD_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS (obj, VN_TYPE_FIELD, VnFieldClass)) +#define VN_TYPE_FIELD (vn_field_get_type ()) +#define VN_FIELD(self) (G_TYPE_CHECK_INSTANCE_CAST (self, VN_TYPE_FIELD, VnField)) +#define VN_IS_FIELD(self) (G_TYPE_CHECK_INSTANCE_TYPE (self, VN_TYPE_FIELD)) +#define VN_FIELD_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST (klass, VN_TYPE_FIELD, VnFieldClass)) +#define VN_FIELD_GET_CLASS(self) (G_TYPE_INSTANCE_GET_CLASS (self, VN_TYPE_FIELD, VnFieldClass)) typedef struct _VnField VnField; typedef struct _VnFieldClass VnFieldClass; -typedef void (*VnFieldSetValueFunc) (VnField * obj, const GValue * value); -typedef void (*VnFieldValueChangedFunc) (VnField * obj, const GValue * value); +typedef void (*VnFieldSetValueFunc) (VnField * self, const GValue * value); +typedef void (*VnFieldValueChangedFunc) (VnField * self, const GValue * value); +typedef void (*VnFieldSetWidgetFunc) (VnField * self, GtkWidget * widget); -typedef void (*VnFieldStyleFunc) (VnField * obj, GtkWidget * widget, +typedef void (*VnFieldStyleFunc) (VnField * self, GtkWidget * widget, const GValue * value); struct _VnField { GtkEventBox parent; - GtkWidget * field; + GtkWidget * widget; GValue * value; - GvnParam * param; + GvnParam * master; + gboolean change_master; GvnParamSpec * spec; GvnParamSpec * user_spec; gboolean lock_changed_done; - gboolean update_param; DbIterator * iterator; gchar * column_name; VnFieldStyleFunc style_func; @@ -57,22 +58,19 @@ struct _VnFieldClass GCallback changed; VnFieldSetValueFunc set_value; VnFieldValueChangedFunc value_changed; + VnFieldSetWidgetFunc set_widget; }; GType vn_field_get_type (); -const GValue * vn_field_get_value (VnField * obj); -void vn_field_set_value (VnField * obj, const GValue * value); -GvnParam * vn_field_get_param (VnField * obj); -void vn_field_set_param (VnField * obj, GvnParam * param); -GType vn_field_get_gtype (VnField * obj); -void vn_field_set_gtype (VnField * obj, GType type); -gboolean vn_field_get_null (VnField * obj); -void vn_field_set_null (VnField * obj, gboolean null); -gboolean vn_field_get_editable (VnField * obj); -void vn_field_set_editable (VnField * obj, gboolean editable); -const GValue * vn_field_get_default (VnField * obj); -void vn_field_set_default (VnField * obj, const GValue * def); -void vn_field_set_to_default (VnField * obj); -GtkWidget * vn_field_get_widget (VnField * obj); +GType vn_field_get_gtype (VnField * self); +void vn_field_set_gtype (VnField * self, GType type); +gboolean vn_field_get_null (VnField * self); +void vn_field_set_null (VnField * self, gboolean null); +gboolean vn_field_get_editable (VnField * self); +void vn_field_set_editable (VnField * self, gboolean editable); +const GValue * vn_field_get_default (VnField * self); +void vn_field_set_default (VnField * self, const GValue * def); +void vn_field_set_to_default (VnField * self); +GtkWidget * vn_field_get_widget (VnField * self); #endif \ No newline at end of file diff --git a/vn/vn-login.c b/vn/vn-login.c index 16e9d9d..d060615 100644 --- a/vn/vn-login.c +++ b/vn/vn-login.c @@ -34,8 +34,8 @@ typedef struct } ConnectData; -void vn_login_cb_gui_logout (VnGui * gui, VnLogin * obj); -void vn_login_cb_gui_exit (VnGui * gui, VnLogin * obj); +void vn_login_on_gui_logout (VnGui * gui, VnLogin * obj); +void vn_login_on_gui_exit (VnGui * gui, VnLogin * obj); G_DEFINE_TYPE (VnLogin, vn_login, G_TYPE_OBJECT); @@ -46,9 +46,9 @@ G_DEFINE_TYPE (VnLogin, vn_login, G_TYPE_OBJECT); * * Return value: the created #VnLogin **/ -VnLogin * vn_login_new (const gchar * application_id) +VnLogin * vn_login_new (GtkApplication * application) { - return g_object_new (VN_TYPE_LOGIN, "application-id", application_id, NULL); + return g_object_new (VN_TYPE_LOGIN, "application", application, NULL); } //+++++++++++++++++++++++++++++++++++++++++++++++++++ Private @@ -117,6 +117,8 @@ static void vn_login_show (VnLogin * obj) g_free (user); g_free (pass); + + gtk_application_add_window (obj->app, obj->window); } else if (err) { @@ -165,8 +167,8 @@ static void vn_login_free_gui (VnLogin * obj) if (obj->gui) { g_object_disconnect (obj->gui - ,"any_signal", vn_login_cb_gui_exit, obj - ,"any_signal", vn_login_cb_gui_logout, obj + ,"any_signal", vn_login_on_gui_exit, obj + ,"any_signal", vn_login_on_gui_logout, obj ,NULL ); g_clear_object (&obj->gui); @@ -176,7 +178,7 @@ static void vn_login_free_gui (VnLogin * obj) /* * Shows the settings dialog. */ -void vn_login_cb_settings_clicked (GtkButton * button, VnLogin * obj) +void vn_login_on_settings_clicked (GtkButton * button, VnLogin * obj) { gchar * plugin = g_settings_get_string (obj->settings, "plugin"); gchar * host = g_settings_get_string (obj->settings, "host"); @@ -198,7 +200,7 @@ void vn_login_cb_settings_clicked (GtkButton * button, VnLogin * obj) /* * Hides the settings dialog. */ -void vn_login_cb_settings_cancel_clicked (GtkButton * button, VnLogin * obj) +void vn_login_on_settings_cancel_clicked (GtkButton * button, VnLogin * obj) { gtk_widget_hide (GTK_WIDGET (obj->settings_dialog)); } @@ -214,7 +216,7 @@ void vn_login_settings_on_delete_event (GtkWidget * settings_dialog) /* * Applies the changes made on settings dialog. */ -void vn_login_cb_settings_apply_clicked (GtkButton * button, VnLogin * obj) +void vn_login_on_settings_apply_clicked (GtkButton * button, VnLogin * obj) { const gchar * plugin = gtk_entry_get_text (obj->plugin); const gchar * host = gtk_entry_get_text (obj->host); @@ -231,7 +233,7 @@ void vn_login_cb_settings_apply_clicked (GtkButton * button, VnLogin * obj) /* * Shows the login dialog when user logout from GUI. */ -void vn_login_cb_gui_logout (VnGui * gui, VnLogin * obj) +void vn_login_on_gui_logout (VnGui * gui, VnLogin * obj) { g_settings_set_string (obj->settings, "pass", ""); vn_login_free_gui (obj); @@ -241,7 +243,7 @@ void vn_login_cb_gui_logout (VnGui * gui, VnLogin * obj) /* * Destroys the login dialog when user exits from GUI. */ -void vn_login_cb_gui_exit (VnGui * gui, VnLogin * obj) +void vn_login_on_gui_exit (VnGui * gui, VnLogin * obj) { vn_login_free_gui (obj); gtk_widget_destroy (GTK_WIDGET (obj->window)); @@ -275,8 +277,8 @@ static gboolean vn_login_done (ConnectData * connect_data) gtk_widget_hide (GTK_WIDGET (obj->window)); obj->gui = vn_gui_new (obj->app, connect_data->conn); g_object_connect (obj->gui - ,"signal::logout", vn_login_cb_gui_logout, obj - ,"signal::exit", vn_login_cb_gui_exit, obj + ,"signal::logout", vn_login_on_gui_logout, obj + ,"signal::exit", vn_login_on_gui_exit, obj ,NULL ); vn_gui_open (obj->gui); @@ -362,7 +364,7 @@ static void vn_login_thread (ConnectData * connect_data) /* * Opens the connection. */ -void vn_login_cb_connect_clicked (GtkButton * button, VnLogin * obj) +void vn_login_on_connect_clicked (GtkButton * button, VnLogin * obj) { ConnectData * connect_data; @@ -382,54 +384,47 @@ void vn_login_cb_connect_clicked (GtkButton * button, VnLogin * obj) /* * Closes the application when login window is destroyed. */ -void vn_login_cb_destroyed (GtkWidget * window, VnLogin * obj) +void vn_login_on_destroyed (GtkWidget * window, VnLogin * obj) { obj->window = NULL; gtk_main_quit (); } -void vn_login_cb_pass_show (GtkEntry * entry, GtkEntryIconPosition * pos, +void vn_login_on_pass_show (GtkEntry * entry, GtkEntryIconPosition * pos, GdkEvent * event, VnLogin * obj) { gtk_entry_set_visibility (entry, TRUE); } -void vn_login_cb_pass_hide (GtkEntry * entry, GtkEntryIconPosition * pos, +void vn_login_on_pass_hide (GtkEntry * entry, GtkEntryIconPosition * pos, GdkEvent * event, VnLogin * obj) { gtk_entry_set_visibility (entry, FALSE); } -//+++++++++++++++++++++++++++++++++++++++++++++++++++ Public - -/** - * vn_login_run: - * @obj: a #VnLogin - * - * Starts the main gui application. - **/ -void vn_login_run (VnLogin * obj) +static void vn_login_on_startup (GApplication * app, VnLogin * obj) { - GApplication * app; + g_object_set (gtk_settings_get_default (), "gtk-button-images", TRUE, NULL); +} - g_return_if_fail (VN_IS_LOGIN (obj)); - - app = G_APPLICATION (obj->app); - - if (g_application_register (app, NULL, NULL) - && !g_application_get_is_remote (app)) +static void vn_login_on_activate (GApplication * app, VnLogin * obj) +{ + g_message ("Activated!"); + + if (gtk_main_level () == 0) { - g_object_set (gtk_settings_get_default (), "gtk-button-images", TRUE, NULL); vn_login_show (obj); gtk_main (); } + else if (!obj->gui) + gtk_window_present (obj->window); } //+++++++++++++++++++++++++++++++++++++++++++++++++++ Properties enum { - PROP_APPLICATION_ID = 1 + PROP_APPLICATION = 1 }; static void vn_login_set_property (VnLogin * obj, guint id, @@ -437,11 +432,17 @@ static void vn_login_set_property (VnLogin * obj, guint id, { switch (id) { - case PROP_APPLICATION_ID: + case PROP_APPLICATION: { - const gchar * id = g_value_get_string (value); - obj->app = gtk_application_new (id, G_APPLICATION_FLAGS_NONE); - obj->settings = g_settings_new (id); + obj->app = g_value_dup_object (value); + g_object_connect (obj->app + ,"signal::startup", vn_login_on_startup, obj + ,"signal::activate", vn_login_on_activate, obj + ,NULL + ); + + obj->settings = g_settings_new ( + g_application_get_application_id (G_APPLICATION (obj->app))); break; } default: @@ -473,7 +474,14 @@ static void vn_login_finalize (VnLogin * obj) { vn_login_free_gui (obj); g_clear_object (&obj->settings); + + g_object_disconnect (obj->app + ,"any_signal", vn_login_on_startup, obj + ,"any_signal", vn_login_on_activate, obj + ,NULL + ); g_clear_object (&obj->app); + G_OBJECT_CLASS (vn_login_parent_class)->finalize (G_OBJECT (obj)); } @@ -484,11 +492,11 @@ static void vn_login_class_init (VnLoginClass * k) klass->set_property = (GObjectSetPropertyFunc) vn_login_set_property; klass->get_property = (GObjectGetPropertyFunc) vn_login_get_property; - g_object_class_install_property (klass, PROP_APPLICATION_ID, - g_param_spec_string ("application-id" - ,_("Application id") - ,_("The application identifier") - ,"app.default" + g_object_class_install_property (klass, PROP_APPLICATION, + g_param_spec_object ("application" + ,_("Application") + ,_("The application") + ,GTK_TYPE_APPLICATION ,G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY )); } diff --git a/vn/vn-login.h b/vn/vn-login.h index 8960a3a..af1b474 100644 --- a/vn/vn-login.h +++ b/vn/vn-login.h @@ -70,7 +70,6 @@ typedef enum VnLoginError; GType vn_login_get_type (); -VnLogin * vn_login_new (); -void vn_login_run (VnLogin * obj); +VnLogin * vn_login_new (GtkApplication * application); #endif \ No newline at end of file