static void gst_sdp_demux_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec) { GstSDPDemux *demux; demux = GST_SDP_DEMUX (object); switch (prop_id) { case PROP_DEBUG: g_value_set_boolean (value, demux->debug); break; case PROP_TIMEOUT: g_value_set_uint64 (value, demux->udp_timeout); break; case PROP_LATENCY: g_value_set_uint (value, demux->latency); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static void parasite_property_cell_renderer_stop_editing(GtkCellEditable *editable, GtkCellRenderer *renderer) { GObject *object; const char *name; GValue gvalue = {0}; GParamSpec *prop; object = g_object_get_data(G_OBJECT(editable), "_prop_object"); name = g_object_get_data(G_OBJECT(editable), "_prop_name"); prop = g_object_class_find_property(G_OBJECT_GET_CLASS(object), name); g_value_init(&gvalue, prop->value_type); if (GTK_IS_ENTRY(editable)) { gboolean canceled = GTK_ENTRY(editable)->editing_canceled; gtk_cell_renderer_stop_editing(renderer, canceled); if (canceled) return; if (GTK_IS_SPIN_BUTTON(editable)) { double value = g_ascii_strtod(gtk_entry_get_text(GTK_ENTRY(editable)), NULL); if (G_IS_PARAM_SPEC_INT(prop)) g_value_set_int(&gvalue, (gint)value); else if G_IS_PARAM_SPEC_UINT(prop) g_value_set_uint(&gvalue, (guint)value); else if G_IS_PARAM_SPEC_INT64(prop) g_value_set_int64(&gvalue, (gint64)value); else if G_IS_PARAM_SPEC_UINT64(prop) g_value_set_uint64(&gvalue, (guint64)value); else if G_IS_PARAM_SPEC_LONG(prop)
static void gst_fragment_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) { GstFragment *fragment = GST_FRAGMENT (object); switch (property_id) { case PROP_INDEX: g_value_set_uint (value, fragment->index); break; case PROP_NAME: g_value_set_string (value, fragment->name); break; case PROP_DURATION: g_value_set_uint64 (value, fragment->stop_time - fragment->start_time); break; case PROP_DISCONTINOUS: g_value_set_boolean (value, fragment->discontinuous); break; case PROP_BUFFER: g_value_take_boxed (value, gst_fragment_get_buffer (fragment)); break; case PROP_CAPS: g_value_take_boxed (value, gst_fragment_get_caps (fragment)); break; default: /* We don't have any other property... */ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); break; } }
/** * zif_changeset_get_property: **/ static void zif_changeset_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) { ZifChangeset *changeset = ZIF_CHANGESET (object); ZifChangesetPrivate *priv = changeset->priv; switch (prop_id) { case PROP_DATE: g_value_set_uint64 (value, priv->date); break; case PROP_AUTHOR: g_value_set_string (value, priv->author); break; case PROP_DESCRIPTION: g_value_set_string (value, priv->description); break; case PROP_VERSION: g_value_set_string (value, priv->version); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static void _gst_controller_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) { GstController *self = GST_CONTROLLER (object); switch (property_id) { case PROP_CONTROL_RATE:{ /* FIXME: don't change if element is playing, controller works for GObject so this wont work GstState c_state, p_state; GstStateChangeReturn ret; ret = gst_element_get_state (self->object, &c_state, &p_state, 0); if ((ret == GST_STATE_CHANGE_SUCCESS && (c_state == GST_STATE_NULL || c_state == GST_STATE_READY)) || (ret == GST_STATE_CHANGE_ASYNC && (p_state == GST_STATE_NULL || p_state == GST_STATE_READY))) { */ g_value_set_uint64 (value, self->priv->control_rate); /* } else { GST_WARNING ("Changing the control rate is only allowed if the elemnt" " is in NULL or READY"); } */ } break; default:{ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); } break; } }
static void gst_dv1394src_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec) { GstDV1394Src *filter = GST_DV1394SRC (object); switch (prop_id) { case PROP_PORT: g_value_set_int (value, filter->port); break; case PROP_CHANNEL: g_value_set_int (value, filter->channel); break; case PROP_SKIP: g_value_set_int (value, filter->skip); break; case PROP_CONSECUTIVE: g_value_set_int (value, filter->consecutive); break; case PROP_DROP_INCOMPLETE: g_value_set_boolean (value, filter->drop_incomplete); break; case PROP_USE_AVC: g_value_set_boolean (value, filter->use_avc); break; case PROP_GUID: g_value_set_uint64 (value, filter->guid); break; case PROP_DEVICE_NAME: g_value_set_string (value, filter->device_name); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static void audio_trim_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec) { AudioTrim *filter = AUDIO_TRIM (object); switch (prop_id) { case PROP_START_THRESHOLD: g_value_set_uint (value, filter->start_threshold); break; case PROP_END_THRESHOLD: g_value_set_uint (value, filter->end_threshold); break; case PROP_START_SKIP: g_value_set_uint64 (value, filter->start_skip); break; case PROP_END_SKIP: g_value_set_uint64 (value, filter->end_skip); break; case PROP_PRE_SILENCE: g_value_set_uint64 (value, filter->pre_silence); break; case PROP_POST_SILENCE: g_value_set_uint64 (value, filter->post_silence); break; case PROP_MAX_SILENCE: g_value_set_uint64 (value, filter->max_silence_duration); break; case PROP_SOUND_DURATION: g_value_set_uint64 (value, filter->sound_duration); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static gboolean gst_lfo_control_source_bind (GstControlSource * source, GParamSpec * pspec) { GType type, base; GstLFOControlSource *self = GST_LFO_CONTROL_SOURCE (source); gboolean ret = TRUE; /* get the fundamental base type */ self->priv->type = base = type = G_PARAM_SPEC_VALUE_TYPE (pspec); while ((type = g_type_parent (type))) base = type; self->priv->base = base; /* restore type */ type = self->priv->type; switch (base) { case G_TYPE_INT:{ GParamSpecInt *tpspec = G_PARAM_SPEC_INT (pspec); g_value_init (&self->priv->minimum_value, type); g_value_set_int (&self->priv->minimum_value, tpspec->minimum); g_value_init (&self->priv->maximum_value, type); g_value_set_int (&self->priv->maximum_value, tpspec->maximum); if (!G_IS_VALUE (&self->priv->amplitude)) { g_value_init (&self->priv->amplitude, type); g_value_set_int (&self->priv->amplitude, 0); } if (!G_IS_VALUE (&self->priv->offset)) { g_value_init (&self->priv->offset, type); g_value_set_int (&self->priv->offset, tpspec->default_value); } break; } case G_TYPE_UINT:{ GParamSpecUInt *tpspec = G_PARAM_SPEC_UINT (pspec); g_value_init (&self->priv->minimum_value, type); g_value_set_uint (&self->priv->minimum_value, tpspec->minimum); g_value_init (&self->priv->maximum_value, type); g_value_set_uint (&self->priv->maximum_value, tpspec->maximum); if (!G_IS_VALUE (&self->priv->amplitude)) { g_value_init (&self->priv->amplitude, type); g_value_set_uint (&self->priv->amplitude, 0); } if (!G_IS_VALUE (&self->priv->offset)) { g_value_init (&self->priv->offset, type); g_value_set_uint (&self->priv->offset, tpspec->default_value); } break; } case G_TYPE_LONG:{ GParamSpecLong *tpspec = G_PARAM_SPEC_LONG (pspec); g_value_init (&self->priv->minimum_value, type); g_value_set_long (&self->priv->minimum_value, tpspec->minimum); g_value_init (&self->priv->maximum_value, type); g_value_set_long (&self->priv->maximum_value, tpspec->maximum); if (!G_IS_VALUE (&self->priv->amplitude)) { g_value_init (&self->priv->amplitude, type); g_value_set_long (&self->priv->amplitude, 0); } if (!G_IS_VALUE (&self->priv->offset)) { g_value_init (&self->priv->offset, type); g_value_set_long (&self->priv->offset, tpspec->default_value); } break; } case G_TYPE_ULONG:{ GParamSpecULong *tpspec = G_PARAM_SPEC_ULONG (pspec); g_value_init (&self->priv->minimum_value, type); g_value_set_ulong (&self->priv->minimum_value, tpspec->minimum); g_value_init (&self->priv->maximum_value, type); g_value_set_ulong (&self->priv->maximum_value, tpspec->maximum); if (!G_IS_VALUE (&self->priv->amplitude)) { g_value_init (&self->priv->amplitude, type); g_value_set_ulong (&self->priv->amplitude, 0); } if (!G_IS_VALUE (&self->priv->offset)) { g_value_init (&self->priv->offset, type); g_value_set_ulong (&self->priv->offset, tpspec->default_value); } break; } case G_TYPE_INT64:{ GParamSpecInt64 *tpspec = G_PARAM_SPEC_INT64 (pspec); g_value_init (&self->priv->minimum_value, type); g_value_set_int64 (&self->priv->minimum_value, tpspec->minimum); g_value_init (&self->priv->maximum_value, type); g_value_set_int64 (&self->priv->maximum_value, tpspec->maximum); if (!G_IS_VALUE (&self->priv->amplitude)) { g_value_init (&self->priv->amplitude, type); g_value_set_int64 (&self->priv->amplitude, 0); } if (!G_IS_VALUE (&self->priv->offset)) { g_value_init (&self->priv->offset, type); g_value_set_int64 (&self->priv->offset, tpspec->default_value); } break; } case G_TYPE_UINT64:{ GParamSpecUInt64 *tpspec = G_PARAM_SPEC_UINT64 (pspec); g_value_init (&self->priv->minimum_value, type); g_value_set_uint64 (&self->priv->minimum_value, tpspec->minimum); g_value_init (&self->priv->maximum_value, type); g_value_set_uint64 (&self->priv->maximum_value, tpspec->maximum); if (!G_IS_VALUE (&self->priv->amplitude)) { g_value_init (&self->priv->amplitude, type); g_value_set_uint64 (&self->priv->amplitude, 0); } if (!G_IS_VALUE (&self->priv->offset)) { g_value_init (&self->priv->offset, type); g_value_set_uint64 (&self->priv->offset, tpspec->default_value); } break; } case G_TYPE_FLOAT:{ GParamSpecFloat *tpspec = G_PARAM_SPEC_FLOAT (pspec); g_value_init (&self->priv->minimum_value, type); g_value_set_float (&self->priv->minimum_value, tpspec->minimum); g_value_init (&self->priv->maximum_value, type); g_value_set_float (&self->priv->maximum_value, tpspec->maximum); if (!G_IS_VALUE (&self->priv->amplitude)) { g_value_init (&self->priv->amplitude, type); g_value_set_float (&self->priv->amplitude, 0.0); } if (!G_IS_VALUE (&self->priv->offset)) { g_value_init (&self->priv->offset, type); g_value_set_float (&self->priv->offset, tpspec->default_value); } break; } case G_TYPE_DOUBLE:{ GParamSpecDouble *tpspec = G_PARAM_SPEC_DOUBLE (pspec); g_value_init (&self->priv->minimum_value, type); g_value_set_double (&self->priv->minimum_value, tpspec->minimum); g_value_init (&self->priv->maximum_value, type); g_value_set_double (&self->priv->maximum_value, tpspec->maximum); if (!G_IS_VALUE (&self->priv->amplitude)) { g_value_init (&self->priv->amplitude, type); g_value_set_float (&self->priv->amplitude, 0.0); } if (!G_IS_VALUE (&self->priv->offset)) { g_value_init (&self->priv->offset, type); g_value_set_float (&self->priv->offset, tpspec->default_value); } break; } default: GST_WARNING ("incomplete implementation for paramspec type '%s'", G_PARAM_SPEC_TYPE_NAME (pspec)); ret = FALSE; break; } if (ret) { GValue amp = { 0, } , off = { 0,}; /* This should never fail unless the user already set amplitude or offset * with an incompatible type before _bind () */ if (!g_value_type_transformable (G_VALUE_TYPE (&self->priv->amplitude), base) || !g_value_type_transformable (G_VALUE_TYPE (&self->priv->offset), base)) { GST_WARNING ("incompatible types for amplitude or offset"); gst_lfo_control_source_reset (self); return FALSE; } /* Generate copies and transform to the correct type */ g_value_init (&, base); g_value_transform (&self->priv->amplitude, &); g_value_init (&off, base); g_value_transform (&self->priv->offset, &off); ret = gst_lfo_control_source_set_waveform (self, self->priv->waveform); g_value_unset (&self->priv->amplitude); g_value_init (&self->priv->amplitude, self->priv->base); g_value_transform (&, &self->priv->amplitude); g_value_unset (&self->priv->offset); g_value_init (&self->priv->offset, self->priv->base); g_value_transform (&off, &self->priv->offset); g_value_unset (&); g_value_unset (&off); } if (!ret) gst_lfo_control_source_reset (self); return ret; }
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 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 void gst_app_src_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec) { GstAppSrc *appsrc = GST_APP_SRC_CAST (object); GstAppSrcPrivate *priv = appsrc->priv; switch (prop_id) { case PROP_CAPS: { GstCaps *caps; /* we're missing a _take_caps() function to transfer ownership */ caps = gst_app_src_get_caps (appsrc); gst_value_set_caps (value, caps); if (caps) gst_caps_unref (caps); break; } case PROP_SIZE: g_value_set_int64 (value, gst_app_src_get_size (appsrc)); break; case PROP_STREAM_TYPE: g_value_set_enum (value, gst_app_src_get_stream_type (appsrc)); break; case PROP_MAX_BYTES: g_value_set_uint64 (value, gst_app_src_get_max_bytes (appsrc)); break; case PROP_FORMAT: g_value_set_enum (value, priv->format); break; case PROP_BLOCK: g_value_set_boolean (value, priv->block); break; case PROP_IS_LIVE: g_value_set_boolean (value, gst_base_src_is_live (GST_BASE_SRC (appsrc))); break; case PROP_MIN_LATENCY: { guint64 min; gst_app_src_get_latency (appsrc, &min, NULL); g_value_set_int64 (value, min); break; } case PROP_MAX_LATENCY: { guint64 max; gst_app_src_get_latency (appsrc, &max, NULL); g_value_set_int64 (value, max); break; } case PROP_EMIT_SIGNALS: g_value_set_boolean (value, gst_app_src_get_emit_signals (appsrc)); break; case PROP_MIN_PERCENT: g_value_set_uint (value, priv->min_percent); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
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); } }
void ags_panel_input_line_map_recall(AgsLine *line, guint output_pad_start) { AgsPanel *panel; AgsPanelInputLine *panel_input_line; AgsAudio *audio; AgsChannel *source; AgsChannel *current; AgsPlayChannel *play_channel; AgsPlayChannelRunMaster *play_channel_run; GList *list; if((AGS_LINE_MAPPED_RECALL & (line->flags)) != 0 || (AGS_LINE_PREMAPPED_RECALL & (line->flags)) != 0){ return; } panel_input_line = AGS_PANEL_INPUT_LINE(line); audio = AGS_AUDIO(line->channel->audio); panel = AGS_PANEL(audio->machine_widget); source = line->channel; /* ags-play */ ags_recall_factory_create(audio, NULL, NULL, "ags-play-master\0", source->audio_channel, source->audio_channel + 1, source->pad, source->pad + 1, (AGS_RECALL_FACTORY_INPUT, AGS_RECALL_FACTORY_PLAY | AGS_RECALL_FACTORY_ADD), 0); /* set audio channel */ list = source->play; while((list = ags_recall_template_find_type(list, AGS_TYPE_PLAY_CHANNEL)) != NULL){ GValue audio_channel_value = {0,}; play_channel = AGS_PLAY_CHANNEL(list->data); g_value_init(&audio_channel_value, G_TYPE_UINT64); g_value_set_uint64(&audio_channel_value, source->audio_channel); ags_port_safe_write(play_channel->audio_channel, &audio_channel_value); list = list->next; } /* call parent */ AGS_LINE_CLASS(ags_panel_input_line_parent_class)->map_recall(line, output_pad_start); }
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; }
/** * 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; }
static void gimp_core_config_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec) { GimpCoreConfig *core_config = GIMP_CORE_CONFIG (object); switch (property_id) { case PROP_LANGUAGE: g_value_set_string (value, core_config->language); break; case PROP_INTERPOLATION_TYPE: g_value_set_enum (value, core_config->interpolation_type); break; case PROP_DEFAULT_THRESHOLD: g_value_set_int (value, core_config->default_threshold); break; case PROP_PLUG_IN_PATH: g_value_set_string (value, core_config->plug_in_path); break; case PROP_MODULE_PATH: g_value_set_string (value, core_config->module_path); break; case PROP_INTERPRETER_PATH: g_value_set_string (value, core_config->interpreter_path); break; case PROP_ENVIRON_PATH: g_value_set_string (value, core_config->environ_path); break; case PROP_BRUSH_PATH: g_value_set_string (value, core_config->brush_path); break; case PROP_BRUSH_PATH_WRITABLE: g_value_set_string (value, core_config->brush_path_writable); break; case PROP_DYNAMICS_PATH: g_value_set_string (value, core_config->dynamics_path); break; case PROP_DYNAMICS_PATH_WRITABLE: g_value_set_string (value, core_config->dynamics_path_writable); break; case PROP_MYPAINT_BRUSH_PATH: g_value_set_string (value, core_config->mypaint_brush_path); break; case PROP_MYPAINT_BRUSH_PATH_WRITABLE: g_value_set_string (value, core_config->mypaint_brush_path_writable); break; case PROP_PATTERN_PATH: g_value_set_string (value, core_config->pattern_path); break; case PROP_PATTERN_PATH_WRITABLE: g_value_set_string (value, core_config->pattern_path_writable); break; case PROP_PALETTE_PATH: g_value_set_string (value, core_config->palette_path); break; case PROP_PALETTE_PATH_WRITABLE: g_value_set_string (value, core_config->palette_path_writable); break; case PROP_GRADIENT_PATH: g_value_set_string (value, core_config->gradient_path); break; case PROP_GRADIENT_PATH_WRITABLE: g_value_set_string (value, core_config->gradient_path_writable); break; case PROP_TOOL_PRESET_PATH: g_value_set_string (value, core_config->tool_preset_path); break; case PROP_TOOL_PRESET_PATH_WRITABLE: g_value_set_string (value, core_config->tool_preset_path_writable); break; case PROP_FONT_PATH: g_value_set_string (value, core_config->font_path); break; case PROP_FONT_PATH_WRITABLE: g_value_set_string (value, core_config->font_path_writable); break; case PROP_DEFAULT_BRUSH: g_value_set_string (value, core_config->default_brush); break; case PROP_DEFAULT_DYNAMICS: g_value_set_string (value, core_config->default_dynamics); break; case PROP_DEFAULT_MYPAINT_BRUSH: g_value_set_string (value, core_config->default_mypaint_brush); break; case PROP_DEFAULT_PATTERN: g_value_set_string (value, core_config->default_pattern); break; case PROP_DEFAULT_PALETTE: g_value_set_string (value, core_config->default_palette); break; case PROP_DEFAULT_GRADIENT: g_value_set_string (value, core_config->default_gradient); break; case PROP_DEFAULT_TOOL_PRESET: g_value_set_string (value, core_config->default_tool_preset); break; case PROP_DEFAULT_FONT: g_value_set_string (value, core_config->default_font); break; case PROP_GLOBAL_BRUSH: g_value_set_boolean (value, core_config->global_brush); break; case PROP_GLOBAL_DYNAMICS: g_value_set_boolean (value, core_config->global_dynamics); break; case PROP_GLOBAL_PATTERN: g_value_set_boolean (value, core_config->global_pattern); break; case PROP_GLOBAL_PALETTE: g_value_set_boolean (value, core_config->global_palette); break; case PROP_GLOBAL_GRADIENT: g_value_set_boolean (value, core_config->global_gradient); break; case PROP_GLOBAL_FONT: g_value_set_boolean (value, core_config->global_font); break; case PROP_DEFAULT_IMAGE: g_value_set_object (value, core_config->default_image); break; case PROP_DEFAULT_GRID: g_value_set_object (value, core_config->default_grid); break; case PROP_FILTER_HISTORY_SIZE: g_value_set_int (value, core_config->filter_history_size); break; case PROP_UNDO_LEVELS: g_value_set_int (value, core_config->levels_of_undo); break; case PROP_UNDO_SIZE: g_value_set_uint64 (value, core_config->undo_size); break; case PROP_UNDO_PREVIEW_SIZE: g_value_set_enum (value, core_config->undo_preview_size); break; case PROP_PLUGINRC_PATH: g_value_set_string (value, core_config->plug_in_rc_path); break; case PROP_LAYER_PREVIEWS: g_value_set_boolean (value, core_config->layer_previews); break; case PROP_GROUP_LAYER_PREVIEWS: g_value_set_boolean (value, core_config->group_layer_previews); break; case PROP_LAYER_PREVIEW_SIZE: g_value_set_enum (value, core_config->layer_preview_size); break; case PROP_THUMBNAIL_SIZE: g_value_set_enum (value, core_config->thumbnail_size); break; case PROP_THUMBNAIL_FILESIZE_LIMIT: g_value_set_uint64 (value, core_config->thumbnail_filesize_limit); break; case PROP_COLOR_MANAGEMENT: g_value_set_object (value, core_config->color_management); break; case PROP_SAVE_DOCUMENT_HISTORY: g_value_set_boolean (value, core_config->save_document_history); break; case PROP_QUICK_MASK_COLOR: gimp_value_set_rgb (value, &core_config->quick_mask_color); break; case PROP_IMPORT_PROMOTE_FLOAT: g_value_set_boolean (value, core_config->import_promote_float); break; case PROP_IMPORT_PROMOTE_DITHER: g_value_set_boolean (value, core_config->import_promote_dither); break; case PROP_IMPORT_ADD_ALPHA: g_value_set_boolean (value, core_config->import_add_alpha); break; case PROP_IMPORT_RAW_PLUG_IN: g_value_set_string (value, core_config->import_raw_plug_in); break; case PROP_EXPORT_FILE_TYPE: g_value_set_enum (value, core_config->export_file_type); break; case PROP_EXPORT_COLOR_PROFILE: g_value_set_boolean (value, core_config->export_color_profile); break; case PROP_EXPORT_METADATA_EXIF: g_value_set_boolean (value, core_config->export_metadata_exif); break; case PROP_EXPORT_METADATA_XMP: g_value_set_boolean (value, core_config->export_metadata_xmp); break; case PROP_EXPORT_METADATA_IPTC: g_value_set_boolean (value, core_config->export_metadata_iptc); break; case PROP_DEBUG_POLICY: g_value_set_enum (value, core_config->debug_policy); break; case PROP_INSTALL_COLORMAP: case PROP_MIN_COLORS: /* ignored */ break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); break; } }
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 (); } }
static void gst_multiudpsink_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec) { GstMultiUDPSink *udpsink; udpsink = GST_MULTIUDPSINK (object); switch (prop_id) { case PROP_BYTES_TO_SERVE: g_value_set_uint64 (value, udpsink->bytes_to_serve); break; case PROP_BYTES_SERVED: g_value_set_uint64 (value, udpsink->bytes_served); break; case PROP_SOCKET: g_value_set_object (value, udpsink->socket); break; case PROP_SOCKET_V6: g_value_set_object (value, udpsink->socket_v6); break; case PROP_CLOSE_SOCKET: g_value_set_boolean (value, udpsink->close_socket); break; case PROP_USED_SOCKET: g_value_set_object (value, udpsink->used_socket); break; case PROP_USED_SOCKET_V6: g_value_set_object (value, udpsink->used_socket_v6); break; case PROP_CLIENTS: g_value_take_string (value, gst_multiudpsink_get_clients_string (udpsink)); break; case PROP_AUTO_MULTICAST: g_value_set_boolean (value, udpsink->auto_multicast); break; case PROP_MULTICAST_IFACE: g_value_set_string (value, udpsink->multi_iface); break; case PROP_TTL: g_value_set_int (value, udpsink->ttl); break; case PROP_TTL_MC: g_value_set_int (value, udpsink->ttl_mc); break; case PROP_LOOP: g_value_set_boolean (value, udpsink->loop); break; case PROP_FORCE_IPV4: g_value_set_boolean (value, udpsink->force_ipv4); break; case PROP_QOS_DSCP: g_value_set_int (value, udpsink->qos_dscp); break; case PROP_SEND_DUPLICATES: g_value_set_boolean (value, udpsink->send_duplicates); break; case PROP_BUFFER_SIZE: g_value_set_int (value, udpsink->buffer_size); break; case PROP_BIND_ADDRESS: g_value_set_string (value, udpsink->bind_address); break; case PROP_BIND_PORT: g_value_set_int (value, udpsink->bind_port); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static void gimp_gui_config_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec) { GimpGuiConfig *gui_config = GIMP_GUI_CONFIG (object); switch (property_id) { case PROP_MOVE_TOOL_CHANGES_ACTIVE: g_value_set_boolean (value, gui_config->move_tool_changes_active); break; case PROP_IMAGE_MAP_TOOL_MAX_RECENT: g_value_set_int (value, gui_config->image_map_tool_max_recent); break; case PROP_TRUST_DIRTY_FLAG: g_value_set_boolean (value, gui_config->trust_dirty_flag); break; case PROP_SAVE_DEVICE_STATUS: g_value_set_boolean (value, gui_config->save_device_status); break; case PROP_SAVE_SESSION_INFO: g_value_set_boolean (value, gui_config->save_session_info); break; case PROP_RESTORE_SESSION: g_value_set_boolean (value, gui_config->restore_session); break; case PROP_RESTORE_MONITOR: g_value_set_boolean (value, gui_config->restore_monitor); break; case PROP_SAVE_TOOL_OPTIONS: g_value_set_boolean (value, gui_config->save_tool_options); break; case PROP_SHOW_TOOLTIPS: g_value_set_boolean (value, gui_config->show_tooltips); break; case PROP_TEAROFF_MENUS: g_value_set_boolean (value, gui_config->tearoff_menus); break; case PROP_CAN_CHANGE_ACCELS: g_value_set_boolean (value, gui_config->can_change_accels); break; case PROP_SAVE_ACCELS: g_value_set_boolean (value, gui_config->save_accels); break; case PROP_RESTORE_ACCELS: g_value_set_boolean (value, gui_config->restore_accels); break; case PROP_LAST_OPENED_SIZE: g_value_set_int (value, gui_config->last_opened_size); break; case PROP_MAX_NEW_IMAGE_SIZE: g_value_set_uint64 (value, gui_config->max_new_image_size); break; case PROP_TOOLBOX_COLOR_AREA: g_value_set_boolean (value, gui_config->toolbox_color_area); break; case PROP_TOOLBOX_FOO_AREA: g_value_set_boolean (value, gui_config->toolbox_foo_area); break; case PROP_TOOLBOX_IMAGE_AREA: g_value_set_boolean (value, gui_config->toolbox_image_area); break; case PROP_TOOLBOX_WILBER: g_value_set_boolean (value, gui_config->toolbox_wilber); break; case PROP_THEME_PATH: g_value_set_string (value, gui_config->theme_path); break; case PROP_THEME: g_value_set_string (value, gui_config->theme); break; case PROP_USE_HELP: g_value_set_boolean (value, gui_config->use_help); break; case PROP_SHOW_HELP_BUTTON: g_value_set_boolean (value, gui_config->show_help_button); break; case PROP_HELP_LOCALES: g_value_set_string (value, gui_config->help_locales); break; case PROP_HELP_BROWSER: g_value_set_enum (value, gui_config->help_browser); break; case PROP_SEARCH_SHOW_UNAVAILABLE_ACTIONS: g_value_set_boolean (value, gui_config->search_show_unavailable); break; case PROP_ACTION_HISTORY_SIZE: g_value_set_int (value, gui_config->action_history_size); break; case PROP_USER_MANUAL_ONLINE: g_value_set_boolean (value, gui_config->user_manual_online); break; case PROP_USER_MANUAL_ONLINE_URI: g_value_set_string (value, gui_config->user_manual_online_uri); break; case PROP_DOCK_WINDOW_HINT: g_value_set_enum (value, gui_config->dock_window_hint); break; case PROP_CURSOR_HANDEDNESS: g_value_set_enum (value, gui_config->cursor_handedness); break; case PROP_HIDE_DOCKS: g_value_set_boolean (value, gui_config->hide_docks); break; case PROP_SINGLE_WINDOW_MODE: g_value_set_boolean (value, gui_config->single_window_mode); break; case PROP_TABS_POSITION: g_value_set_enum (value, gui_config->tabs_position); break; case PROP_LAST_TIP_SHOWN: g_value_set_int (value, gui_config->last_tip_shown); break; case PROP_CURSOR_FORMAT: case PROP_INFO_WINDOW_PER_DISPLAY: case PROP_MENU_MNEMONICS: case PROP_SHOW_TOOL_TIPS: case PROP_SHOW_TIPS: case PROP_TOOLBOX_WINDOW_HINT: case PROP_TRANSIENT_DOCKS: case PROP_WEB_BROWSER: /* ignored */ break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); break; } }
void ags_recycling_context_get_property(GObject *gobject, guint prop_id, GValue *value, GParamSpec *param_spec) { AgsRecyclingContext *recycling_context; pthread_mutex_t *recycling_context_mutex; recycling_context = AGS_RECYCLING_CONTEXT(gobject); /* get recycling context mutex */ pthread_mutex_lock(ags_recycling_context_get_class_mutex()); recycling_context_mutex = recycling_context->obj_mutex; pthread_mutex_unlock(ags_recycling_context_get_class_mutex()); switch(prop_id){ case PROP_RECALL_ID: { pthread_mutex_lock(recycling_context_mutex); g_value_set_object(value, recycling_context->recall_id); pthread_mutex_unlock(recycling_context_mutex); } break; case PROP_PARENT: { pthread_mutex_lock(recycling_context_mutex); g_value_set_object(value, recycling_context->parent); pthread_mutex_unlock(recycling_context_mutex); } break; case PROP_CHILD: { pthread_mutex_lock(recycling_context_mutex); g_value_set_pointer(value, g_list_copy_deep(recycling_context->children, (GCopyFunc) g_object_ref, NULL)); pthread_mutex_unlock(recycling_context_mutex); } break; case PROP_LENGTH: { pthread_mutex_lock(recycling_context_mutex); g_value_set_uint64(value, recycling_context->length); pthread_mutex_unlock(recycling_context_mutex); } break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID(gobject, prop_id, param_spec); break; } }
static RhythmDBEntry * add_mtp_track_to_db (RBMtpSource *source, RhythmDB *db, LIBMTP_track_t *track) { RhythmDBEntry *entry = NULL; RhythmDBEntryType *entry_type; RBMtpSourcePrivate *priv = MTP_SOURCE_GET_PRIVATE (source); char *name = NULL; /* ignore everything except audio (allow audio/video types too, since they're probably pretty common) */ if (!(LIBMTP_FILETYPE_IS_AUDIO (track->filetype) || LIBMTP_FILETYPE_IS_AUDIOVIDEO (track->filetype))) { rb_debug ("ignoring non-audio item %d (filetype %s)", track->item_id, LIBMTP_Get_Filetype_Description (track->filetype)); return NULL; } /* Set URI */ g_object_get (G_OBJECT (source), "entry-type", &entry_type, NULL); name = g_strdup_printf ("xrbmtp://%i/%s", track->item_id, track->filename); entry = rhythmdb_entry_new (RHYTHMDB (db), entry_type, name); g_free (name); g_object_unref (entry_type); if (entry == NULL) { rb_debug ("cannot create entry %i", track->item_id); g_object_unref (G_OBJECT (db)); return NULL; } /* Set track number */ if (track->tracknumber != 0) { GValue value = {0, }; g_value_init (&value, G_TYPE_ULONG); g_value_set_ulong (&value, track->tracknumber); rhythmdb_entry_set (RHYTHMDB (db), entry, RHYTHMDB_PROP_TRACK_NUMBER, &value); g_value_unset (&value); } /* Set length */ if (track->duration != 0) { GValue value = {0, }; g_value_init (&value, G_TYPE_ULONG); g_value_set_ulong (&value, track->duration/1000); rhythmdb_entry_set (RHYTHMDB (db), entry, RHYTHMDB_PROP_DURATION, &value); g_value_unset (&value); } /* Set file size */ if (track->filesize != 0) { GValue value = {0, }; g_value_init (&value, G_TYPE_UINT64); g_value_set_uint64 (&value, track->filesize); rhythmdb_entry_set (RHYTHMDB (db), entry, RHYTHMDB_PROP_FILE_SIZE, &value); g_value_unset (&value); } /* Set playcount */ if (track->usecount != 0) { GValue value = {0, }; g_value_init (&value, G_TYPE_ULONG); g_value_set_ulong (&value, track->usecount); rhythmdb_entry_set (RHYTHMDB (db), entry, RHYTHMDB_PROP_PLAY_COUNT, &value); g_value_unset (&value); } /* Set rating */ if (track->rating != 0) { GValue value = {0, }; g_value_init (&value, G_TYPE_DOUBLE); g_value_set_double (&value, track->rating/20); rhythmdb_entry_set (RHYTHMDB (db), entry, RHYTHMDB_PROP_RATING, &value); g_value_unset (&value); } /* Set release date */ if (track->date != NULL && track->date[0] != '\0') { GTimeVal tv; if (g_time_val_from_iso8601 (track->date, &tv)) { GDate d; GValue value = {0, }; g_value_init (&value, G_TYPE_ULONG); g_date_set_time_val (&d, &tv); g_value_set_ulong (&value, g_date_get_julian (&d)); rhythmdb_entry_set (RHYTHMDB (db), entry, RHYTHMDB_PROP_DATE, &value); g_value_unset (&value); } } /* Set title */ entry_set_string_prop (RHYTHMDB (db), entry, RHYTHMDB_PROP_TITLE, track->title); /* Set album, artist and genre from MTP */ entry_set_string_prop (RHYTHMDB (db), entry, RHYTHMDB_PROP_ARTIST, track->artist); entry_set_string_prop (RHYTHMDB (db), entry, RHYTHMDB_PROP_ALBUM, track->album); entry_set_string_prop (RHYTHMDB (db), entry, RHYTHMDB_PROP_GENRE, track->genre); g_hash_table_insert (priv->entry_map, entry, track); rhythmdb_commit (RHYTHMDB (db)); return entry; }
static void simple_daap_record_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) { SimpleDAAPRecord *record = SIMPLE_DAAP_RECORD (object); switch (prop_id) { case PROP_LOCATION: g_value_set_static_string (value, record->priv->location); break; case PROP_TITLE: g_value_set_static_string (value, record->priv->title); break; case PROP_ALBUM: g_value_set_static_string (value, record->priv->album); break; case PROP_SORT_ALBUM: g_value_set_static_string (value, record->priv->sort_album); break; case PROP_ARTIST: g_value_set_static_string (value, record->priv->artist); break; case PROP_SORT_ARTIST: g_value_set_static_string (value, record->priv->sort_artist); break; case PROP_GENRE: g_value_set_static_string (value, record->priv->genre); break; case PROP_FORMAT: g_value_set_static_string (value, record->priv->format); break; case PROP_MEDIAKIND: g_value_set_enum (value, record->priv->mediakind); break; case PROP_RATING: g_value_set_int (value, record->priv->rating); break; case PROP_FILESIZE: g_value_set_uint64 (value, record->priv->filesize); break; case PROP_DURATION: g_value_set_int (value, record->priv->duration); break; case PROP_TRACK: g_value_set_int (value, record->priv->track); break; case PROP_YEAR: g_value_set_int (value, record->priv->year); break; case PROP_FIRSTSEEN: g_value_set_int (value, record->priv->firstseen); break; case PROP_MTIME: g_value_set_int (value, record->priv->mtime); break; case PROP_DISC: g_value_set_int (value, record->priv->disc); break; case PROP_BITRATE: g_value_set_int (value, record->priv->bitrate); break; case PROP_HAS_VIDEO: g_value_set_boolean (value, record->priv->has_video); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
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 matahari_get_property(GObject *object, guint property_id, GValue *value, GParamSpec *pspec) { sigar_proc_stat_t procs; sigar_loadavg_t avg; Dict *dict; GValue value_value = {0, }; switch (property_id) { case PROP_HOST_UUID: g_value_set_string (value, mh_host_get_uuid(NULL)); break; case PROP_HOST_HOSTNAME: g_value_set_string (value, mh_host_get_hostname()); break; case PROP_HOST_OS: g_value_set_string (value, mh_host_get_operating_system()); break; case PROP_HOST_ARCH: g_value_set_string (value, mh_host_get_architecture()); break; case PROP_HOST_WORDSIZE: g_value_set_uint (value, mh_host_get_cpu_wordsize()); break; case PROP_HOST_MEMORY: g_value_set_uint64 (value, mh_host_get_memory()); break; case PROP_HOST_SWAP: g_value_set_uint64 (value, mh_host_get_swap()); break; case PROP_HOST_CPU_COUNT: g_value_set_uint (value, mh_host_get_cpu_count()); break; case PROP_HOST_CPU_CORES: g_value_set_uint (value, mh_host_get_cpu_number_of_cores()); break; case PROP_HOST_CPU_MODEL: g_value_set_string (value, mh_host_get_cpu_model()); break; case PROP_HOST_CPU_FLAGS: g_value_set_string (value, mh_host_get_cpu_flags()); break; case PROP_HOST_UPDATE_INTERVAL: g_value_set_uint (value, priv.update_interval); break; case PROP_HOST_LAST_UPDATED: // Not used in DBus module break; case PROP_HOST_SEQUENCE: // Not used in DBus module break; case PROP_HOST_FREE_MEM: g_value_set_uint64 (value, mh_host_get_mem_free()); break; case PROP_HOST_FREE_SWAP: g_value_set_uint64 (value, mh_host_get_swap_free()); break; case PROP_HOST_LOAD: // 1/5/15 minute load average - map mh_host_get_load_averages(&avg); dict = dict_new(value); g_value_init (&value_value, G_TYPE_DOUBLE); g_value_set_double(&value_value, avg.loadavg[0]); dict_add(dict, "1", &value_value); g_value_set_double(&value_value, avg.loadavg[1]); dict_add(dict, "5", &value_value); g_value_set_double(&value_value, avg.loadavg[2]); dict_add(dict, "15", &value_value); dict_free(dict); break; case PROP_HOST_PROCESS_STATISTICS: // Process statistics is type map string -> int mh_host_get_processes(&procs); dict = dict_new(value); g_value_init (&value_value, G_TYPE_INT); g_value_set_int(&value_value, procs.total); dict_add(dict, "total", &value_value); g_value_set_int(&value_value, procs.idle); dict_add(dict, "idle", &value_value); g_value_set_int(&value_value, procs.zombie); dict_add(dict, "zombie", &value_value); g_value_set_int(&value_value, procs.running); dict_add(dict, "running", &value_value); g_value_set_int(&value_value, procs.stopped); dict_add(dict, "stopped", &value_value); g_value_set_int(&value_value, procs.sleeping); dict_add(dict, "sleeping", &value_value); dict_free(dict); break; default: /* We don't have any other property... */ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); break; } }
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; }
void ags_audiorec_map_recall(AgsMachine *machine) { AgsWindow *window; AgsAudiorec *audiorec; AgsAudio *audio; AgsPlayWaveAudioRun *play_wave_audio_run; AgsCaptureWaveAudioRun *capture_wave_audio_run; GList *start_play, *play; if((AGS_MACHINE_MAPPED_RECALL & (machine->flags)) != 0 || (AGS_MACHINE_PREMAPPED_RECALL & (machine->flags)) != 0){ return; } audiorec = AGS_AUDIOREC(machine); window = (AgsWindow *) gtk_widget_get_ancestor((GtkWidget *) machine, AGS_TYPE_WINDOW); audio = machine->audio; /* ags-play-wave */ ags_recall_factory_create(audio, NULL, NULL, "ags-play-wave", 0, 0, 0, 0, (AGS_RECALL_FACTORY_OUTPUT | AGS_RECALL_FACTORY_ADD | AGS_RECALL_FACTORY_PLAY), 0); g_object_get(audio, "play", &start_play, NULL); play = ags_recall_find_type(start_play, AGS_TYPE_PLAY_WAVE_AUDIO_RUN); if(play != NULL){ GValue value = {0,}; play_wave_audio_run = play->data; /* wave loop */ g_value_init(&value, G_TYPE_BOOLEAN); g_value_set_boolean(&value, gtk_toggle_button_get_active((GtkToggleButton *) window->navigation->loop)); ags_port_safe_write(AGS_PLAY_WAVE_AUDIO(AGS_RECALL_AUDIO_RUN(play_wave_audio_run)->recall_audio)->wave_loop, &value); g_value_unset(&value); g_value_init(&value, G_TYPE_UINT64); g_value_set_uint64(&value, 16 * window->navigation->loop_left_tact->adjustment->value); ags_port_safe_write(AGS_PLAY_WAVE_AUDIO(AGS_RECALL_AUDIO_RUN(play_wave_audio_run)->recall_audio)->wave_loop_start, &value); g_value_reset(&value); g_value_set_uint64(&value, 16 * window->navigation->loop_right_tact->adjustment->value); ags_port_safe_write(AGS_PLAY_WAVE_AUDIO(AGS_RECALL_AUDIO_RUN(play_wave_audio_run)->recall_audio)->wave_loop_end, &value); } g_list_free_full(start_play, g_object_unref); /* ags-capture-wave */ ags_recall_factory_create(audio, NULL, NULL, "ags-capture-wave", 0, 0, 0, 0, (AGS_RECALL_FACTORY_OUTPUT | AGS_RECALL_FACTORY_ADD | AGS_RECALL_FACTORY_PLAY), 0); g_object_get(audio, "play", &start_play, NULL); play = ags_recall_find_type(start_play, AGS_TYPE_CAPTURE_WAVE_AUDIO_RUN); if(play != NULL){ GValue value = {0,}; capture_wave_audio_run = play->data; /* wave loop */ g_value_init(&value, G_TYPE_BOOLEAN); g_value_set_boolean(&value, gtk_toggle_button_get_active((GtkToggleButton *) window->navigation->loop)); ags_port_safe_write(AGS_CAPTURE_WAVE_AUDIO(AGS_RECALL_AUDIO_RUN(capture_wave_audio_run)->recall_audio)->wave_loop, &value); g_value_unset(&value); g_value_init(&value, G_TYPE_UINT64); g_value_set_uint64(&value, 16 * window->navigation->loop_left_tact->adjustment->value); ags_port_safe_write(AGS_CAPTURE_WAVE_AUDIO(AGS_RECALL_AUDIO_RUN(capture_wave_audio_run)->recall_audio)->wave_loop_start, &value); g_value_reset(&value); g_value_set_uint64(&value, 16 * window->navigation->loop_right_tact->adjustment->value); ags_port_safe_write(AGS_CAPTURE_WAVE_AUDIO(AGS_RECALL_AUDIO_RUN(capture_wave_audio_run)->recall_audio)->wave_loop_end, &value); } g_list_free_full(start_play, g_object_unref); /* depending on destination */ ags_audiorec_input_map_recall(audiorec, 0); /* depending on destination */ ags_audiorec_output_map_recall(audiorec, 0); /* call parent */ AGS_MACHINE_CLASS(ags_audiorec_parent_class)->map_recall(machine); }
/** * up_device_get_property: **/ static void up_device_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) { UpDevice *device = UP_DEVICE (object); switch (prop_id) { case PROP_NATIVE_PATH: g_value_set_string (value, device->priv->native_path); break; case PROP_VENDOR: g_value_set_string (value, device->priv->vendor); break; case PROP_MODEL: g_value_set_string (value, device->priv->model); break; case PROP_SERIAL: g_value_set_string (value, device->priv->serial); break; case PROP_UPDATE_TIME: g_value_set_uint64 (value, device->priv->update_time); break; case PROP_TYPE: g_value_set_uint (value, device->priv->type); break; case PROP_POWER_SUPPLY: g_value_set_boolean (value, device->priv->power_supply); break; case PROP_ONLINE: g_value_set_boolean (value, device->priv->online); break; case PROP_IS_PRESENT: g_value_set_boolean (value, device->priv->is_present); break; case PROP_IS_RECHARGEABLE: g_value_set_boolean (value, device->priv->is_rechargeable); break; case PROP_HAS_HISTORY: g_value_set_boolean (value, device->priv->has_history); break; case PROP_HAS_STATISTICS: g_value_set_boolean (value, device->priv->has_statistics); break; case PROP_STATE: g_value_set_uint (value, device->priv->state); break; case PROP_CAPACITY: g_value_set_double (value, device->priv->capacity); break; case PROP_ENERGY: g_value_set_double (value, device->priv->energy); break; case PROP_ENERGY_EMPTY: g_value_set_double (value, device->priv->energy_empty); break; case PROP_ENERGY_FULL: g_value_set_double (value, device->priv->energy_full); break; case PROP_ENERGY_FULL_DESIGN: g_value_set_double (value, device->priv->energy_full_design); break; case PROP_ENERGY_RATE: g_value_set_double (value, device->priv->energy_rate); break; case PROP_VOLTAGE: g_value_set_double (value, device->priv->voltage); break; case PROP_TIME_TO_EMPTY: g_value_set_int64 (value, device->priv->time_to_empty); break; case PROP_TIME_TO_FULL: g_value_set_int64 (value, device->priv->time_to_full); break; case PROP_PERCENTAGE: g_value_set_double (value, device->priv->percentage); break; case PROP_TECHNOLOGY: g_value_set_uint (value, device->priv->technology); break; case PROP_RECALL_NOTICE: g_value_set_boolean (value, device->priv->recall_notice); break; case PROP_RECALL_VENDOR: g_value_set_string (value, device->priv->recall_vendor); break; case PROP_RECALL_URL: g_value_set_string (value, device->priv->recall_url); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static GTokenType gimp_config_deserialize_fundamental (GValue *value, GParamSpec *prop_spec, GScanner *scanner) { GTokenType token; GType value_type; gboolean negate = FALSE; value_type = G_TYPE_FUNDAMENTAL (prop_spec->value_type); switch (value_type) { case G_TYPE_STRING: token = G_TOKEN_STRING; break; case G_TYPE_BOOLEAN: token = G_TOKEN_IDENTIFIER; break; case G_TYPE_INT: case G_TYPE_LONG: case G_TYPE_INT64: if (g_scanner_peek_next_token (scanner) == '-') { negate = TRUE; g_scanner_get_next_token (scanner); } /* fallthrough */ case G_TYPE_UINT: case G_TYPE_ULONG: case G_TYPE_UINT64: token = G_TOKEN_INT; break; case G_TYPE_FLOAT: case G_TYPE_DOUBLE: if (g_scanner_peek_next_token (scanner) == '-') { negate = TRUE; g_scanner_get_next_token (scanner); } token = G_TOKEN_FLOAT; break; default: token = G_TOKEN_NONE; g_assert_not_reached (); break; } if (g_scanner_peek_next_token (scanner) != token) { return token; } g_scanner_get_next_token (scanner); switch (value_type) { case G_TYPE_STRING: if (scanner_string_utf8_valid (scanner, prop_spec->name)) g_value_set_static_string (value, scanner->value.v_string); else return G_TOKEN_NONE; break; case G_TYPE_BOOLEAN: if (! g_ascii_strcasecmp (scanner->value.v_identifier, "yes") || ! g_ascii_strcasecmp (scanner->value.v_identifier, "true")) g_value_set_boolean (value, TRUE); else if (! g_ascii_strcasecmp (scanner->value.v_identifier, "no") || ! g_ascii_strcasecmp (scanner->value.v_identifier, "false")) g_value_set_boolean (value, FALSE); else { g_scanner_error (scanner, /* please don't translate 'yes' and 'no' */ _("expected 'yes' or 'no' for boolean token %s, got '%s'"), prop_spec->name, scanner->value.v_identifier); return G_TOKEN_NONE; } break; case G_TYPE_INT: g_value_set_int (value, (negate ? - scanner->value.v_int64 : scanner->value.v_int64)); break; case G_TYPE_UINT: g_value_set_uint (value, scanner->value.v_int64); break; case G_TYPE_LONG: g_value_set_long (value, (negate ? - scanner->value.v_int64 : scanner->value.v_int64)); break; case G_TYPE_ULONG: g_value_set_ulong (value, scanner->value.v_int64); break; case G_TYPE_INT64: g_value_set_int64 (value, (negate ? - scanner->value.v_int64 : scanner->value.v_int64)); break; case G_TYPE_UINT64: g_value_set_uint64 (value, scanner->value.v_int64); break; case G_TYPE_FLOAT: g_value_set_float (value, negate ? - scanner->value.v_float : scanner->value.v_float); break; case G_TYPE_DOUBLE: g_value_set_double (value, negate ? - scanner->value.v_float: scanner->value.v_float); break; default: g_assert_not_reached (); break; } return G_TOKEN_RIGHT_PAREN; }
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; } }
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; }