static void
gdaui_numeric_entry_get_property (GObject *object,
guint param_id,
GValue *value,
GParamSpec *pspec)
{
GdauiNumericEntry *entry;
entry = GDAUI_NUMERIC_ENTRY (object);
if (entry->priv) {
switch (param_id) {
case PROP_TYPE:
g_value_set_gtype (value, entry->priv->type);
break;
case PROP_N_DECIMALS:
g_value_set_uint (value, entry->priv->nb_decimals);
break;
case PROP_DECIMAL_SEP:
g_value_set_schar (value, (gint8) entry->priv->decimal_sep);
break;
case PROP_THOUSANDS_SEP:
g_value_set_schar (value, (gint8) entry->priv->thousands_sep);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
break;
}
}
}
static void
get_property (GObject *object, guint prop_id,
GValue *value, GParamSpec *pspec)
{
NMSettingSerial *setting = NM_SETTING_SERIAL (object);
switch (prop_id) {
case PROP_BAUD:
g_value_set_uint (value, nm_setting_serial_get_baud (setting));
break;
case PROP_BITS:
g_value_set_uint (value, nm_setting_serial_get_bits (setting));
break;
case PROP_PARITY:
g_value_set_schar (value, nm_setting_serial_get_parity (setting));
break;
case PROP_STOPBITS:
g_value_set_uint (value, nm_setting_serial_get_stopbits (setting));
break;
case PROP_SEND_DELAY:
g_value_set_uint64 (value, nm_setting_serial_get_send_delay (setting));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
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);
}
}
static void gvir_sandbox_console_get_property(GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
GVirSandboxConsole *console = GVIR_SANDBOX_CONSOLE(object);
GVirSandboxConsolePrivate *priv = console->priv;
switch (prop_id) {
case PROP_CONNECTION:
g_value_set_object(value, priv->connection);
break;
case PROP_DOMAIN:
g_value_set_object(value, priv->domain);
break;
case PROP_DEVNAME:
g_value_set_string(value, priv->devname);
break;
case PROP_ESCAPE:
g_value_set_schar(value, priv->escape);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
}
}
int
main (int argc, char ** argv)
{
gst_init (&argc, &argv);
GMainLoop* loop = g_main_loop_new (NULL, FALSE);
pipe = gst_pipeline_new ("pipeline");
src = gst_element_factory_make ("filesrc", NULL);
// this parses the FLAC tags to replay gain stuff.
GstElement* decoder = gst_element_factory_make("decodebin2",NULL);
GstElement* converter = gst_element_factory_make("audioconvert",NULL);
GstElement* analyzer = gst_element_factory_make("rganalysis",NULL);
GstElement* alsa = gst_element_factory_make("fakesink", NULL);
if(!(src && decoder && converter && analyzer && alsa))
g_error("_______ could not be created");
GValue val = { 0, };
g_value_init (&val, G_TYPE_INT);
g_value_set_schar (&val, 1);
g_object_set_property(G_OBJECT(analyzer),"num-tracks",&val);
g_value_unset(&val);
GstBus* bus = gst_pipeline_get_bus (GST_PIPELINE (pipe));
gst_bus_add_watch (bus, bus_call, loop);
g_object_unref(bus);
gst_bin_add_many (GST_BIN (pipe), src, decoder,
converter, analyzer, alsa, NULL);
// src -> decoder ...> converter -> analyzer -> sink
gst_element_link(src,decoder);
g_signal_connect (decoder, "pad-added", G_CALLBACK (on_new_pad), converter);
gst_element_link_many(converter, analyzer, alsa, NULL);
if(argc==2) {
GString* next = g_string_new(argv[1]);
nextSong(next);
} else {
watch_input(loop);
}
g_main_loop_run(loop);
gst_element_set_state (pipe, GST_STATE_NULL);
puts("boofff");
gst_object_unref (pipe);
return 0;
}
static void
get_property (GObject *object, guint prop_id,
GValue *value, GParamSpec *pspec)
{
NMAccessPointPrivate *priv = NM_AP_GET_PRIVATE (object);
GArray * ssid;
int len;
int i;
switch (prop_id) {
case PROP_FLAGS:
g_value_set_uint (value, priv->flags);
break;
case PROP_WPA_FLAGS:
g_value_set_uint (value, priv->wpa_flags);
break;
case PROP_RSN_FLAGS:
g_value_set_uint (value, priv->rsn_flags);
break;
case PROP_SSID:
len = priv->ssid ? priv->ssid->len : 0;
ssid = g_array_sized_new (FALSE, TRUE, sizeof (unsigned char), len);
for (i = 0; i < len; i++)
g_array_append_val (ssid, priv->ssid->data[i]);
g_value_set_boxed (value, ssid);
g_array_free (ssid, TRUE);
break;
case PROP_FREQUENCY:
g_value_set_uint (value, priv->freq);
break;
case PROP_HW_ADDRESS:
g_value_set_string (value, priv->address);
break;
case PROP_MODE:
g_value_set_uint (value, priv->mode);
break;
case PROP_MAX_BITRATE:
g_value_set_uint (value, priv->max_bitrate);
break;
case PROP_STRENGTH:
g_value_set_schar (value, priv->strength);
break;
case PROP_LAST_SEEN:
g_value_set_int (value,
priv->last_seen > 0
? (gint) nm_utils_monotonic_timestamp_as_boottime (priv->last_seen, NM_UTILS_NS_PER_SECOND)
: -1);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
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;
}
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");
}
void
_gda_oracle_set_value (GValue *value,
GdaOracleValue *ora_value,
GdaConnection *cnc)
{
GdaTime gtime;
GdaTimestamp timestamp;
sb2 year;
ub1 month;
ub1 day;
ub1 hour;
ub1 min;
ub1 sec;
if (ora_value->indicator == -1) {
gda_value_set_null (value);
return;
}
gda_value_reset_with_type (value, ora_value->g_type);
switch (ora_value->s_type) {
case GDA_STYPE_INT:
g_value_set_int (value, *((gint *) ora_value->value));
break;
case GDA_STYPE_STRING: {
gchar *string_buffer, *tmp;
string_buffer = (gchar *) ora_value->value;
string_buffer [ora_value->rlen] = '\0';
g_strchomp (string_buffer);
//tmp = g_locale_to_utf8 (string_buffer, -1, NULL, NULL, NULL);
//g_value_take_string (value, tmp);
g_value_set_string (value, string_buffer);
if (ora_value->use_callback) {
g_free (string_buffer);
ora_value->value = NULL;
}
break;
}
case GDA_STYPE_BOOLEAN:
g_value_set_boolean (value, (*((gint *) ora_value->value)) ? TRUE: FALSE);
break;
case GDA_STYPE_DATE: {
GDate *date;
OCIDateGetDate ((CONST OCIDate *) ora_value->value,
(sb2 *) &year,
(ub1 *) &month,
(ub1 *) &day);
date = g_date_new_dmy (day, month, year);
g_value_take_boxed (value, date);
break;
}
case GDA_STYPE_TIME: {
OCIDateGetTime ((CONST OCIDate *) ora_value->value,
(ub1 *) &hour,
(ub1 *) &min,
(ub1 *) &sec);
gtime.hour = hour;
gtime.minute = min;
gtime.second = sec;
gda_value_set_time (value, >ime);
break;
}
case GDA_STYPE_TIMESTAMP: {
OCIDateGetDate ((CONST OCIDate *) ora_value->value,
(sb2 *) &year,
(ub1 *) &month,
(ub1 *) &day);
OCIDateGetTime ((CONST OCIDate *) ora_value->value,
(ub1 *) &hour,
(ub1 *) &min,
(ub1 *) &sec);
timestamp.year = year;
timestamp.month = month;
timestamp.day = day;
timestamp.hour = hour;
timestamp.minute = min;
timestamp.second = sec;
timestamp.fraction = 0;
timestamp.timezone = 0;
gda_value_set_timestamp(value, ×tamp);
break;
}
case GDA_STYPE_INT64:
TO_IMPLEMENT; /* test that value fits in */
g_value_set_int64 (value, atoll (ora_value->value));
break;
case GDA_STYPE_UINT64:
TO_IMPLEMENT; /* test that value fits in */
g_value_set_uint64 (value, atoll (ora_value->value));
break;
case GDA_STYPE_UINT:
TO_IMPLEMENT; /* test that value fits in */
g_value_set_uint (value, *((guint*) ora_value->value));
break;
case GDA_STYPE_FLOAT:
g_value_set_float (value, *((gfloat*) ora_value->value));
break;
case GDA_STYPE_DOUBLE:
g_value_set_double (value, *((gdouble*) ora_value->value));
break;
case GDA_STYPE_LONG:
TO_IMPLEMENT;
break;
case GDA_STYPE_ULONG:
TO_IMPLEMENT;
break;
case GDA_STYPE_NUMERIC: {
GdaNumeric *numeric;
gchar *tmp;
g_assert (!ora_value->use_callback);
tmp = g_malloc0 (ora_value->defined_size);
memcpy (tmp, ora_value->value, ora_value->defined_size);
tmp [ora_value->rlen] = '\0';
g_strchomp (tmp);
numeric = gda_numeric_new ();
gda_numeric_set_from_string (numeric, tmp);
g_free (tmp);
gda_numeric_set_precision (numeric, ora_value->precision);
gda_numeric_set_width (numeric, ora_value->scale);
g_value_take_boxed (value, numeric);
break;
}
case GDA_STYPE_BINARY: {
GdaBinary *bin;
bin = g_new0 (GdaBinary, 1);
if (ora_value->use_callback) {
bin->data = ora_value->value;
ora_value->value = NULL;
}
else {
bin->data = g_new (guchar, ora_value->rlen);
memcpy (bin->data, ora_value->value, ora_value->rlen);
}
bin->binary_length = ora_value->rlen;
gda_value_take_binary (value, bin);
break;
}
case GDA_STYPE_BLOB: {
GdaBlob *blob;
GdaBlobOp *op;
OCILobLocator *lobloc;
OracleConnectionData *cdata;
gint result;
/* REM: we need to make a "copy" of the lob locator to give to the GdaOracleblobOp object */
cdata = (OracleConnectionData*) gda_connection_internal_get_provider_data_error (cnc, NULL);
if (!cdata) {
gda_connection_add_event_string (cnc, _("Invalid Oracle handle"));
gda_value_set_null (value);
return;
}
result = OCIDescriptorAlloc ((dvoid *) cdata->henv, (dvoid **) &lobloc,
(ub4) gda_oracle_blob_type (ora_value->sql_type), (size_t) 0, (dvoid **) 0);
if (gda_oracle_check_result (result, cnc, cdata, OCI_HTYPE_ERROR,
_("Could not allocate Lob locator"))) {
gda_value_set_null (value);
return;
}
result = OCILobAssign ((dvoid *) cdata->henv, (dvoid *) cdata->herr, ora_value->value, &lobloc);
if (gda_oracle_check_result (result, cnc, cdata, OCI_HTYPE_ERROR,
_("Could not copy Lob locator"))) {
gda_value_set_null (value);
return;
}
blob = g_new0 (GdaBlob, 1);
op = gda_oracle_blob_op_new (cnc, lobloc);
gda_blob_set_op (blob, op);
g_object_unref (op);
gda_value_take_blob (value, blob);
break;
}
case GDA_STYPE_CHAR: {
TO_IMPLEMENT; /* test that value fits in */
g_value_set_schar (value, *((gint8*) ora_value->value));
break;
}
case GDA_STYPE_SHORT: {
TO_IMPLEMENT; /* test that value fits in */
gda_value_set_short (value, *((gint*) ora_value->value));
break;
}
case GDA_STYPE_GTYPE:
TO_IMPLEMENT;
break;
case GDA_STYPE_GEOMETRIC_POINT:
TO_IMPLEMENT;
break;
case GDA_STYPE_NULL:
gda_value_set_null (value);
break;
default:
g_assert_not_reached ();
}
}
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;
}
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
ada_gvalue_set (GValue* value, void *val)
{
if G_VALUE_HOLDS_CHAR (value)
g_value_set_schar (value, *(gchar*)val);
else if G_VALUE_HOLDS_UCHAR (value)
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;
}
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;
}
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;
}
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;
}
}
static gboolean _parse_atom(IdleParser *parser, GValueArray *arr, char atom, const gchar *token, TpHandleSet *contact_reffed, TpHandleSet *room_reffed) {
IdleParserPrivate *priv = IDLE_PARSER_GET_PRIVATE(parser);
TpHandle handle;
GValue val = {0};
TpHandleRepoIface *contact_repo = tp_base_connection_get_handles(TP_BASE_CONNECTION(priv->conn), TP_HANDLE_TYPE_CONTACT);
TpHandleRepoIface *room_repo = tp_base_connection_get_handles(TP_BASE_CONNECTION(priv->conn), TP_HANDLE_TYPE_ROOM);
if (token[0] == ':')
token++;
IDLE_DEBUG("parsing atom \"%s\" as %c", token, atom);
switch (atom) {
case 'I':
IDLE_DEBUG("ignored token");
return TRUE;
break;
case 'c':
case 'r':
case 'C': {
gchar *id, *bang = NULL;
gchar modechar = '\0';
if (idle_muc_channel_is_modechar(token[0])) {
modechar = token[0];
token++;
}
id = g_strdup(token);
if (atom != 'r') {
bang = strchr(id, '!');
if (bang)
*bang = '\0';
}
if (atom == 'r') {
if ((handle = tp_handle_ensure(room_repo, id, NULL, NULL))) {
tp_handle_set_add(room_reffed, handle);
}
} else {
if ((handle = tp_handle_ensure(contact_repo, id, NULL, NULL))) {
tp_handle_set_add(contact_reffed, handle);
idle_connection_canon_nick_receive(priv->conn, handle, id);
}
}
g_free(id);
if (!handle)
return FALSE;
g_value_init(&val, G_TYPE_UINT);
g_value_set_uint(&val, handle);
g_value_array_append(arr, &val);
g_value_unset(&val);
IDLE_DEBUG("set handle %u", handle);
if (atom == 'C') {
g_value_init(&val, G_TYPE_CHAR);
g_value_set_schar(&val, modechar);
g_value_array_append(arr, &val);
g_value_unset(&val);
IDLE_DEBUG("set modechar %c", modechar);
}
return TRUE;
}
break;
case 'd': {
guint dval;
if (sscanf(token, "%d", &dval)) {
g_value_init(&val, G_TYPE_UINT);
g_value_set_uint(&val, dval);
g_value_array_append(arr, &val);
g_value_unset(&val);
IDLE_DEBUG("set int %d", dval);
return TRUE;
} else {
return FALSE;
}
}
break;
case 's':
g_value_init(&val, G_TYPE_STRING);
g_value_set_string(&val, token);
g_value_array_append(arr, &val);
g_value_unset(&val);
IDLE_DEBUG("set string \"%s\"", token);
return TRUE;
break;
default:
IDLE_DEBUG("unknown atom %c", atom);
return FALSE;
break;
}
}
static HaskellObj
#ifdef GHC_RTS_USES_CAPABILITY
gtk2hs_value_as_haskellobj(Capability *cap, const GValue *value) {
#else
gtk2hs_value_as_haskellobj(const GValue *value) {
#endif
switch (G_TYPE_FUNDAMENTAL(G_VALUE_TYPE(value))) {
case G_TYPE_INTERFACE:
if (g_type_is_a(G_VALUE_TYPE(value), G_TYPE_OBJECT))
return rts_mkPtr(CAP g_value_get_object(value));
else
break;
case G_TYPE_CHAR:
return rts_mkChar(CAP g_value_get_schar(value));
case G_TYPE_UCHAR:
return rts_mkChar(CAP g_value_get_uchar(value));
case G_TYPE_BOOLEAN:
return rts_mkBool(CAP g_value_get_boolean(value));
case G_TYPE_INT:
return rts_mkInt(CAP g_value_get_int(value));
case G_TYPE_UINT:
return rts_mkWord(CAP g_value_get_uint(value));
case G_TYPE_LONG:
return rts_mkInt(CAP g_value_get_long(value));
case G_TYPE_ULONG:
return rts_mkWord(CAP g_value_get_ulong(value));
/* case G_TYPE_INT64:
return rts_mkInt64(CAP g_value_get_int64(value));
case G_TYPE_UINT64:
return rts_mkWord64(CAP g_value_get_uint64(value)); */
case G_TYPE_ENUM:
return rts_mkInt(CAP g_value_get_enum(value));
case G_TYPE_FLAGS:
return rts_mkWord(CAP g_value_get_enum(value));
case G_TYPE_FLOAT:
return rts_mkFloat(CAP g_value_get_float(value));
case G_TYPE_DOUBLE:
return rts_mkDouble(CAP g_value_get_double(value));
case G_TYPE_STRING:
return rts_mkPtr(CAP (char *)g_value_get_string(value)); /* CHECKME: is the string freed? */
case G_TYPE_POINTER:
return rts_mkPtr(CAP g_value_get_pointer(value));
case G_TYPE_BOXED:
return rts_mkPtr(CAP g_value_get_boxed(value));
case G_TYPE_PARAM:
return rts_mkPtr(CAP g_value_get_param(value));
case G_TYPE_OBJECT:
return rts_mkPtr(CAP g_value_get_object(value));
}
g_error("gtk2hs_value_as_haskellobj: unable to handle GValue with type %s\n"
"please report this as a bug to [email protected]",
g_type_name(G_VALUE_TYPE(value)));
}
void
gtk2hs_value_from_haskellobj(GValue *value, HaskellObj obj) {
switch (G_TYPE_FUNDAMENTAL(G_VALUE_TYPE(value))) {
case G_TYPE_INVALID:
case G_TYPE_NONE:
return;
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)) {
g_value_set_object(value, rts_getPtr(obj));
} else {
break;
}
return;
case G_TYPE_CHAR:
g_value_set_schar(value, rts_getChar(obj));
return;
case G_TYPE_UCHAR:
g_value_set_schar(value, rts_getChar(obj));
return;
case G_TYPE_BOOLEAN:
g_value_set_boolean(value, rts_getBool(obj));
return;
case G_TYPE_INT:
g_value_set_int(value, rts_getInt(obj));
return;
case G_TYPE_UINT:
g_value_set_uint(value, rts_getWord(obj));
return;
case G_TYPE_LONG:
g_value_set_long(value, rts_getInt(obj));
return;
case G_TYPE_ULONG:
g_value_set_ulong(value, rts_getWord(obj));
return;
/* case G_TYPE_INT64:
g_value_set_int64(value, rts_getInt64(obj));
return;
case G_TYPE_UINT64:
g_value_set_uint64(value, rts_getWord64(obj));
return; */
case G_TYPE_ENUM:
g_value_set_enum(value, rts_getInt(obj));
return;
case G_TYPE_FLAGS:
g_value_set_flags(value, rts_getInt(obj));
return;
case G_TYPE_FLOAT:
g_value_set_float(value, rts_getFloat(obj));
return;
case G_TYPE_DOUBLE:
g_value_set_double(value, rts_getDouble(obj));
return;
case G_TYPE_STRING:
g_value_set_string(value, rts_getPtr(obj));
return;
case G_TYPE_POINTER:
g_value_set_pointer(value, rts_getPtr(obj));
return;
/* case G_TYPE_BOXED: {
g_value_set_boxed(value, obj);
break;
}
case G_TYPE_PARAM:
g_value_set_param(value, (obj));
break; */
case G_TYPE_OBJECT:
g_value_set_object(value, rts_getPtr(obj));
return;
}
g_error("gtk2hs_value_from_haskellobj: unable to handle GValue with type %s\n"
"please report this as a bug to [email protected]",
g_type_name(G_VALUE_TYPE(value)));
}
static void
get_g_value_from_java_number (JNIEnv *jniEnv, jobject jnumber, GValue *value)
{
jclass classByte = (*jniEnv)->FindClass(jniEnv, "java/lang/Byte");
jclass classDouble = (*jniEnv)->FindClass(jniEnv, "java/lang/Double");
jclass classFloat = (*jniEnv)->FindClass(jniEnv, "java/lang/Float");
jclass classInteger = (*jniEnv)->FindClass(jniEnv, "java/lang/Integer");
jclass classLong = (*jniEnv)->FindClass(jniEnv, "java/lang/Long");
jclass classShort = (*jniEnv)->FindClass(jniEnv, "java/lang/Short");
jmethodID jmid;
if ((*jniEnv)->IsInstanceOf(jniEnv, jnumber, classByte))
{
jmid = (*jniEnv)->GetMethodID(jniEnv, classByte, "byteValue", "()B");
g_value_init(value, G_TYPE_CHAR);
g_value_set_schar(value,
(gchar)(*jniEnv)->CallByteMethod(jniEnv, jnumber, jmid));
return;
}
if ((*jniEnv)->IsInstanceOf(jniEnv, jnumber, classDouble))
{
jmid = (*jniEnv)->GetMethodID(jniEnv, classDouble, "doubleValue", "()D");
g_value_init(value, G_TYPE_DOUBLE);
g_value_set_double(value,
(gdouble)(*jniEnv)->CallDoubleMethod(jniEnv, jnumber, jmid));
return;
}
if ((*jniEnv)->IsInstanceOf(jniEnv, jnumber, classFloat))
{
jmid = (*jniEnv)->GetMethodID(jniEnv, classFloat, "floatValue", "()F");
g_value_init(value, G_TYPE_FLOAT);
g_value_set_float(value,
(gfloat)(*jniEnv)->CallFloatMethod(jniEnv, jnumber, jmid));
return;
}
if ((*jniEnv)->IsInstanceOf(jniEnv, jnumber, classInteger)
|| (*jniEnv)->IsInstanceOf(jniEnv, jnumber, classShort))
{
jmid = (*jniEnv)->GetMethodID(jniEnv, classInteger, "intValue", "()I");
g_value_init(value, G_TYPE_INT);
g_value_set_int(value,
(gint)(*jniEnv)->CallIntMethod(jniEnv, jnumber, jmid));
return;
}
if ((*jniEnv)->IsInstanceOf(jniEnv, jnumber, classLong)) {
jmid = (*jniEnv)->GetMethodID(jniEnv, classLong, "longValue", "()J");
g_value_init(value, G_TYPE_INT64);
g_value_set_int64(value,
(gint64)(*jniEnv)->CallLongMethod(jniEnv, jnumber, jmid));
return;
}
}