verdnatura
/
hedera
Archived
0
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

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).
This commit is contained in:
Juan Ferrer Toribio 2014-07-16 16:12:36 +02:00
parent c0071fe461
commit e092946ec5
24 changed files with 1440 additions and 1571 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

139
db/db-calc.c
View File

@ -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;

8
db/db-calc.h
View File

@ -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
{
/* <private> */
GvnParamClass klass;
GObjectClass klass;
};
GType db_calc_get_type ();

605
db/db-iterator.c
View File

File diff suppressed because it is too large Load Diff

68
db/db-iterator.h
View File

@ -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

18
db/db-model-holder.c
View File

@ -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

14
db/db-model-holder.h
View File

@ -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

14
db/db-model.c
View File

@ -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

1
db/db-model.h
View File

@ -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

267
db/db-param.c
View File

@ -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;
}

23
db/db-param.h
View File

@ -21,11 +21,11 @@
#include <gvn/gvn-param.h>
#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
{
/* <private> */
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

437
gvn/gvn-param.c
View File

@ -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
));
}

84
gvn/gvn-param.h
View File

@ -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
{
/* <private> */
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

14
main/main.c
View File

@ -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;
}

2
sql/parser/gram.y
View File

@ -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);
}

220
sql/sql-value.c
View File

@ -18,6 +18,9 @@
#include <stdlib.h>
#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;
}

11
sql/sql-value.h
View File

@ -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

153
vn/field/vn-combo.c
View File

@ -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)

156
vn/field/vn-completion.c
View File

@ -20,7 +20,7 @@
#include <vn/vn-grid-model.h>
#include <string.h>
#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)

95
vn/field/vn-http-image.c
View File

@ -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)

14
vn/gui/login.glade
View File

@ -10,7 +10,7 @@
<property name="resizable">False</property>
<property name="window_position">center</property>
<property name="icon">../image/icon.svg</property>
<signal name="destroy" handler="vn_login_cb_destroyed" swapped="no"/>
<signal name="destroy" handler="vn_login_on_destroyed" swapped="no"/>
<child>
<object class="GtkBox" id="box4">
<property name="visible">True</property>
@ -111,8 +111,8 @@
<property name="invisible_char">●</property>
<property name="secondary_icon_name">edit-find-symbolic</property>
<property name="secondary_icon_tooltip_text" translatable="yes">Press here to see the password</property>
<signal name="icon-press" handler="vn_login_cb_pass_show" swapped="no"/>
<signal name="icon-release" handler="vn_login_cb_pass_hide" swapped="no"/>
<signal name="icon-press" handler="vn_login_on_pass_show" swapped="no"/>
<signal name="icon-release" handler="vn_login_on_pass_hide" swapped="no"/>
</object>
<packing>
<property name="left_attach">1</property>
@ -156,7 +156,7 @@
<property name="can_focus">False</property>
<property name="receives_default">True</property>
<property name="use_stock">True</property>
<signal name="clicked" handler="vn_login_cb_settings_clicked" swapped="no"/>
<signal name="clicked" handler="vn_login_on_settings_clicked" swapped="no"/>
</object>
<packing>
<property name="expand">False</property>
@ -171,7 +171,7 @@
<property name="can_focus">True</property>
<property name="receives_default">True</property>
<property name="use_stock">True</property>
<signal name="clicked" handler="vn_login_cb_connect_clicked" swapped="no"/>
<signal name="clicked" handler="vn_login_on_connect_clicked" swapped="no"/>
<accelerator key="KP_Enter" signal="clicked"/>
<accelerator key="Return" signal="clicked"/>
</object>
@ -217,7 +217,7 @@
<property name="can_focus">True</property>
<property name="receives_default">True</property>
<property name="use_stock">True</property>
<signal name="clicked" handler="vn_login_cb_settings_cancel_clicked" swapped="no"/>
<signal name="clicked" handler="vn_login_on_settings_cancel_clicked" swapped="no"/>
</object>
<packing>
<property name="expand">False</property>
@ -232,7 +232,7 @@
<property name="can_focus">True</property>
<property name="receives_default">True</property>
<property name="use_stock">True</property>
<signal name="clicked" handler="vn_login_cb_settings_apply_clicked" swapped="no"/>
<signal name="clicked" handler="vn_login_on_settings_apply_clicked" swapped="no"/>
<accelerator key="KP_Enter" signal="clicked"/>
<accelerator key="Return" signal="clicked"/>
</object>

521
vn/vn-field.c
View File

@ -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;
}

48
vn/vn-field.h
View File

@ -21,31 +21,32 @@
#include <db/db.h>
#include <gtk/gtk.h>
#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

96
vn/vn-login.c
View File

@ -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
));
}

3
vn/vn-login.h
View File

@ -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