static void
aisleriot_card_get_property (GObject *self,
guint property_id,
GValue *value,
GParamSpec *pspec)
{
AisleriotCard *card = AISLERIOT_CARD (self);
AisleriotCardPrivate *priv = card->priv;
switch (property_id) {
case PROP_BOTTOM_CARD:
g_value_set_uchar (value, priv->bottom_card.value);
break;
case PROP_TOP_CARD:
g_value_set_uchar (value, priv->top_card.value);
break;
case PROP_CACHE:
g_value_set_object (value, priv->cache);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (self, property_id, pspec);
break;
}
}
static inline gboolean
gtk_arg_static_to_value (GtkArg *arg,
GValue *value)
{
switch (G_TYPE_FUNDAMENTAL (arg->type))
{
case G_TYPE_CHAR: g_value_set_char (value, GTK_VALUE_CHAR (*arg)); break;
case G_TYPE_UCHAR: g_value_set_uchar (value, GTK_VALUE_UCHAR (*arg)); break;
case G_TYPE_BOOLEAN: g_value_set_boolean (value, GTK_VALUE_BOOL (*arg)); break;
case G_TYPE_INT: g_value_set_int (value, GTK_VALUE_INT (*arg)); break;
case G_TYPE_UINT: g_value_set_uint (value, GTK_VALUE_UINT (*arg)); break;
case G_TYPE_LONG: g_value_set_long (value, GTK_VALUE_LONG (*arg)); break;
case G_TYPE_ULONG: g_value_set_ulong (value, GTK_VALUE_ULONG (*arg)); break;
case G_TYPE_ENUM: g_value_set_enum (value, GTK_VALUE_ENUM (*arg)); break;
case G_TYPE_FLAGS: g_value_set_flags (value, GTK_VALUE_FLAGS (*arg)); break;
case G_TYPE_FLOAT: g_value_set_float (value, GTK_VALUE_FLOAT (*arg)); break;
case G_TYPE_DOUBLE: g_value_set_double (value, GTK_VALUE_DOUBLE (*arg)); break;
case G_TYPE_STRING: g_value_set_static_string (value, GTK_VALUE_STRING (*arg)); break;
case G_TYPE_BOXED: g_value_set_static_boxed (value, GTK_VALUE_BOXED (*arg)); break;
case G_TYPE_POINTER: g_value_set_pointer (value, GTK_VALUE_POINTER (*arg)); break;
case G_TYPE_OBJECT: g_value_set_object (value, GTK_VALUE_POINTER (*arg)); break;
default:
return FALSE;
}
return TRUE;
}
gboolean
stetic_param_spec_get_maximum (GParamSpec *pspec, GValue *value)
{
g_value_init (value, pspec->value_type);
if (G_IS_PARAM_SPEC_CHAR (pspec))
g_value_set_char (value, G_PARAM_SPEC_CHAR (pspec)->maximum);
else if (G_IS_PARAM_SPEC_UCHAR (pspec))
g_value_set_uchar (value, G_PARAM_SPEC_UCHAR (pspec)->maximum);
else if (G_IS_PARAM_SPEC_INT (pspec))
g_value_set_int (value, G_PARAM_SPEC_INT (pspec)->maximum);
else if (G_IS_PARAM_SPEC_UINT (pspec))
g_value_set_uint (value, G_PARAM_SPEC_UINT (pspec)->maximum);
else if (G_IS_PARAM_SPEC_LONG (pspec))
g_value_set_long (value, G_PARAM_SPEC_LONG (pspec)->maximum);
else if (G_IS_PARAM_SPEC_ULONG (pspec))
g_value_set_ulong (value, G_PARAM_SPEC_ULONG (pspec)->maximum);
else if (G_IS_PARAM_SPEC_INT64 (pspec))
g_value_set_int64 (value, G_PARAM_SPEC_INT64 (pspec)->maximum);
else if (G_IS_PARAM_SPEC_UINT64 (pspec))
g_value_set_uint64 (value, G_PARAM_SPEC_UINT64 (pspec)->maximum);
else if (G_IS_PARAM_SPEC_FLOAT (pspec))
g_value_set_float (value, G_PARAM_SPEC_FLOAT (pspec)->maximum);
else if (G_IS_PARAM_SPEC_DOUBLE (pspec))
g_value_set_double (value, G_PARAM_SPEC_DOUBLE (pspec)->maximum);
else
return FALSE;
return TRUE;
}
void scp_tree_data_to_value(const ScpTreeData *data, GType type, GValue *value)
{
g_value_init(value, type);
switch (scp_tree_data_get_fundamental_type(type))
{
case G_TYPE_INT : g_value_set_int(value, data->v_int); break;
case G_TYPE_UINT : g_value_set_uint(value, data->v_uint); break;
case G_TYPE_STRING : g_value_set_string(value, data->v_string); break;
case G_TYPE_BOOLEAN : g_value_set_boolean(value, data->v_int); break;
case G_TYPE_LONG : g_value_set_long(value, data->v_long); break;
case G_TYPE_ULONG : g_value_set_ulong(value, data->v_ulong); break;
case G_TYPE_FLOAT : g_value_set_float(value, data->v_float); break;
case G_TYPE_DOUBLE : g_value_set_double(value, data->v_double); break;
#if GLIB_CHECK_VERSION(2, 32, 0)
case G_TYPE_CHAR : g_value_set_schar(value, data->v_char); break;
#else
case G_TYPE_CHAR : g_value_set_char(value, data->v_char); break;
#endif
case G_TYPE_UCHAR : g_value_set_uchar(value, data->v_uchar); break;
case G_TYPE_INT64 : g_value_set_int64(value, data->v_int64); break;
case G_TYPE_UINT64 : g_value_set_uint64 (value, data->v_uint64); break;
case G_TYPE_ENUM : g_value_set_enum(value, data->v_int); break;
case G_TYPE_FLAGS : g_value_set_flags(value, data->v_uint); break;
case G_TYPE_POINTER : g_value_set_pointer(value, data->v_pointer); break;
case G_TYPE_OBJECT : g_value_set_object(value, (GObject *) data->v_pointer); break;
case G_TYPE_BOXED : g_value_set_boxed(value, data->v_pointer); break;
#if GLIB_CHECK_VERSION(2, 26, 0)
case G_TYPE_VARIANT : g_value_set_variant(value, data->v_pointer); break;
#endif
default : scp_tree_data_warn_unsupported_type(G_STRFUNC, type);
}
}
gboolean
stetic_param_spec_get_default (GParamSpec *pspec, GValue *value)
{
g_value_init (value, pspec->value_type);
if (G_IS_PARAM_SPEC_CHAR (pspec))
g_value_set_char (value, G_PARAM_SPEC_CHAR (pspec)->default_value);
else if (G_IS_PARAM_SPEC_UCHAR (pspec))
g_value_set_uchar (value, G_PARAM_SPEC_UCHAR (pspec)->default_value);
else if (G_IS_PARAM_SPEC_INT (pspec))
g_value_set_int (value, G_PARAM_SPEC_INT (pspec)->default_value);
else if (G_IS_PARAM_SPEC_UINT (pspec))
g_value_set_uint (value, G_PARAM_SPEC_UINT (pspec)->default_value);
else if (G_IS_PARAM_SPEC_LONG (pspec))
g_value_set_long (value, G_PARAM_SPEC_LONG (pspec)->default_value);
else if (G_IS_PARAM_SPEC_ULONG (pspec))
g_value_set_ulong (value, G_PARAM_SPEC_ULONG (pspec)->default_value);
else if (G_IS_PARAM_SPEC_INT64 (pspec))
g_value_set_int64 (value, G_PARAM_SPEC_INT64 (pspec)->default_value);
else if (G_IS_PARAM_SPEC_UINT64 (pspec))
g_value_set_uint64 (value, G_PARAM_SPEC_UINT64 (pspec)->default_value);
else if (G_IS_PARAM_SPEC_FLOAT (pspec))
g_value_set_float (value, G_PARAM_SPEC_FLOAT (pspec)->default_value);
else if (G_IS_PARAM_SPEC_DOUBLE (pspec))
g_value_set_double (value, G_PARAM_SPEC_DOUBLE (pspec)->default_value);
else if (G_IS_PARAM_SPEC_BOOLEAN (pspec))
g_value_set_boolean (value, G_PARAM_SPEC_BOOLEAN (pspec)->default_value);
else if (G_IS_PARAM_SPEC_UNICHAR (pspec))
g_value_set_uint (value, G_PARAM_SPEC_UNICHAR (pspec)->default_value);
else if (G_IS_PARAM_SPEC_STRING (pspec))
g_value_set_static_string (value, G_PARAM_SPEC_STRING (pspec)->default_value);
else
return FALSE;
return TRUE;
}
static void
get_property (GObject *object, guint prop_id,
GValue *value, GParamSpec *pspec)
{
NMDeviceIPTunnelPrivate *priv = NM_DEVICE_IP_TUNNEL_GET_PRIVATE (object);
NMDevice *parent;
switch (prop_id) {
case PROP_MODE:
g_value_set_uint (value, priv->mode);
break;
case PROP_PARENT:
parent = nm_manager_get_device_by_ifindex (nm_manager_get (), priv->parent_ifindex);
nm_utils_g_value_set_object_path (value, parent);
break;
case PROP_LOCAL:
g_value_set_string (value, priv->local);
break;
case PROP_REMOTE:
g_value_set_string (value, priv->remote);
break;
case PROP_TTL:
g_value_set_uchar (value, priv->ttl);
break;
case PROP_TOS:
g_value_set_uchar (value, priv->tos);
break;
case PROP_PATH_MTU_DISCOVERY:
g_value_set_boolean (value, priv->path_mtu_discovery);
break;
case PROP_INPUT_KEY:
g_value_set_string (value, priv->input_key);
break;
case PROP_OUTPUT_KEY:
g_value_set_string (value, priv->output_key);
break;
case PROP_ENCAPSULATION_LIMIT:
g_value_set_uchar (value, priv->encap_limit);
break;
case PROP_FLOW_LABEL:
g_value_set_uint (value, priv->flow_label);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static gboolean
parse_uint8 (const char *string,
GValue *value,
GError **error)
{
g_value_set_uchar (value, 42);
return TRUE;
}
static void
g_value_from_ffi_value (GValue *gvalue,
const GIArgument *value)
{
switch (g_type_fundamental (G_VALUE_TYPE (gvalue))) {
case G_TYPE_INT:
g_value_set_int (gvalue, (gint)value->v_long);
break;
case G_TYPE_FLOAT:
g_value_set_float (gvalue, (gfloat)value->v_float);
break;
case G_TYPE_DOUBLE:
g_value_set_double (gvalue, (gdouble)value->v_double);
break;
case G_TYPE_BOOLEAN:
g_value_set_boolean (gvalue, (gboolean)value->v_long);
break;
case G_TYPE_STRING:
g_value_set_string (gvalue, (gchar*)value->v_pointer);
break;
case G_TYPE_CHAR:
g_value_set_char (gvalue, (gchar)value->v_long);
break;
case G_TYPE_UCHAR:
g_value_set_uchar (gvalue, (guchar)value->v_ulong);
break;
case G_TYPE_UINT:
g_value_set_uint (gvalue, (guint)value->v_ulong);
break;
case G_TYPE_POINTER:
g_value_set_pointer (gvalue, (gpointer)value->v_pointer);
break;
case G_TYPE_LONG:
g_value_set_long (gvalue, (glong)value->v_long);
break;
case G_TYPE_ULONG:
g_value_set_ulong (gvalue, (gulong)value->v_ulong);
break;
case G_TYPE_INT64:
g_value_set_int64 (gvalue, (gint64)value->v_int64);
break;
case G_TYPE_UINT64:
g_value_set_uint64 (gvalue, (guint64)value->v_uint64);
break;
case G_TYPE_BOXED:
g_value_set_boxed (gvalue, (gpointer)value->v_pointer);
break;
default:
g_warning ("Unsupported fundamental type: %s",
g_type_name (g_type_fundamental (G_VALUE_TYPE (gvalue))));
}
}
static void
get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
NMAccessPoint *ap = NM_ACCESS_POINT (object);
_nm_object_ensure_inited (NM_OBJECT (object));
switch (prop_id) {
case PROP_FLAGS:
g_value_set_uint (value, nm_access_point_get_flags (ap));
break;
case PROP_WPA_FLAGS:
g_value_set_uint (value, nm_access_point_get_wpa_flags (ap));
break;
case PROP_RSN_FLAGS:
g_value_set_uint (value, nm_access_point_get_rsn_flags (ap));
break;
case PROP_SSID:
g_value_set_boxed (value, nm_access_point_get_ssid (ap));
break;
case PROP_FREQUENCY:
g_value_set_uint (value, nm_access_point_get_frequency (ap));
break;
case PROP_HW_ADDRESS:
g_value_set_string (value, nm_access_point_get_bssid (ap));
break;
case PROP_BSSID:
g_value_set_string (value, nm_access_point_get_bssid (ap));
break;
case PROP_MODE:
g_value_set_uint (value, nm_access_point_get_mode (ap));
break;
case PROP_MAX_BITRATE:
g_value_set_uint (value, nm_access_point_get_max_bitrate (ap));
break;
case PROP_STRENGTH:
g_value_set_uchar (value, nm_access_point_get_strength (ap));
break;
case PROP_LAST_SEEN:
g_value_set_int (value, nm_access_point_get_last_seen (ap));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
gst_cmml_enc_get_property (GObject * object, guint property_id,
GValue * value, GParamSpec * pspec)
{
GstCmmlEnc *enc = GST_CMML_ENC (object);
switch (property_id) {
case GST_CMML_ENC_GRANULERATE_N:
g_value_set_int64 (value, enc->granulerate_n);
break;
case GST_CMML_ENC_GRANULERATE_D:
g_value_set_int64 (value, enc->granulerate_d);
break;
case GST_CMML_ENC_GRANULESHIFT:
g_value_set_uchar (value, enc->granuleshift);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
}
}
static void
maman_bar_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec)
{
MamanBar *self = MAMAN_BAR (object);
switch (property_id) {
case PROP_MAMAN_NAME:
g_value_set_string (value, self->name);
break;
case PROP_PAPA_NUMBER:
g_value_set_uchar (value, self->papa_number);
break;
default:
/* We don't have any other property... */
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
/**
* pyg_value_from_pyobject:
* @value: the GValue object to store the converted value in.
* @obj: the Python object to convert.
*
* This function converts a Python object and stores the result in a
* GValue. The GValue must be initialised in advance with
* g_value_init(). If the Python object can't be converted to the
* type of the GValue, then an error is returned.
*
* Returns: 0 on success, -1 on error.
*/
int
pyg_value_from_pyobject(GValue *value, PyObject *obj)
{
PyObject *tmp;
switch (G_TYPE_FUNDAMENTAL(G_VALUE_TYPE(value))) {
case G_TYPE_INTERFACE:
/* we only handle interface types that have a GObject prereq */
if (g_type_is_a(G_VALUE_TYPE(value), G_TYPE_OBJECT)) {
if (obj == Py_None)
g_value_set_object(value, NULL);
else {
if (!PyObject_TypeCheck(obj, &PyGObject_Type)) {
return -1;
}
if (!G_TYPE_CHECK_INSTANCE_TYPE(pygobject_get(obj),
G_VALUE_TYPE(value))) {
return -1;
}
g_value_set_object(value, pygobject_get(obj));
}
} else {
return -1;
}
break;
case G_TYPE_CHAR:
#if PY_VERSION_HEX < 0x03000000
if (PyString_Check(obj)) {
g_value_set_char(value, PyString_AsString(obj)[0]);
} else
#endif
if (PyUnicode_Check(obj)) {
tmp = PyUnicode_AsUTF8String(obj);
g_value_set_char(value, PYGLIB_PyBytes_AsString(tmp)[0]);
Py_DECREF(tmp);
} else {
PyErr_Clear();
return -1;
}
break;
case G_TYPE_UCHAR:
if (PYGLIB_PyLong_Check(obj)) {
glong val;
val = PYGLIB_PyLong_AsLong(obj);
if (val >= 0 && val <= 255)
g_value_set_uchar(value, (guchar)PYGLIB_PyLong_AsLong (obj));
else
return -1;
#if PY_VERSION_HEX < 0x03000000
} else if (PyString_Check(obj)) {
g_value_set_uchar(value, PyString_AsString(obj)[0]);
#endif
} else if (PyUnicode_Check(obj)) {
tmp = PyUnicode_AsUTF8String(obj);
g_value_set_uchar(value, PYGLIB_PyBytes_AsString(tmp)[0]);
Py_DECREF(tmp);
} else {
PyErr_Clear();
return -1;
}
break;
case G_TYPE_BOOLEAN:
g_value_set_boolean(value, PyObject_IsTrue(obj));
break;
case G_TYPE_INT:
g_value_set_int(value, PYGLIB_PyLong_AsLong(obj));
break;
case G_TYPE_UINT:
{
if (PYGLIB_PyLong_Check(obj)) {
glong val;
val = PYGLIB_PyLong_AsLong(obj);
if (val >= 0 && val <= G_MAXUINT)
g_value_set_uint(value, (guint)val);
else
return -1;
} else {
g_value_set_uint(value, PyLong_AsUnsignedLong(obj));
}
}
break;
case G_TYPE_LONG:
g_value_set_long(value, PYGLIB_PyLong_AsLong(obj));
break;
case G_TYPE_ULONG:
#if PY_VERSION_HEX < 0x03000000
if (PyInt_Check(obj)) {
long val;
val = PYGLIB_PyLong_AsLong(obj);
if (val < 0) {
PyErr_SetString(PyExc_OverflowError, "negative value not allowed for uint64 property");
return -1;
}
g_value_set_ulong(value, (gulong)val);
} else
#endif
if (PyLong_Check(obj))
g_value_set_ulong(value, PyLong_AsUnsignedLong(obj));
else
return -1;
break;
case G_TYPE_INT64:
g_value_set_int64(value, PyLong_AsLongLong(obj));
break;
case G_TYPE_UINT64:
#if PY_VERSION_HEX < 0x03000000
if (PyInt_Check(obj)) {
long v = PyInt_AsLong(obj);
if (v < 0) {
PyErr_SetString(PyExc_OverflowError, "negative value not allowed for uint64 property");
return -1;
}
g_value_set_uint64(value, v);
} else
#endif
if (PyLong_Check(obj))
g_value_set_uint64(value, PyLong_AsUnsignedLongLong(obj));
else
return -1;
break;
case G_TYPE_ENUM:
{
gint val = 0;
if (pyg_enum_get_value(G_VALUE_TYPE(value), obj, &val) < 0) {
PyErr_Clear();
return -1;
}
g_value_set_enum(value, val);
}
break;
case G_TYPE_FLAGS:
{
gint val = 0;
if (pyg_flags_get_value(G_VALUE_TYPE(value), obj, &val) < 0) {
PyErr_Clear();
return -1;
}
g_value_set_flags(value, val);
}
break;
case G_TYPE_FLOAT:
g_value_set_float(value, PyFloat_AsDouble(obj));
break;
case G_TYPE_DOUBLE:
g_value_set_double(value, PyFloat_AsDouble(obj));
break;
case G_TYPE_STRING:
if (obj == Py_None) {
g_value_set_string(value, NULL);
#if PY_VERSION_HEX < 0x03000000
} else if (PyString_Check(obj)) {
g_value_set_string(value, PyString_AsString(obj));
#endif
} else if (PyUnicode_Check(obj)) {
tmp = PyUnicode_AsUTF8String(obj);
g_value_set_string(value, PYGLIB_PyBytes_AsString(tmp));
Py_DECREF(tmp);
} else {
PyErr_Clear();
return -1;
}
break;
case G_TYPE_POINTER:
if (obj == Py_None)
g_value_set_pointer(value, NULL);
else if (PyObject_TypeCheck(obj, &PyGPointer_Type) &&
G_VALUE_HOLDS(value, ((PyGPointer *)obj)->gtype))
g_value_set_pointer(value, pyg_pointer_get(obj, gpointer));
else if (PYGLIB_CPointer_Check(obj))
g_value_set_pointer(value, PYGLIB_CPointer_GetPointer(obj, NULL));
else
return -1;
break;
case G_TYPE_BOXED: {
PyGTypeMarshal *bm;
if (obj == Py_None)
g_value_set_boxed(value, NULL);
else if (G_VALUE_HOLDS(value, PY_TYPE_OBJECT))
g_value_set_boxed(value, obj);
else if (PyObject_TypeCheck(obj, &PyGBoxed_Type) &&
G_VALUE_HOLDS(value, ((PyGBoxed *)obj)->gtype))
g_value_set_boxed(value, pyg_boxed_get(obj, gpointer));
else if (G_VALUE_HOLDS(value, G_TYPE_VALUE)) {
GType type;
GValue *n_value;
type = pyg_type_from_object((PyObject*)Py_TYPE(obj));
if (G_UNLIKELY (! type)) {
PyErr_Clear();
return -1;
}
n_value = g_new0 (GValue, 1);
g_value_init (n_value, type);
g_value_take_boxed (value, n_value);
return pyg_value_from_pyobject (n_value, obj);
}
else if (PySequence_Check(obj) &&
G_VALUE_HOLDS(value, G_TYPE_VALUE_ARRAY))
return pyg_value_array_from_pyobject(value, obj, NULL);
else if (PYGLIB_PyUnicode_Check(obj) &&
G_VALUE_HOLDS(value, G_TYPE_GSTRING)) {
GString *string;
char *buffer;
Py_ssize_t len;
if (PYGLIB_PyUnicode_AsStringAndSize(obj, &buffer, &len))
return -1;
string = g_string_new_len(buffer, len);
g_value_set_boxed(value, string);
g_string_free (string, TRUE);
break;
}
else if ((bm = pyg_type_lookup(G_VALUE_TYPE(value))) != NULL)
return bm->tovalue(value, obj);
else if (PYGLIB_CPointer_Check(obj))
g_value_set_boxed(value, PYGLIB_CPointer_GetPointer(obj, NULL));
else
return -1;
break;
}
case G_TYPE_PARAM:
if (PyGParamSpec_Check(obj))
g_value_set_param(value, PYGLIB_CPointer_GetPointer(obj, NULL));
else
return -1;
break;
case G_TYPE_OBJECT:
if (obj == Py_None) {
g_value_set_object(value, NULL);
} else if (PyObject_TypeCheck(obj, &PyGObject_Type) &&
G_TYPE_CHECK_INSTANCE_TYPE(pygobject_get(obj),
G_VALUE_TYPE(value))) {
g_value_set_object(value, pygobject_get(obj));
} else
return -1;
break;
default:
{
PyGTypeMarshal *bm;
if ((bm = pyg_type_lookup(G_VALUE_TYPE(value))) != NULL)
return bm->tovalue(value, obj);
break;
}
}
if (PyErr_Occurred()) {
g_value_unset(value);
PyErr_Clear();
return -1;
}
return 0;
}
gboolean
panel_dbus_client_plugin_event (const gchar *plugin_event,
gboolean *return_succeed,
GError **error)
{
DBusGProxy *dbus_proxy;
gboolean result = FALSE;
gchar **tokens;
GType type;
GValue value = { 0, };
guint n_tokens;
panel_return_val_if_fail (error == NULL || *error == NULL, FALSE);
dbus_proxy = panel_dbus_client_get_proxy (error);
if (G_UNLIKELY (dbus_proxy == NULL))
return FALSE;
tokens = g_strsplit (plugin_event, ":", -1);
n_tokens = g_strv_length (tokens);
if (!(n_tokens == 2 || n_tokens == N_TOKENS)
|| exo_str_is_empty (tokens[PLUGIN_NAME])
|| exo_str_is_empty (tokens[NAME]))
{
g_set_error_literal (error, G_OPTION_ERROR, G_OPTION_ERROR_BAD_VALUE,
_("Invalid plugin event syntax specified. "
"Use PLUGIN-NAME:NAME[:TYPE:VALUE]."));
goto out;
}
else if (n_tokens == 2)
{
/* set noop value, recognized by the dbus service as %NULL value */
g_value_init (&value, G_TYPE_UCHAR);
g_value_set_uchar (&value, '\0');
}
else if (n_tokens == N_TOKENS)
{
type = panel_dbus_client_gtype_from_string (tokens[TYPE]);
if (G_LIKELY (type != G_TYPE_NONE))
{
g_value_init (&value, type);
if (type == G_TYPE_BOOLEAN)
g_value_set_boolean (&value, strcmp (tokens[VALUE], "true") == 0);
else if (type == G_TYPE_DOUBLE)
g_value_set_double (&value, g_ascii_strtod (tokens[VALUE], NULL));
else if (type == G_TYPE_INT)
g_value_set_int (&value, strtol (tokens[VALUE], NULL, 0));
else if (type == G_TYPE_STRING)
g_value_set_static_string (&value, tokens[VALUE]);
else if (type == G_TYPE_UINT)
g_value_set_uint (&value, strtol (tokens[VALUE], NULL, 0));
else
panel_assert_not_reached ();
}
else
{
g_set_error (error, G_OPTION_ERROR, G_OPTION_ERROR_BAD_VALUE,
_("Invalid hint type \"%s\". Valid types "
"are bool, double, int, string and uint."),
tokens[TYPE]);
goto out;
}
}
else
{
panel_assert_not_reached ();
goto out;
}
/* send value over dbus */
panel_return_val_if_fail (G_IS_VALUE (&value), FALSE);
result = _panel_dbus_client_plugin_event (dbus_proxy,
tokens[PLUGIN_NAME],
tokens[NAME],
&value,
return_succeed,
error);
g_value_unset (&value);
out:
g_strfreev (tokens);
g_object_unref (G_OBJECT (dbus_proxy));
return result;
}
gboolean
json_deserialize_pspec (GValue *value,
GParamSpec *pspec,
JsonNode *node)
{
GValue node_value = { 0, };
gboolean retval = FALSE;
if (G_TYPE_FUNDAMENTAL (G_VALUE_TYPE (value)) == G_TYPE_BOXED)
{
JsonNodeType node_type = json_node_get_node_type (node);
GType boxed_type = G_VALUE_TYPE (value);
if (json_boxed_can_deserialize (boxed_type, node_type))
{
gpointer boxed = json_boxed_deserialize (boxed_type, node);
g_value_take_boxed (value, boxed);
return TRUE;
}
}
switch (JSON_NODE_TYPE (node))
{
case JSON_NODE_OBJECT:
if (g_type_is_a (G_VALUE_TYPE (value), G_TYPE_OBJECT))
{
GObject *object;
object = json_gobject_new (G_VALUE_TYPE (value), json_node_get_object (node));
if (object != NULL)
g_value_take_object (value, object);
else
g_value_set_object (value, NULL);
retval = TRUE;
}
break;
case JSON_NODE_ARRAY:
if (G_VALUE_HOLDS (value, G_TYPE_STRV))
{
JsonArray *array = json_node_get_array (node);
guint i, array_len = json_array_get_length (array);
GPtrArray *str_array = g_ptr_array_sized_new (array_len + 1);
for (i = 0; i < array_len; i++)
{
JsonNode *val = json_array_get_element (array, i);
if (JSON_NODE_TYPE (val) != JSON_NODE_VALUE)
continue;
if (json_node_get_string (val) != NULL)
g_ptr_array_add (str_array, (gpointer) json_node_get_string (val));
}
g_ptr_array_add (str_array, NULL);
g_value_set_boxed (value, str_array->pdata);
g_ptr_array_free (str_array, TRUE);
retval = TRUE;
}
break;
case JSON_NODE_VALUE:
json_node_get_value (node, &node_value);
#if 0
{
gchar *node_str = g_strdup_value_contents (&node_value);
g_debug ("%s: value type '%s' := node value type '%s' -> '%s'",
G_STRLOC,
g_type_name (G_VALUE_TYPE (value)),
g_type_name (G_VALUE_TYPE (&node_value)),
node_str);
g_free (node_str);
}
#endif
switch (G_TYPE_FUNDAMENTAL (G_VALUE_TYPE (value)))
{
case G_TYPE_BOOLEAN:
case G_TYPE_INT64:
case G_TYPE_STRING:
if (G_VALUE_HOLDS (&node_value, G_VALUE_TYPE (value)))
{
g_value_copy (&node_value, value);
retval = TRUE;
}
break;
case G_TYPE_INT:
if (G_VALUE_HOLDS (&node_value, G_TYPE_INT64))
{
g_value_set_int (value, (gint) g_value_get_int64 (&node_value));
retval = TRUE;
}
break;
case G_TYPE_CHAR:
if (G_VALUE_HOLDS (&node_value, G_TYPE_INT64))
{
g_value_set_schar (value, (gchar) g_value_get_int64 (&node_value));
retval = TRUE;
}
break;
case G_TYPE_UINT:
if (G_VALUE_HOLDS (&node_value, G_TYPE_INT64))
{
g_value_set_uint (value, (guint) g_value_get_int64 (&node_value));
retval = TRUE;
}
break;
case G_TYPE_UCHAR:
if (G_VALUE_HOLDS (&node_value, G_TYPE_INT64))
{
g_value_set_uchar (value, (guchar) g_value_get_int64 (&node_value));
retval = TRUE;
}
break;
case G_TYPE_LONG:
if (G_VALUE_HOLDS (&node_value, G_TYPE_INT64))
{
g_value_set_long (value, (glong) g_value_get_int64 (&node_value));
retval = TRUE;
}
break;
case G_TYPE_ULONG:
if (G_VALUE_HOLDS (&node_value, G_TYPE_INT64))
{
g_value_set_ulong (value, (gulong) g_value_get_int64 (&node_value));
retval = TRUE;
}
break;
case G_TYPE_UINT64:
if (G_VALUE_HOLDS (&node_value, G_TYPE_INT64))
{
g_value_set_uint64 (value, (guint64) g_value_get_int64 (&node_value));
retval = TRUE;
}
break;
case G_TYPE_DOUBLE:
if (G_VALUE_HOLDS (&node_value, G_TYPE_DOUBLE))
{
g_value_set_double (value, g_value_get_double (&node_value));
retval = TRUE;
}
else if (G_VALUE_HOLDS (&node_value, G_TYPE_INT64))
{
g_value_set_double (value, (gdouble) g_value_get_int64 (&node_value));
retval = TRUE;
}
break;
case G_TYPE_FLOAT:
if (G_VALUE_HOLDS (&node_value, G_TYPE_DOUBLE))
{
g_value_set_float (value, (gfloat) g_value_get_double (&node_value));
retval = TRUE;
}
else if (G_VALUE_HOLDS (&node_value, G_TYPE_INT64))
{
g_value_set_float (value, (gfloat) g_value_get_int64 (&node_value));
retval = TRUE;
}
break;
case G_TYPE_ENUM:
{
gint enum_value = 0;
if (G_VALUE_HOLDS (&node_value, G_TYPE_INT64))
{
enum_value = g_value_get_int64 (&node_value);
retval = TRUE;
}
else if (G_VALUE_HOLDS (&node_value, G_TYPE_STRING))
{
retval = enum_from_string (G_VALUE_TYPE (value),
g_value_get_string (&node_value),
&enum_value);
}
if (retval)
g_value_set_enum (value, enum_value);
}
break;
case G_TYPE_FLAGS:
{
gint flags_value = 0;
if (G_VALUE_HOLDS (&node_value, G_TYPE_INT64))
{
flags_value = g_value_get_int64 (&node_value);
retval = TRUE;
}
else if (G_VALUE_HOLDS (&node_value, G_TYPE_STRING))
{
retval = flags_from_string (G_VALUE_TYPE (value),
g_value_get_string (&node_value),
&flags_value);
}
if (retval)
g_value_set_flags (value, flags_value);
}
break;
default:
retval = FALSE;
break;
}
g_value_unset (&node_value);
break;
case JSON_NODE_NULL:
if (G_TYPE_FUNDAMENTAL (G_VALUE_TYPE (value)) == G_TYPE_STRING)
{
g_value_set_string (value, NULL);
retval = TRUE;
}
else if (G_TYPE_FUNDAMENTAL (G_VALUE_TYPE (value)) == G_TYPE_OBJECT)
{
g_value_set_object (value, NULL);
retval = TRUE;
}
else
retval = FALSE;
break;
}
return retval;
}
static JSBool
gjs_value_to_g_value_internal(JSContext *context,
jsval value,
GValue *gvalue,
gboolean no_copy)
{
GType gtype;
gtype = G_VALUE_TYPE(gvalue);
if (gtype == 0) {
gtype = gjs_value_guess_g_type(context, value);
if (gtype == G_TYPE_INVALID) {
gjs_throw(context, "Could not guess unspecified GValue type");
return JS_FALSE;
}
gjs_debug_marshal(GJS_DEBUG_GCLOSURE,
"Guessed GValue type %s from JS Value",
g_type_name(gtype));
g_value_init(gvalue, gtype);
}
gjs_debug_marshal(GJS_DEBUG_GCLOSURE,
"Converting jsval to gtype %s",
g_type_name(gtype));
if (gtype == G_TYPE_STRING) {
/* Don't use ValueToString since we don't want to just toString()
* everything automatically
*/
if (JSVAL_IS_NULL(value)) {
g_value_set_string(gvalue, NULL);
} else if (JSVAL_IS_STRING(value)) {
gchar *utf8_string;
if (!gjs_string_to_utf8(context, value, &utf8_string))
return JS_FALSE;
g_value_take_string(gvalue, utf8_string);
} else {
gjs_throw(context,
"Wrong type %s; string expected",
gjs_get_type_name(value));
return JS_FALSE;
}
} else if (gtype == G_TYPE_CHAR) {
gint32 i;
if (JS_ValueToInt32(context, value, &i) && i >= SCHAR_MIN && i <= SCHAR_MAX) {
g_value_set_schar(gvalue, (signed char)i);
} else {
gjs_throw(context,
"Wrong type %s; char expected",
gjs_get_type_name(value));
return JS_FALSE;
}
} else if (gtype == G_TYPE_UCHAR) {
guint16 i;
if (JS_ValueToUint16(context, value, &i) && i <= UCHAR_MAX) {
g_value_set_uchar(gvalue, (unsigned char)i);
} else {
gjs_throw(context,
"Wrong type %s; unsigned char expected",
gjs_get_type_name(value));
return JS_FALSE;
}
} else if (gtype == G_TYPE_INT) {
gint32 i;
if (JS_ValueToInt32(context, value, &i)) {
g_value_set_int(gvalue, i);
} else {
gjs_throw(context,
"Wrong type %s; integer expected",
gjs_get_type_name(value));
return JS_FALSE;
}
} else if (gtype == G_TYPE_DOUBLE) {
gdouble d;
if (JS_ValueToNumber(context, value, &d)) {
g_value_set_double(gvalue, d);
} else {
gjs_throw(context,
"Wrong type %s; double expected",
gjs_get_type_name(value));
return JS_FALSE;
}
} else if (gtype == G_TYPE_FLOAT) {
gdouble d;
if (JS_ValueToNumber(context, value, &d)) {
g_value_set_float(gvalue, d);
} else {
gjs_throw(context,
"Wrong type %s; float expected",
gjs_get_type_name(value));
return JS_FALSE;
}
} else if (gtype == G_TYPE_UINT) {
guint32 i;
if (JS_ValueToECMAUint32(context, value, &i)) {
g_value_set_uint(gvalue, i);
} else {
gjs_throw(context,
"Wrong type %s; unsigned integer expected",
gjs_get_type_name(value));
return JS_FALSE;
}
} else if (gtype == G_TYPE_BOOLEAN) {
JSBool b;
/* JS_ValueToBoolean() pretty much always succeeds,
* which is maybe surprising sometimes, but could
* be handy also...
*/
if (JS_ValueToBoolean(context, value, &b)) {
g_value_set_boolean(gvalue, b);
} else {
gjs_throw(context,
"Wrong type %s; boolean expected",
gjs_get_type_name(value));
return JS_FALSE;
}
} else if (g_type_is_a(gtype, G_TYPE_OBJECT) || g_type_is_a(gtype, G_TYPE_INTERFACE)) {
GObject *gobj;
gobj = NULL;
if (JSVAL_IS_NULL(value)) {
/* nothing to do */
} else if (JSVAL_IS_OBJECT(value)) {
JSObject *obj;
obj = JSVAL_TO_OBJECT(value);
if (!gjs_typecheck_object(context, obj,
gtype, JS_TRUE))
return JS_FALSE;
gobj = gjs_g_object_from_object(context, obj);
} else {
gjs_throw(context,
"Wrong type %s; object %s expected",
gjs_get_type_name(value),
g_type_name(gtype));
return JS_FALSE;
}
g_value_set_object(gvalue, gobj);
} else if (gtype == G_TYPE_STRV) {
if (JSVAL_IS_NULL(value)) {
/* do nothing */
} else if (gjs_object_has_property(context,
JSVAL_TO_OBJECT(value),
"length")) {
jsval length_value;
guint32 length;
if (!gjs_object_require_property(context,
JSVAL_TO_OBJECT(value), NULL,
"length",
&length_value) ||
!JS_ValueToECMAUint32(context, length_value, &length)) {
gjs_throw(context,
"Wrong type %s; strv expected",
gjs_get_type_name(value));
return JS_FALSE;
} else {
void *result;
char **strv;
if (!gjs_array_to_strv (context,
value,
length, &result))
return JS_FALSE;
/* cast to strv in a separate step to avoid type-punning */
strv = result;
g_value_take_boxed (gvalue, strv);
}
} else {
gjs_throw(context,
"Wrong type %s; strv expected",
gjs_get_type_name(value));
return JS_FALSE;
}
} else if (g_type_is_a(gtype, G_TYPE_BOXED)) {
void *gboxed;
gboxed = NULL;
if (JSVAL_IS_NULL(value)) {
/* nothing to do */
} else if (JSVAL_IS_OBJECT(value)) {
JSObject *obj;
obj = JSVAL_TO_OBJECT(value);
if (g_type_is_a(gtype, G_TYPE_ERROR)) {
/* special case GError */
if (!gjs_typecheck_gerror(context, obj, JS_TRUE))
return JS_FALSE;
gboxed = gjs_gerror_from_error(context, obj);
} else {
/* First try a union, if that fails,
assume a boxed struct. Distinguishing
which one is expected would require checking
the associated GIBaseInfo, which is not necessary
possible, if e.g. we see the GType without
loading the typelib.
*/
if (gjs_typecheck_union(context, obj,
NULL, gtype, JS_FALSE)) {
gboxed = gjs_c_union_from_union(context, obj);
} else {
if (!gjs_typecheck_boxed(context, obj,
NULL, gtype, JS_TRUE))
return JS_FALSE;
gboxed = gjs_c_struct_from_boxed(context, obj);
}
}
} else {
gjs_throw(context,
"Wrong type %s; boxed type %s expected",
gjs_get_type_name(value),
g_type_name(gtype));
return JS_FALSE;
}
if (no_copy)
g_value_set_static_boxed(gvalue, gboxed);
else
g_value_set_boxed(gvalue, gboxed);
} else if (g_type_is_a(gtype, G_TYPE_VARIANT)) {
GVariant *variant = NULL;
if (JSVAL_IS_NULL(value)) {
/* nothing to do */
} else if (JSVAL_IS_OBJECT(value)) {
JSObject *obj = JSVAL_TO_OBJECT(value);
if (!gjs_typecheck_boxed(context, obj,
NULL, G_TYPE_VARIANT, JS_TRUE))
return JS_FALSE;
variant = gjs_c_struct_from_boxed(context, obj);
} else {
gjs_throw(context,
"Wrong type %s; boxed type %s expected",
gjs_get_type_name(value),
g_type_name(gtype));
return JS_FALSE;
}
g_value_set_variant (gvalue, variant);
} else if (g_type_is_a(gtype, G_TYPE_ENUM)) {
gint64 value_int64;
if (gjs_value_to_int64 (context, value, &value_int64)) {
GEnumValue *v;
/* See arg.c:_gjs_enum_to_int() */
v = g_enum_get_value(G_ENUM_CLASS(g_type_class_peek(gtype)),
(int)value_int64);
if (v == NULL) {
gjs_throw(context,
"%d is not a valid value for enumeration %s",
JSVAL_TO_INT(value), g_type_name(gtype));
return JS_FALSE;
}
g_value_set_enum(gvalue, v->value);
} else {
gjs_throw(context,
"Wrong type %s; enum %s expected",
gjs_get_type_name(value),
g_type_name(gtype));
return JS_FALSE;
}
} else if (g_type_is_a(gtype, G_TYPE_FLAGS)) {
gint64 value_int64;
if (gjs_value_to_int64 (context, value, &value_int64)) {
if (!_gjs_flags_value_is_valid(context, gtype, value_int64))
return JS_FALSE;
/* See arg.c:_gjs_enum_to_int() */
g_value_set_flags(gvalue, (int)value_int64);
} else {
gjs_throw(context,
"Wrong type %s; flags %s expected",
gjs_get_type_name(value),
g_type_name(gtype));
return JS_FALSE;
}
} else if (g_type_is_a(gtype, G_TYPE_PARAM)) {
void *gparam;
gparam = NULL;
if (JSVAL_IS_NULL(value)) {
/* nothing to do */
} else if (JSVAL_IS_OBJECT(value)) {
JSObject *obj;
obj = JSVAL_TO_OBJECT(value);
if (!gjs_typecheck_param(context, obj, gtype, JS_TRUE))
return JS_FALSE;
gparam = gjs_g_param_from_param(context, obj);
} else {
gjs_throw(context,
"Wrong type %s; param type %s expected",
gjs_get_type_name(value),
g_type_name(gtype));
return JS_FALSE;
}
g_value_set_param(gvalue, gparam);
} else if (g_type_is_a(gtype, G_TYPE_GTYPE)) {
GType type;
if (!JSVAL_IS_OBJECT(value)) {
gjs_throw(context, "Wrong type %s; expect a GType object",
gjs_get_type_name(value));
return JS_FALSE;
}
type = gjs_gtype_get_actual_gtype(context, JSVAL_TO_OBJECT(value));
g_value_set_gtype(gvalue, type);
} else if (g_type_is_a(gtype, G_TYPE_POINTER)) {
if (JSVAL_IS_NULL(value)) {
/* Nothing to do */
} else {
gjs_throw(context,
"Cannot convert non-null JS value to G_POINTER");
return JS_FALSE;
}
} else if (JSVAL_IS_NUMBER(value) &&
g_value_type_transformable(G_TYPE_INT, gtype)) {
/* Only do this crazy gvalue transform stuff after we've
* exhausted everything else. Adding this for
* e.g. ClutterUnit.
*/
gint32 i;
if (JS_ValueToInt32(context, value, &i)) {
GValue int_value = { 0, };
g_value_init(&int_value, G_TYPE_INT);
g_value_set_int(&int_value, i);
g_value_transform(&int_value, gvalue);
} else {
gjs_throw(context,
"Wrong type %s; integer expected",
gjs_get_type_name(value));
return JS_FALSE;
}
} else {
gjs_debug(GJS_DEBUG_GCLOSURE, "jsval is number %d gtype fundamental %d transformable to int %d from int %d",
JSVAL_IS_NUMBER(value),
G_TYPE_IS_FUNDAMENTAL(gtype),
g_value_type_transformable(gtype, G_TYPE_INT),
g_value_type_transformable(G_TYPE_INT, gtype));
gjs_throw(context,
"Don't know how to convert JavaScript object to GType %s",
g_type_name(gtype));
return JS_FALSE;
}
return JS_TRUE;
}
static GdaRow *
fetch_next_sqlite_row (GdaSqliteRecordset *model, gboolean do_store, GError **error)
{
int rc;
SqliteConnectionData *cdata;
GdaSqlitePStmt *ps;
GdaRow *prow = NULL;
GdaConnection *cnc;
glong length;
cnc = gda_data_select_get_connection ((GdaDataSelect*) model);
cdata = (SqliteConnectionData*) gda_connection_internal_get_provider_data_error (cnc, error);
if (!cdata)
return NULL;
ps = GDA_SQLITE_PSTMT (GDA_DATA_SELECT (model)->prep_stmt);
virt_cnc_set_working_obj (gda_data_select_get_connection ((GdaDataSelect*) model), model);
if (model->priv->empty_forced)
rc = SQLITE_DONE;
else
rc = SQLITE3_CALL (sqlite3_step) (ps->sqlite_stmt);
switch (rc) {
case SQLITE_ROW: {
gint col, real_col;
prow = gda_row_new (_GDA_PSTMT (ps)->ncols);
for (col = 0; col < _GDA_PSTMT (ps)->ncols; col++) {
GValue *value;
GType type = _GDA_PSTMT (ps)->types [col];
real_col = col + ps->nb_rowid_columns;
if (type == GDA_TYPE_NULL) {
type = fuzzy_get_gtype (cdata, ps, col);
if (type == GDA_TYPE_BLOB) {
/* extra check: make sure we have a rowid for this blob, or fallback to binary */
if (ps->rowid_hash) {
gint oidcol = 0;
const char *ctable;
ctable = SQLITE3_CALL (sqlite3_column_name) (ps->sqlite_stmt, real_col);
if (ctable)
oidcol = GPOINTER_TO_INT (g_hash_table_lookup (ps->rowid_hash,
ctable));
if (oidcol == 0) {
ctable = SQLITE3_CALL (sqlite3_column_table_name) (ps->sqlite_stmt, real_col);
if (ctable)
oidcol = GPOINTER_TO_INT (g_hash_table_lookup (ps->rowid_hash,
ctable));
}
if (oidcol == 0)
type = GDA_TYPE_BINARY;
}
else
type = GDA_TYPE_BINARY;
}
if (type != GDA_TYPE_NULL) {
GdaColumn *column;
_GDA_PSTMT (ps)->types [col] = type;
column = gda_data_model_describe_column (GDA_DATA_MODEL (model), col);
gda_column_set_g_type (column, type);
column = (GdaColumn *) g_slist_nth_data (_GDA_PSTMT (ps)->tmpl_columns, col);
gda_column_set_g_type (column, type);
}
}
/* fill GValue */
value = gda_row_get_value (prow, col);
GError *may_error;
may_error = (GError*) SQLITE3_CALL (sqlite3_column_blob) (ps->sqlite_stmt, real_col);
if (may_error && g_hash_table_lookup (error_blobs_hash, may_error)) {
/*g_print ("Row invalidated: [%s]\n", may_error->message);*/
gda_row_invalidate_value_e (prow, value, may_error);
g_hash_table_remove (error_blobs_hash, may_error);
}
else if (SQLITE3_CALL (sqlite3_column_text) (ps->sqlite_stmt, real_col) == NULL) {
/* we have a NULL value */
gda_value_set_null (value);
}
else {
gda_value_reset_with_type (value, type);
if (type == GDA_TYPE_NULL)
;
else if (type == G_TYPE_INT) {
gint64 i;
i = SQLITE3_CALL (sqlite3_column_int64) (ps->sqlite_stmt, real_col);
if ((i > G_MAXINT) || (i < G_MININT)) {
GError *lerror = NULL;
g_set_error (&lerror, GDA_SERVER_PROVIDER_ERROR,
GDA_SERVER_PROVIDER_DATA_ERROR,
"%s", _("Integer value is too big"));
gda_row_invalidate_value_e (prow, value, lerror);
}
else
g_value_set_int (value, (gint) i);
}
else if (type == G_TYPE_UINT) {
guint64 i;
i = (gint64) SQLITE3_CALL (sqlite3_column_int64) (ps->sqlite_stmt, real_col);
if (i > G_MAXUINT) {
GError *lerror = NULL;
g_set_error (&lerror, GDA_SERVER_PROVIDER_ERROR,
GDA_SERVER_PROVIDER_DATA_ERROR,
"%s", _("Integer value is too big"));
gda_row_invalidate_value_e (prow, value, lerror);
}
else
g_value_set_uint (value, (gint) i);
}
else if (type == G_TYPE_INT64)
g_value_set_int64 (value, SQLITE3_CALL (sqlite3_column_int64) (ps->sqlite_stmt, real_col));
else if (type == G_TYPE_UINT64)
g_value_set_uint64 (value, (guint64) SQLITE3_CALL (sqlite3_column_int64) (ps->sqlite_stmt,
real_col));
else if (type == G_TYPE_DOUBLE)
g_value_set_double (value, SQLITE3_CALL (sqlite3_column_double) (ps->sqlite_stmt,
real_col));
else if (type == G_TYPE_STRING)
g_value_set_string (value, (gchar *) SQLITE3_CALL (sqlite3_column_text) (ps->sqlite_stmt,
real_col));
else if (type == GDA_TYPE_BINARY) {
GdaBinary *bin;
bin = gda_binary_new ();
length = SQLITE3_CALL (sqlite3_column_bytes) (ps->sqlite_stmt, real_col);
if (length > 0) {
gda_binary_set_data (bin, SQLITE3_CALL (sqlite3_column_blob) (ps->sqlite_stmt, /* Flawfinder: ignore */
real_col), length);
}
gda_value_take_binary (value, bin);
}
else if (type == GDA_TYPE_BLOB) {
GdaBlobOp *bop = NULL;
gint oidcol = 0;
if (ps->rowid_hash) {
const char *ctable;
ctable = SQLITE3_CALL (sqlite3_column_name) (ps->sqlite_stmt, real_col);
if (ctable)
oidcol = GPOINTER_TO_INT (g_hash_table_lookup (ps->rowid_hash,
ctable));
if (oidcol == 0) {
ctable = SQLITE3_CALL (sqlite3_column_table_name) (ps->sqlite_stmt, real_col);
if (ctable)
oidcol = GPOINTER_TO_INT (g_hash_table_lookup (ps->rowid_hash,
ctable));
}
}
if (oidcol != 0) {
gint64 rowid;
rowid = SQLITE3_CALL (sqlite3_column_int64) (ps->sqlite_stmt, oidcol - 1); /* remove 1
because it was added in the first place */
bop = _gda_sqlite_blob_op_new (cnc,
SQLITE3_CALL (sqlite3_column_database_name) (ps->sqlite_stmt,
real_col),
SQLITE3_CALL (sqlite3_column_table_name) (ps->sqlite_stmt,
real_col),
SQLITE3_CALL (sqlite3_column_origin_name) (ps->sqlite_stmt,
real_col),
rowid);
}
if (!bop) {
GError *lerror = NULL;
g_set_error (&lerror, GDA_SERVER_PROVIDER_ERROR,
GDA_SERVER_PROVIDER_DATA_ERROR,
"%s", _("Unable to open BLOB"));
gda_row_invalidate_value_e (prow, value, lerror);
}
else {
GdaBlob *blob;
blob = gda_blob_new ();
gda_blob_set_op (blob, bop);
g_object_unref (bop);
gda_value_take_blob (value, blob);
}
}
else if (type == G_TYPE_BOOLEAN)
g_value_set_boolean (value, SQLITE3_CALL (sqlite3_column_int) (ps->sqlite_stmt, real_col) == 0 ? FALSE : TRUE);
else if (type == G_TYPE_DATE) {
GDate date;
if (!gda_parse_iso8601_date (&date,
(gchar *) SQLITE3_CALL (sqlite3_column_text) (ps->sqlite_stmt,
real_col))) {
GError *lerror = NULL;
g_set_error (&lerror, GDA_SERVER_PROVIDER_ERROR,
GDA_SERVER_PROVIDER_DATA_ERROR,
_("Invalid date '%s' (date format should be YYYY-MM-DD)"),
(gchar *) SQLITE3_CALL (sqlite3_column_text) (ps->sqlite_stmt, real_col));
gda_row_invalidate_value_e (prow, value, lerror);
}
else
g_value_set_boxed (value, &date);
}
else if (type == GDA_TYPE_TIME) {
GdaTime timegda;
if (!gda_parse_iso8601_time (&timegda,
(gchar *) SQLITE3_CALL (sqlite3_column_text) (ps->sqlite_stmt,
real_col))) {
GError *lerror = NULL;
g_set_error (&lerror, GDA_SERVER_PROVIDER_ERROR,
GDA_SERVER_PROVIDER_DATA_ERROR,
_("Invalid time '%s' (time format should be HH:MM:SS[.ms])"),
(gchar *) SQLITE3_CALL (sqlite3_column_text) (ps->sqlite_stmt, real_col));
gda_row_invalidate_value_e (prow, value, lerror);
}
else {
if (timegda.timezone == GDA_TIMEZONE_INVALID)
timegda.timezone = 0; /* set to GMT */
gda_value_set_time (value, &timegda);
}
}
else if (type == GDA_TYPE_TIMESTAMP) {
GdaTimestamp timestamp;
if (!gda_parse_iso8601_timestamp (×tamp,
(gchar *) SQLITE3_CALL (sqlite3_column_text) (ps->sqlite_stmt,
real_col))) {
GError *lerror = NULL;
g_set_error (&lerror, GDA_SERVER_PROVIDER_ERROR,
GDA_SERVER_PROVIDER_DATA_ERROR,
_("Invalid timestamp '%s' (format should be YYYY-MM-DD HH:MM:SS[.ms])"),
(gchar *) SQLITE3_CALL (sqlite3_column_text) (ps->sqlite_stmt, real_col));
gda_row_invalidate_value_e (prow, value, lerror);
}
else {
if (timestamp.timezone == GDA_TIMEZONE_INVALID)
timestamp.timezone = 0; /* set to GMT */
gda_value_set_timestamp (value, ×tamp);
}
}
else if (type == G_TYPE_CHAR) {
gint64 i;
i = (gint64) SQLITE3_CALL (sqlite3_column_int64) (ps->sqlite_stmt, real_col);
if ((i > G_MAXINT8) || (i < G_MININT8)) {
GError *lerror = NULL;
g_set_error (&lerror, GDA_SERVER_PROVIDER_ERROR,
GDA_SERVER_PROVIDER_DATA_ERROR,
"%s", _("Integer value is too big"));
gda_row_invalidate_value_e (prow, value, lerror);
}
else
g_value_set_schar (value, (gchar) i);
}
else if (type == G_TYPE_UCHAR) {
gint64 i;
i = (gint64) SQLITE3_CALL (sqlite3_column_int64) (ps->sqlite_stmt, real_col);
if ((i > G_MAXUINT8) || (i < 0)) {
GError *lerror = NULL;
g_set_error (&lerror, GDA_SERVER_PROVIDER_ERROR,
GDA_SERVER_PROVIDER_DATA_ERROR,
"%s", _("Integer value is too big"));
gda_row_invalidate_value_e (prow, value, lerror);
}
else
g_value_set_uchar (value, (guchar) i);
}
else if (type == GDA_TYPE_SHORT) {
gint64 i;
i = (gint64) SQLITE3_CALL (sqlite3_column_int64) (ps->sqlite_stmt, real_col);
if ((i > G_MAXSHORT) || (i < G_MINSHORT)) {
GError *lerror = NULL;
g_set_error (&lerror, GDA_SERVER_PROVIDER_ERROR,
GDA_SERVER_PROVIDER_DATA_ERROR,
"%s", _("Integer value is too big"));
gda_row_invalidate_value_e (prow, value, lerror);
}
else
gda_value_set_short (value, (guchar) i);
}
else if (type == GDA_TYPE_USHORT) {
gint64 i;
i = (gint64) SQLITE3_CALL (sqlite3_column_int64) (ps->sqlite_stmt, real_col);
if ((i > G_MAXUSHORT) || (i < 0)) {
GError *lerror = NULL;
g_set_error (&lerror, GDA_SERVER_PROVIDER_ERROR,
GDA_SERVER_PROVIDER_DATA_ERROR,
"%s", _("Integer value is too big"));
gda_row_invalidate_value_e (prow, value, lerror);
}
else
gda_value_set_ushort (value, (guchar) i);
}
else {
GError *lerror = NULL;
g_set_error (&lerror, GDA_SERVER_PROVIDER_ERROR,
GDA_SERVER_PROVIDER_DATA_ERROR,
"Unhandled type '%s' in SQLite recordset",
gda_g_type_to_string (_GDA_PSTMT (ps)->types [col]));
gda_row_invalidate_value_e (prow, value, lerror);
}
}
}
if (do_store) {
/* insert row */
gda_data_select_take_row (GDA_DATA_SELECT (model), prow, model->priv->next_row_num);
}
model->priv->next_row_num ++;
break;
}
case SQLITE_BUSY:
/* nothing to do */
break;
case SQLITE_DONE:
GDA_DATA_SELECT (model)->advertized_nrows = model->priv->next_row_num;
SQLITE3_CALL (sqlite3_reset) (ps->sqlite_stmt);
break;
case SQLITE_READONLY:
case SQLITE_MISUSE:
g_set_error (error, GDA_SERVER_PROVIDER_ERROR,
GDA_SERVER_PROVIDER_INTERNAL_ERROR,
"%s", _("SQLite provider fatal internal error"));
break;
case SQLITE_ERROR:
default: {
GError *lerror = NULL;
SQLITE3_CALL (sqlite3_reset) (ps->sqlite_stmt);
if (rc == SQLITE_IOERR_TRUNCATE)
g_set_error (&lerror, GDA_DATA_MODEL_ERROR,
GDA_DATA_MODEL_TRUNCATED_ERROR, "%s", _("Truncated data"));
else
g_set_error (&lerror, GDA_SERVER_PROVIDER_ERROR,
GDA_SERVER_PROVIDER_INTERNAL_ERROR,
"%s", SQLITE3_CALL (sqlite3_errmsg) (cdata->connection));
gda_data_select_add_exception (GDA_DATA_SELECT (model), lerror);
if (rc == SQLITE_ERROR)
g_propagate_error (error, g_error_copy (lerror));
GDA_DATA_SELECT (model)->advertized_nrows = model->priv->next_row_num;
break;
}
}
virt_cnc_set_working_obj (gda_data_select_get_connection ((GdaDataSelect*) model), NULL);
return prow;
}
void
gy_value_set_iarg(GValue* pval, GITypeInfo * info, int iarg)
{
GY_DEBUG("in gy_value_set_iarg\n");
GITypeTag type = g_type_info_get_tag(info);
GIBaseInfo * itrf;
switch (type) {
case GI_TYPE_TAG_BOOLEAN:
g_value_set_boolean(pval, ygets_c(iarg));
break;
case GI_TYPE_TAG_INT8:
g_value_set_schar(pval, ygets_c(iarg));
break;
case GI_TYPE_TAG_UINT8:
g_value_set_uchar(pval, ygets_c(iarg));
break;
case GI_TYPE_TAG_INT16:
case GI_TYPE_TAG_INT32:
g_value_set_int(pval, ygets_i(iarg));
break;
case GI_TYPE_TAG_UINT16:
case GI_TYPE_TAG_UINT32:
g_value_set_uint(pval, ygets_i(iarg));
break;
case GI_TYPE_TAG_INT64:
g_value_set_int64(pval, ygets_l(iarg));
break;
case GI_TYPE_TAG_UINT64:
g_value_set_uint64(pval, ygets_l(iarg));
break;
case GI_TYPE_TAG_FLOAT:
g_value_set_float(pval, ygets_f(iarg));
break;
case GI_TYPE_TAG_DOUBLE:
g_value_set_double(pval, ygets_d(iarg));
break;
case GI_TYPE_TAG_GTYPE:
g_value_set_gtype(pval, ygets_l(iarg));
break;
case GI_TYPE_TAG_UTF8:
case GI_TYPE_TAG_FILENAME:
g_value_set_static_string (pval, ygets_q(iarg));
GY_DEBUG("GValue is string: \"%s\"\n", ygets_q(iarg));
break;
/* interface types */
case GI_TYPE_TAG_INTERFACE:
itrf = g_type_info_get_interface(info);
switch(g_base_info_get_type (itrf)) {
case GI_INFO_TYPE_ENUM:
g_value_set_enum (pval, ygets_l(iarg));
break;
case GI_INFO_TYPE_OBJECT:
g_value_set_object(pval, yget_gy_Object(iarg)->object);
break;
default:
y_errorn("Unimplemented GValue interface type %ld",
g_base_info_get_type (itrf));
}
g_base_info_unref(itrf);
break;
case GI_TYPE_TAG_VOID:
default:
y_error("Unimplement property GValue type");
}
GY_DEBUG("out gy_iarg2gvalue\n");
}
static void
test_copying (void)
{
GValue value = { 0, };
gchar *error;
{
gchar c = 0;
g_value_init (&value, G_TYPE_CHAR);
g_value_set_char (&value, 'c');
error = lcopy (&value, &c);
g_assert (error == NULL);
g_assert (c == 'c');
}
{
guchar c = 0;
g_value_unset (&value);
g_value_init (&value, G_TYPE_UCHAR);
g_value_set_uchar (&value, 129);
error = lcopy (&value, &c);
g_assert (error == NULL);
g_assert (c == 129);
}
{
gint c = 0;
g_value_unset (&value);
g_value_init (&value, G_TYPE_INT);
g_value_set_int (&value, G_MAXINT);
error = lcopy (&value, &c);
g_assert (error == NULL);
g_assert (c == G_MAXINT);
}
{
guint c = 0;
g_value_unset (&value);
g_value_init (&value, G_TYPE_UINT);
g_value_set_uint (&value, G_MAXUINT);
error = lcopy (&value, &c);
g_assert (error == NULL);
g_assert (c == G_MAXUINT);
}
{
glong c = 0;
g_value_unset (&value);
g_value_init (&value, G_TYPE_LONG);
g_value_set_long (&value, G_MAXLONG);
error = lcopy (&value, &c);
g_assert (error == NULL);
g_assert (c == G_MAXLONG);
}
{
gulong c = 0;
g_value_unset (&value);
g_value_init (&value, G_TYPE_ULONG);
g_value_set_ulong (&value, G_MAXULONG);
error = lcopy (&value, &c);
g_assert (error == NULL);
g_assert (c == G_MAXULONG);
}
{
gint64 c = 0;
g_value_unset (&value);
g_value_init (&value, G_TYPE_INT64);
g_value_set_int64 (&value, G_MAXINT64);
error = lcopy (&value, &c);
g_assert (error == NULL);
g_assert (c == G_MAXINT64);
}
{
guint64 c = 0;
g_value_unset (&value);
g_value_init (&value, G_TYPE_UINT64);
g_value_set_uint64 (&value, G_MAXUINT64);
error = lcopy (&value, &c);
g_assert (error == NULL);
g_assert (c == G_MAXUINT64);
}
{
gfloat c = 0;
g_value_unset (&value);
g_value_init (&value, G_TYPE_FLOAT);
g_value_set_float (&value, G_MAXFLOAT);
error = lcopy (&value, &c);
g_assert (error == NULL);
g_assert (c == G_MAXFLOAT);
}
{
gdouble c = 0;
g_value_unset (&value);
g_value_init (&value, G_TYPE_DOUBLE);
g_value_set_double (&value, G_MAXDOUBLE);
error = lcopy (&value, &c);
g_assert (error == NULL);
g_assert (c == G_MAXDOUBLE);
}
{
gchar *c = NULL;
g_value_unset (&value);
g_value_init (&value, G_TYPE_STRING);
g_value_set_string (&value, "string ?");
error = lcopy (&value, &c);
g_assert (error == NULL);
g_assert (strcmp (c, "string ?") == 0);
}
{
GType c = G_TYPE_NONE;
g_value_unset (&value);
g_value_init (&value, G_TYPE_GTYPE);
g_value_set_gtype (&value, G_TYPE_BOXED);
error = lcopy (&value, &c);
g_assert (error == NULL);
g_assert (c == G_TYPE_BOXED);
}
}
static void
get_property (GObject *object, guint prop_id,
GValue *value, GParamSpec *pspec)
{
NMDeviceVxlanPrivate *priv = NM_DEVICE_VXLAN_GET_PRIVATE (object);
NMDevice *parent;
switch (prop_id) {
case PROP_PARENT:
parent = nm_manager_get_device_by_ifindex (nm_manager_get (), priv->props.parent_ifindex);
nm_utils_g_value_set_object_path (value, parent);
break;
case PROP_ID:
g_value_set_uint (value, priv->props.id);
break;
case PROP_GROUP:
if (priv->props.group)
g_value_set_string (value, nm_utils_inet4_ntop (priv->props.group, NULL));
else if (!IN6_IS_ADDR_UNSPECIFIED (&priv->props.group6))
g_value_set_string (value, nm_utils_inet6_ntop (&priv->props.group6, NULL));
break;
case PROP_LOCAL:
if (priv->props.local)
g_value_set_string (value, nm_utils_inet4_ntop (priv->props.local, NULL));
else if (!IN6_IS_ADDR_UNSPECIFIED (&priv->props.local6))
g_value_set_string (value, nm_utils_inet6_ntop (&priv->props.local6, NULL));
break;
case PROP_TOS:
g_value_set_uchar (value, priv->props.tos);
break;
case PROP_TTL:
g_value_set_uchar (value, priv->props.ttl);
break;
case PROP_LEARNING:
g_value_set_boolean (value, priv->props.learning);
break;
case PROP_AGEING:
g_value_set_uint (value, priv->props.ageing);
break;
case PROP_LIMIT:
g_value_set_uint (value, priv->props.limit);
break;
case PROP_DST_PORT:
g_value_set_uint (value, priv->props.dst_port);
break;
case PROP_SRC_PORT_MIN:
g_value_set_uint (value, priv->props.src_port_min);
break;
case PROP_SRC_PORT_MAX:
g_value_set_uint (value, priv->props.src_port_max);
break;
case PROP_PROXY:
g_value_set_boolean (value, priv->props.proxy);
break;
case PROP_RSC:
g_value_set_boolean (value, priv->props.rsc);
break;
case PROP_L2MISS:
g_value_set_boolean (value, priv->props.l2miss);
break;
case PROP_L3MISS:
g_value_set_boolean (value, priv->props.l3miss);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
gboolean
g_settings_get_mapping (GValue *value,
GVariant *variant,
gpointer user_data)
{
if (g_variant_is_of_type (variant, G_VARIANT_TYPE_BOOLEAN))
{
if (!G_VALUE_HOLDS_BOOLEAN (value))
return FALSE;
g_value_set_boolean (value, g_variant_get_boolean (variant));
return TRUE;
}
else if (g_variant_is_of_type (variant, G_VARIANT_TYPE_BYTE))
{
if (G_VALUE_HOLDS_UCHAR (value))
g_value_set_uchar (value, g_variant_get_byte (variant));
else if (G_VALUE_HOLDS_CHAR (value))
g_value_set_char (value, (gchar) g_variant_get_byte (variant));
else
return FALSE;
return TRUE;
}
else if (g_variant_is_of_type (variant, G_VARIANT_TYPE_INT16) ||
g_variant_is_of_type (variant, G_VARIANT_TYPE_INT32) ||
g_variant_is_of_type (variant, G_VARIANT_TYPE_INT64))
return g_settings_get_mapping_int (value, variant);
else if (g_variant_is_of_type (variant, G_VARIANT_TYPE_DOUBLE))
return g_settings_get_mapping_float (value, variant);
else if (g_variant_is_of_type (variant, G_VARIANT_TYPE_UINT16) ||
g_variant_is_of_type (variant, G_VARIANT_TYPE_UINT32) ||
g_variant_is_of_type (variant, G_VARIANT_TYPE_UINT64) ||
g_variant_is_of_type (variant, G_VARIANT_TYPE_HANDLE))
return g_settings_get_mapping_unsigned_int (value, variant);
else if (g_variant_is_of_type (variant, G_VARIANT_TYPE_STRING) ||
g_variant_is_of_type (variant, G_VARIANT_TYPE_OBJECT_PATH) ||
g_variant_is_of_type (variant, G_VARIANT_TYPE_SIGNATURE))
{
if (G_VALUE_HOLDS_STRING (value))
{
g_value_set_string (value, g_variant_get_string (variant, NULL));
return TRUE;
}
else if (G_VALUE_HOLDS_ENUM (value))
{
GEnumClass *eclass;
GEnumValue *evalue;
const gchar *nick;
/* GParamSpecEnum holds a ref on the class so we just peek... */
eclass = g_type_class_peek (G_VALUE_TYPE (value));
nick = g_variant_get_string (variant, NULL);
evalue = g_enum_get_value_by_nick (eclass, nick);
if (evalue)
{
g_value_set_enum (value, evalue->value);
return TRUE;
}
g_warning ("Unable to lookup enum nick '%s' via GType\n", nick);
return FALSE;
}
}
else if (g_variant_is_of_type (variant, G_VARIANT_TYPE ("as")))
{
if (G_VALUE_HOLDS (value, G_TYPE_STRV))
{
g_value_take_boxed (value, g_variant_dup_strv (variant, NULL));
return TRUE;
}
else if (G_VALUE_HOLDS_FLAGS (value))
{
GFlagsClass *fclass;
GFlagsValue *fvalue;
const gchar *nick;
GVariantIter iter;
guint flags = 0;
fclass = g_type_class_peek (G_VALUE_TYPE (value));
g_variant_iter_init (&iter, variant);
while (g_variant_iter_next (&iter, "&s", &nick))
{
fvalue = g_flags_get_value_by_nick (fclass, nick);
if (fvalue)
flags |= fvalue->value;
else
{
g_warning ("Unable to lookup flags nick '%s' via GType\n",
nick);
return FALSE;
}
}
g_value_set_flags (value, flags);
return TRUE;
}
}
else if (g_variant_is_of_type (variant, G_VARIANT_TYPE_BYTESTRING))
{
g_value_set_string (value, g_variant_get_bytestring (variant));
return TRUE;
}
g_critical ("No GSettings bind handler for type \"%s\".",
g_variant_get_type_string (variant));
return FALSE;
}
gint
pygi_set_property_value_real (PyGObject *instance,
const gchar *attr_name,
PyObject *py_value)
{
GType g_type;
GIPropertyInfo *property_info = NULL;
char *property_name = g_strdup (attr_name);
GITypeInfo *type_info = NULL;
GITypeTag type_tag;
GITransfer transfer;
GValue value = { 0, };
GIArgument arg = { 0, };
GParamSpec *pspec = NULL;
gint ret_value = -1;
canonicalize_key (property_name);
g_type = pyg_type_from_object ((PyObject *)instance);
property_info = _pygi_lookup_property_from_g_type (g_type, property_name);
if (property_info == NULL)
goto out;
pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (instance->obj),
attr_name);
if (pspec == NULL)
goto out;
if (! (pspec->flags & G_PARAM_WRITABLE))
goto out;
type_info = g_property_info_get_type (property_info);
transfer = g_property_info_get_ownership_transfer (property_info);
arg = _pygi_argument_from_object (py_value, type_info, transfer);
if (PyErr_Occurred())
goto out;
g_value_init (&value, G_PARAM_SPEC_VALUE_TYPE (pspec));
// FIXME: Lots of types still unhandled
type_tag = g_type_info_get_tag (type_info);
switch (type_tag) {
case GI_TYPE_TAG_INTERFACE:
{
GIBaseInfo *info;
GIInfoType info_type;
GType type;
info = g_type_info_get_interface (type_info);
type = g_registered_type_info_get_g_type (info);
info_type = g_base_info_get_type (info);
g_base_info_unref (info);
switch (info_type) {
case GI_INFO_TYPE_ENUM:
g_value_set_enum (&value, arg.v_int32);
break;
case GI_INFO_TYPE_INTERFACE:
case GI_INFO_TYPE_OBJECT:
g_value_set_object (&value, arg.v_pointer);
break;
case GI_INFO_TYPE_BOXED:
case GI_INFO_TYPE_STRUCT:
case GI_INFO_TYPE_UNION:
if (g_type_is_a (type, G_TYPE_BOXED)) {
g_value_set_boxed (&value, arg.v_pointer);
} else {
PyErr_Format (PyExc_NotImplementedError,
"Setting properties of type '%s' is not implemented",
g_type_name (type));
}
break;
default:
PyErr_Format (PyExc_NotImplementedError,
"Setting properties of type '%s' is not implemented",
g_type_name (type));
goto out;
}
break;
}
case GI_TYPE_TAG_BOOLEAN:
g_value_set_boolean (&value, arg.v_boolean);
break;
case GI_TYPE_TAG_INT8:
g_value_set_schar (&value, arg.v_int8);
break;
case GI_TYPE_TAG_INT16:
case GI_TYPE_TAG_INT32:
if (G_VALUE_HOLDS_LONG (&value))
g_value_set_long (&value, arg.v_long);
else
g_value_set_int (&value, arg.v_int);
break;
case GI_TYPE_TAG_INT64:
if (G_VALUE_HOLDS_LONG (&value))
g_value_set_long (&value, arg.v_long);
else
g_value_set_int64 (&value, arg.v_int64);
break;
case GI_TYPE_TAG_UINT8:
g_value_set_uchar (&value, arg.v_uint8);
break;
case GI_TYPE_TAG_UINT16:
case GI_TYPE_TAG_UINT32:
if (G_VALUE_HOLDS_ULONG (&value))
g_value_set_ulong (&value, arg.v_ulong);
else
g_value_set_uint (&value, arg.v_uint);
break;
case GI_TYPE_TAG_UINT64:
if (G_VALUE_HOLDS_ULONG (&value))
g_value_set_ulong (&value, arg.v_ulong);
else
g_value_set_uint64 (&value, arg.v_uint64);
break;
case GI_TYPE_TAG_FLOAT:
g_value_set_float (&value, arg.v_float);
break;
case GI_TYPE_TAG_DOUBLE:
g_value_set_double (&value, arg.v_double);
break;
case GI_TYPE_TAG_GTYPE:
g_value_set_gtype (&value, arg.v_size);
break;
case GI_TYPE_TAG_UTF8:
case GI_TYPE_TAG_FILENAME:
g_value_set_string (&value, arg.v_string);
break;
case GI_TYPE_TAG_GHASH:
g_value_set_boxed (&value, arg.v_pointer);
break;
case GI_TYPE_TAG_GLIST:
g_value_set_pointer (&value, arg.v_pointer);
break;
case GI_TYPE_TAG_ARRAY:
{
GArray *arg_items = (GArray*) arg.v_pointer;
gchar** strings;
int i;
if (arg_items == NULL)
goto out;
strings = g_new0 (char*, arg_items->len);
for (i = 0; i < arg_items->len; ++i) {
strings[i] = g_array_index (arg_items, GIArgument, i).v_string;
}
g_array_free (arg_items, TRUE);
g_value_set_boxed (&value, strings);
break;
}
default:
PyErr_Format (PyExc_NotImplementedError,
"Setting properties of type %s is not implemented",
g_type_tag_to_string (g_type_info_get_tag (type_info)));
goto out;
}
g_object_set_property (instance->obj, attr_name, &value);
ret_value = 0;
out:
g_free (property_name);
if (property_info != NULL)
g_base_info_unref (property_info);
if (type_info != NULL)
g_base_info_unref (type_info);
return ret_value;
}
void
rbgobj_rvalue_to_gvalue(VALUE val, GValue* result)
{
GType type, fundamental_type;
type = G_VALUE_TYPE(result);
if (rbgobj_convert_rvalue2gvalue(type, val, result))
return;
fundamental_type = G_TYPE_FUNDAMENTAL(type);
switch (fundamental_type) {
case G_TYPE_NONE:
return;
case G_TYPE_CHAR:
g_value_set_char(result, NUM2INT(val));
return;
case G_TYPE_UCHAR:
g_value_set_uchar(result, NUM2UINT(val));
return;
case G_TYPE_BOOLEAN:
g_value_set_boolean(result, RVAL2CBOOL(val));
return;
case G_TYPE_INT:
g_value_set_int(result, NUM2INT(val));
return;
case G_TYPE_UINT:
g_value_set_uint(result, NUM2UINT(val));
return;
case G_TYPE_LONG:
g_value_set_long(result, NUM2LONG(val));
return;
case G_TYPE_ULONG:
g_value_set_ulong(result, NUM2ULONG(val));
return;
case G_TYPE_INT64:
g_value_set_int64(result, rbglib_num_to_int64(val));
return;
case G_TYPE_UINT64:
g_value_set_uint64(result, rbglib_num_to_uint64(val));
return;
case G_TYPE_ENUM:
g_value_set_enum(result, rbgobj_get_enum(val, G_VALUE_TYPE(result)));
return;
case G_TYPE_FLAGS:
g_value_set_flags(result, rbgobj_get_flags(val, G_VALUE_TYPE(result)));
return;
case G_TYPE_FLOAT:
g_value_set_float(result, NUM2DBL(val));
return;
case G_TYPE_DOUBLE:
g_value_set_double(result, NUM2DBL(val));
return;
case G_TYPE_STRING:
{
if (SYMBOL_P(val))
val = rb_funcall(val, id_to_s, 0);
g_value_set_string(result, RVAL2CSTR_ACCEPT_NIL(val));
return;
}
case G_TYPE_OBJECT:
case G_TYPE_INTERFACE:
g_value_set_object(result, NIL_P(val) ? NULL : RVAL2GOBJ(val));
return;
case G_TYPE_PARAM:
g_value_set_param(result, NIL_P(val) ? NULL : RVAL2GOBJ(val));
return;
case G_TYPE_POINTER:
g_value_set_pointer(result, NIL_P(val) ? NULL : rbgobj_ptr2cptr(val));
return;
case G_TYPE_BOXED:
{
GType gtype;
for (gtype = type;
gtype != G_TYPE_INVALID;
gtype = g_type_parent(gtype))
{
RValueToGValueFunc func =
g_type_get_qdata(gtype, qRValueToGValueFunc);
if (!func)
continue;
func(val, result);
return;
}
}
default:
if (!rbgobj_convert_rvalue2gvalue(fundamental_type, val, result)) {
RValueToGValueFunc func =
g_type_get_qdata(type, qRValueToGValueFunc);
if (!func){
g_warning("rbgobj_rvalue_to_gvalue: unsupported type: %s\n",
g_type_name(type));
} else {
func(val, result);
}
}
}
}
gboolean
gvalue_util_set_value_from_string (GValue *value,
const char *str)
{
GValue tmp_value = {0, };
int i;
long l;
double d;
g_return_val_if_fail (str != NULL, FALSE);
switch (G_VALUE_TYPE (value)) {
case G_TYPE_STRING:
g_value_set_string (value, str);
break;
case G_TYPE_CHAR:
#if GLIB_CHECK_VERSION(2,32,0)
g_value_set_schar (value, *str);
#else
g_value_set_char (value, *str);
#endif
break;
case G_TYPE_UCHAR:
g_value_set_uchar (value, *str);
break;
case G_TYPE_INT:
i = atoi (str);
g_value_set_int (value, i);
break;
case G_TYPE_UINT:
i = atoi (str);
g_value_set_uint (value, (guint) i);
break;
case G_TYPE_INT64:
i = atoi (str);
g_value_set_int64 (value, (gint64) i);
break;
case G_TYPE_UINT64:
i = atoi (str);
g_value_set_uint64 (value, (guint64) i);
break;
case G_TYPE_LONG:
l = atol (str);
g_value_set_long (value, l);
break;
case G_TYPE_ULONG:
l = atol (str);
g_value_set_ulong (value, (gulong) l);
break;
case G_TYPE_FLOAT:
d = atof (str);
g_value_set_float (value, (float) d);
break;
case G_TYPE_DOUBLE:
d = atof (str);
g_value_set_float (value, d);
break;
case G_TYPE_BOOLEAN:
if (g_ascii_strcasecmp (str, "true") == 0 ||
g_ascii_strcasecmp (str, "yes") == 0)
g_value_set_boolean (value, TRUE);
else if (g_ascii_strcasecmp (str, "false") == 0 ||
g_ascii_strcasecmp (str, "no") == 0)
g_value_set_boolean (value, FALSE);
else {
int i;
i = atoi (str);
g_value_set_boolean (value, i ? TRUE : FALSE);
}
break;
default:
/* Try to convert */
if (g_value_type_transformable (G_TYPE_STRING,
G_VALUE_TYPE (value))) {
g_value_init (&tmp_value, G_TYPE_STRING);
g_value_set_static_string (&tmp_value, str);
g_value_transform (&tmp_value, value);
g_value_unset (&tmp_value);
} else if (g_value_type_transformable (G_TYPE_INT,
G_VALUE_TYPE (value))) {
i = atoi (str);
g_value_init (&tmp_value, G_TYPE_INT);
g_value_set_int (&tmp_value, i);
g_value_transform (&tmp_value, value);
g_value_unset (&tmp_value);
} else {
g_warning ("Failed to transform integer "
"value to type %s",
G_VALUE_TYPE_NAME (value));
return FALSE;
}
break;
}
return TRUE;
}
static gboolean json_deserialize_pspec (GValue *value, GParamSpec *pspec, json_t *node)
{
switch (json_typeof(node)) {
case JSON_OBJECT:
if (g_type_is_a (G_VALUE_TYPE (value), G_TYPE_OBJECT)) {
GObject *object;
object = json_gobject_deserialize (G_VALUE_TYPE (value), node);
if (object)
g_value_take_object (value, object);
else
g_value_set_object (value, NULL);
return TRUE;
}
break;
case JSON_STRING:
if (G_TYPE_FUNDAMENTAL (G_VALUE_TYPE (value)) == G_TYPE_STRING) {
g_value_set_string(value, json_string_value(node));
return TRUE;
}
break;
case JSON_INTEGER:
{
json_int_t int_value = json_integer_value (node);
switch (G_TYPE_FUNDAMENTAL (G_VALUE_TYPE (value))) {
case G_TYPE_CHAR:
g_value_set_schar(value, (gchar)int_value);
return TRUE;
case G_TYPE_UCHAR:
g_value_set_uchar (value, (guchar)int_value);
return TRUE;
case G_TYPE_INT:
g_value_set_int (value, (gint)int_value);
return TRUE;
case G_TYPE_UINT:
g_value_set_uint(value, (guint)int_value);
return TRUE;
case G_TYPE_LONG:
g_value_set_long(value, (glong)int_value);
return TRUE;
case G_TYPE_ULONG:
g_value_set_ulong(value, (gulong)int_value);
return TRUE;
case G_TYPE_INT64:
g_value_set_int64(value,(gint64)int_value);
return TRUE;
case G_TYPE_ENUM:
g_value_set_enum(value,(gint64)int_value);
return TRUE;
case G_TYPE_FLAGS:
g_value_set_flags(value,(gint64)int_value);
return TRUE;
}
}
break;
case JSON_REAL:
{
double real_value = json_real_value(node);
switch (G_TYPE_FUNDAMENTAL (G_VALUE_TYPE (value))) {
case G_TYPE_FLOAT:
g_value_set_float(value,(gfloat)real_value);
return TRUE;
case G_TYPE_DOUBLE:
g_value_set_double(value,(gdouble)real_value);
return TRUE;
}
}
break;
case JSON_TRUE:
case JSON_FALSE:
if (G_TYPE_FUNDAMENTAL (G_VALUE_TYPE (value)) == G_TYPE_BOOLEAN) {
g_value_set_boolean(value,(gboolean)json_is_true(node));
return TRUE;
}
break;
case JSON_NULL:
if (G_TYPE_FUNDAMENTAL (G_VALUE_TYPE (value)) == G_TYPE_STRING) {
g_value_set_string (value, NULL);
return TRUE;
}
else if (G_TYPE_FUNDAMENTAL (G_VALUE_TYPE (value)) == G_TYPE_OBJECT) {
g_value_set_object (value, NULL);
return TRUE;
}
break;
case JSON_ARRAY:
return FALSE;
break;
default:
return FALSE;
}
return FALSE;
}
void
_gtk_tree_data_list_node_to_value (GtkTreeDataList *list,
GType type,
GValue *value)
{
g_value_init (value, type);
switch (get_fundamental_type (type))
{
case G_TYPE_BOOLEAN:
g_value_set_boolean (value, (gboolean) list->data.v_int);
break;
case G_TYPE_CHAR:
g_value_set_schar (value, (gchar) list->data.v_char);
break;
case G_TYPE_UCHAR:
g_value_set_uchar (value, (guchar) list->data.v_uchar);
break;
case G_TYPE_INT:
g_value_set_int (value, (gint) list->data.v_int);
break;
case G_TYPE_UINT:
g_value_set_uint (value, (guint) list->data.v_uint);
break;
case G_TYPE_LONG:
g_value_set_long (value, list->data.v_long);
break;
case G_TYPE_ULONG:
g_value_set_ulong (value, list->data.v_ulong);
break;
case G_TYPE_INT64:
g_value_set_int64 (value, list->data.v_int64);
break;
case G_TYPE_UINT64:
g_value_set_uint64 (value, list->data.v_uint64);
break;
case G_TYPE_ENUM:
g_value_set_enum (value, list->data.v_int);
break;
case G_TYPE_FLAGS:
g_value_set_flags (value, list->data.v_uint);
break;
case G_TYPE_FLOAT:
g_value_set_float (value, (gfloat) list->data.v_float);
break;
case G_TYPE_DOUBLE:
g_value_set_double (value, (gdouble) list->data.v_double);
break;
case G_TYPE_STRING:
g_value_set_string (value, (gchar *) list->data.v_pointer);
break;
case G_TYPE_POINTER:
g_value_set_pointer (value, (gpointer) list->data.v_pointer);
break;
case G_TYPE_BOXED:
g_value_set_boxed (value, (gpointer) list->data.v_pointer);
break;
case G_TYPE_VARIANT:
g_value_set_variant (value, (gpointer) list->data.v_pointer);
break;
case G_TYPE_OBJECT:
g_value_set_object (value, (GObject *) list->data.v_pointer);
break;
default:
g_warning ("%s: Unsupported type (%s) retrieved.", G_STRLOC, g_type_name (value->g_type));
break;
}
}
/**
* g_dbus_gvariant_to_gvalue:
* @value: A #GVariant.
* @out_gvalue: (out): Return location pointing to a zero-filled (uninitialized) #GValue.
*
* Converts a #GVariant to a #GValue. If @value is floating, it is consumed.
*
* The rules specified in the g_dbus_gvalue_to_gvariant() function are
* used - this function is essentially its reverse form.
*
* The conversion never fails - a valid #GValue is always returned in
* @out_gvalue.
*
* Since: 2.30
*/
void
g_dbus_gvariant_to_gvalue (GVariant *value,
GValue *out_gvalue)
{
const GVariantType *type;
gchar **array;
g_return_if_fail (value != NULL);
g_return_if_fail (out_gvalue != NULL);
memset (out_gvalue, '\0', sizeof (GValue));
switch (g_variant_classify (value))
{
case G_VARIANT_CLASS_BOOLEAN:
g_value_init (out_gvalue, G_TYPE_BOOLEAN);
g_value_set_boolean (out_gvalue, g_variant_get_boolean (value));
break;
case G_VARIANT_CLASS_BYTE:
g_value_init (out_gvalue, G_TYPE_UCHAR);
g_value_set_uchar (out_gvalue, g_variant_get_byte (value));
break;
case G_VARIANT_CLASS_INT16:
g_value_init (out_gvalue, G_TYPE_INT);
g_value_set_int (out_gvalue, g_variant_get_int16 (value));
break;
case G_VARIANT_CLASS_UINT16:
g_value_init (out_gvalue, G_TYPE_UINT);
g_value_set_uint (out_gvalue, g_variant_get_uint16 (value));
break;
case G_VARIANT_CLASS_INT32:
g_value_init (out_gvalue, G_TYPE_INT);
g_value_set_int (out_gvalue, g_variant_get_int32 (value));
break;
case G_VARIANT_CLASS_UINT32:
g_value_init (out_gvalue, G_TYPE_UINT);
g_value_set_uint (out_gvalue, g_variant_get_uint32 (value));
break;
case G_VARIANT_CLASS_INT64:
g_value_init (out_gvalue, G_TYPE_INT64);
g_value_set_int64 (out_gvalue, g_variant_get_int64 (value));
break;
case G_VARIANT_CLASS_UINT64:
g_value_init (out_gvalue, G_TYPE_UINT64);
g_value_set_uint64 (out_gvalue, g_variant_get_uint64 (value));
break;
case G_VARIANT_CLASS_DOUBLE:
g_value_init (out_gvalue, G_TYPE_DOUBLE);
g_value_set_double (out_gvalue, g_variant_get_double (value));
break;
case G_VARIANT_CLASS_STRING:
g_value_init (out_gvalue, G_TYPE_STRING);
g_value_set_string (out_gvalue, g_variant_get_string (value, NULL));
break;
case G_VARIANT_CLASS_OBJECT_PATH:
g_value_init (out_gvalue, G_TYPE_STRING);
g_value_set_string (out_gvalue, g_variant_get_string (value, NULL));
break;
case G_VARIANT_CLASS_SIGNATURE:
g_value_init (out_gvalue, G_TYPE_STRING);
g_value_set_string (out_gvalue, g_variant_get_string (value, NULL));
break;
case G_VARIANT_CLASS_ARRAY:
type = g_variant_get_type (value);
switch (g_variant_type_peek_string (type)[1])
{
case G_VARIANT_CLASS_BYTE:
g_value_init (out_gvalue, G_TYPE_STRING);
g_value_set_string (out_gvalue, g_variant_get_bytestring (value));
break;
case G_VARIANT_CLASS_STRING:
g_value_init (out_gvalue, G_TYPE_STRV);
array = g_variant_dup_strv (value, NULL);
g_value_take_boxed (out_gvalue, array);
break;
case G_VARIANT_CLASS_OBJECT_PATH:
g_value_init (out_gvalue, G_TYPE_STRV);
array = g_variant_dup_objv (value, NULL);
g_value_take_boxed (out_gvalue, array);
break;
case G_VARIANT_CLASS_ARRAY:
switch (g_variant_type_peek_string (type)[2])
{
case G_VARIANT_CLASS_BYTE:
g_value_init (out_gvalue, G_TYPE_STRV);
array = g_variant_dup_bytestring_array (value, NULL);
g_value_take_boxed (out_gvalue, array);
break;
default:
g_value_init (out_gvalue, G_TYPE_VARIANT);
g_value_set_variant (out_gvalue, value);
break;
}
break;
default:
g_value_init (out_gvalue, G_TYPE_VARIANT);
g_value_set_variant (out_gvalue, value);
break;
}
break;
case G_VARIANT_CLASS_HANDLE:
case G_VARIANT_CLASS_VARIANT:
case G_VARIANT_CLASS_MAYBE:
case G_VARIANT_CLASS_TUPLE:
case G_VARIANT_CLASS_DICT_ENTRY:
g_value_init (out_gvalue, G_TYPE_VARIANT);
g_value_set_variant (out_gvalue, value);
break;
}
}
