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:
#if GLIB_CHECK_VERSION(2,31,0)
return rts_mkChar(CAP g_value_get_schar(value));
#else
return rts_mkChar(CAP g_value_get_char(value));
#endif
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:
#if GLIB_CHECK_VERSION(2,31,0)
g_value_set_schar(value, rts_getChar(obj));
#else
g_value_set_char(value, rts_getChar(obj));
#endif
return;
case G_TYPE_UCHAR:
#if GLIB_CHECK_VERSION(2,31,0)
g_value_set_schar(value, rts_getChar(obj));
#else
g_value_set_char(value, rts_getChar(obj));
#endif
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)));
}
/* Get_property handler for the pixbuf canvasi item */
static void
foo_canvas_pixbuf_get_property (GObject *object,
guint param_id,
GValue *value,
GParamSpec *pspec)
{
FooCanvasPixbuf *gcp;
PixbufPrivate *priv;
g_return_if_fail (object != NULL);
g_return_if_fail (FOO_IS_CANVAS_PIXBUF (object));
gcp = FOO_CANVAS_PIXBUF (object);
priv = gcp->priv;
switch (param_id) {
case PROP_PIXBUF:
g_value_set_object (value, G_OBJECT (priv->pixbuf));
break;
case PROP_WIDTH:
g_value_set_double (value, priv->width);
break;
case PROP_WIDTH_SET:
g_value_set_boolean (value, priv->width_set);
break;
case PROP_WIDTH_IN_PIXELS:
g_value_set_boolean (value, priv->width_in_pixels);
break;
case PROP_HEIGHT:
g_value_set_double (value, priv->height);
break;
case PROP_HEIGHT_SET:
g_value_set_boolean (value, priv->height_set);
break;
case PROP_HEIGHT_IN_PIXELS:
g_value_set_boolean (value, priv->height_in_pixels);
break;
case PROP_X:
g_value_set_double (value, priv->x);
break;
case PROP_X_IN_PIXELS:
g_value_set_boolean (value, priv->x_in_pixels);
break;
case PROP_Y:
g_value_set_double (value, priv->y);
break;
case PROP_Y_IN_PIXELS:
g_value_set_boolean (value, priv->y_in_pixels);
break;
case PROP_ANCHOR:
g_value_set_enum (value, priv->anchor);
break;
case PROP_INTERP_TYPE:
g_value_set_enum (value, priv->interp_type);
break;
case PROP_POINT_IGNORES_ALPHA:
g_value_set_boolean (value, priv->point_ignores_alpha);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
break;
}
}
static void gst_imx_compositor_pad_get_property(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
{
GstImxCompositorPad *compositor_pad = GST_IMX_COMPOSITOR_PAD(object);
switch (prop_id)
{
case PROP_PAD_XPOS:
g_value_set_int(value, compositor_pad->xpos);
break;
case PROP_PAD_YPOS:
g_value_set_int(value, compositor_pad->ypos);
break;
case PROP_PAD_WIDTH:
g_value_set_int(value, compositor_pad->width);
break;
case PROP_PAD_HEIGHT:
g_value_set_int(value, compositor_pad->height);
break;
case PROP_PAD_LEFT_MARGIN:
g_value_set_uint(value, compositor_pad->canvas.margin_left);
break;
case PROP_PAD_TOP_MARGIN:
g_value_set_uint(value, compositor_pad->canvas.margin_top);
break;
case PROP_PAD_RIGHT_MARGIN:
g_value_set_uint(value, compositor_pad->canvas.margin_right);
break;
case PROP_PAD_BOTTOM_MARGIN:
g_value_set_uint(value, compositor_pad->canvas.margin_bottom);
break;
case PROP_PAD_ROTATION:
g_value_set_enum(value, compositor_pad->canvas.inner_rotation);
break;
case PROP_PAD_KEEP_ASPECT_RATIO:
g_value_set_boolean(value, compositor_pad->canvas.keep_aspect_ratio);
break;
case PROP_PAD_INPUT_CROP:
g_value_set_boolean(value, compositor_pad->input_crop);
break;
case PROP_PAD_ALPHA:
g_value_set_double(value, compositor_pad->alpha);
break;
case PROP_PAD_FILL_COLOR:
g_value_set_uint(value, compositor_pad->canvas.fill_color);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
break;
}
}
static void
gimp_paint_options_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec)
{
GimpPaintOptions *options = GIMP_PAINT_OPTIONS (object);
GimpFadeOptions *fade_options = options->fade_options;
GimpJitterOptions *jitter_options = options->jitter_options;
GimpGradientOptions *gradient_options = options->gradient_options;
GimpSmoothingOptions *smoothing_options = options->smoothing_options;
switch (property_id)
{
case PROP_PAINT_INFO:
g_value_set_object (value, options->paint_info);
break;
case PROP_USE_APPLICATOR:
g_value_set_boolean (value, options->use_applicator);
break;
case PROP_BRUSH_SIZE:
g_value_set_double (value, options->brush_size);
break;
case PROP_BRUSH_ASPECT_RATIO:
g_value_set_double (value, options->brush_aspect_ratio);
break;
case PROP_BRUSH_ANGLE:
g_value_set_double (value, - 1.0 * options->brush_angle * 360.0); /* mathematically correct -> intuitively correct */
break;
case PROP_APPLICATION_MODE:
g_value_set_enum (value, options->application_mode);
break;
case PROP_HARD:
g_value_set_boolean (value, options->hard);
break;
case PROP_USE_JITTER:
g_value_set_boolean (value, jitter_options->use_jitter);
break;
case PROP_JITTER_AMOUNT:
g_value_set_double (value, jitter_options->jitter_amount);
break;
case PROP_DYNAMICS_EXPANDED:
g_value_set_boolean (value, options->dynamics_expanded);
break;
case PROP_FADE_LENGTH:
g_value_set_double (value, fade_options->fade_length);
break;
case PROP_FADE_REVERSE:
g_value_set_boolean (value, fade_options->fade_reverse);
break;
case PROP_FADE_REPEAT:
g_value_set_enum (value, fade_options->fade_repeat);
break;
case PROP_FADE_UNIT:
g_value_set_int (value, fade_options->fade_unit);
break;
case PROP_GRADIENT_REVERSE:
g_value_set_boolean (value, gradient_options->gradient_reverse);
break;
case PROP_BRUSH_VIEW_TYPE:
g_value_set_enum (value, options->brush_view_type);
break;
case PROP_BRUSH_VIEW_SIZE:
g_value_set_int (value, options->brush_view_size);
break;
case PROP_DYNAMICS_VIEW_TYPE:
g_value_set_enum (value, options->dynamics_view_type);
break;
case PROP_DYNAMICS_VIEW_SIZE:
g_value_set_int (value, options->dynamics_view_size);
break;
case PROP_PATTERN_VIEW_TYPE:
g_value_set_enum (value, options->pattern_view_type);
break;
case PROP_PATTERN_VIEW_SIZE:
g_value_set_int (value, options->pattern_view_size);
break;
case PROP_GRADIENT_VIEW_TYPE:
g_value_set_enum (value, options->gradient_view_type);
break;
case PROP_GRADIENT_VIEW_SIZE:
g_value_set_int (value, options->gradient_view_size);
break;
case PROP_USE_SMOOTHING:
g_value_set_boolean (value, smoothing_options->use_smoothing);
break;
case PROP_SMOOTHING_QUALITY:
g_value_set_int (value, smoothing_options->smoothing_quality);
break;
case PROP_SMOOTHING_FACTOR:
g_value_set_double (value, smoothing_options->smoothing_factor);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static void
gimp_tiling_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec)
{
GimpTiling *tiling = GIMP_TILING (object);
GimpSymmetry *sym = GIMP_SYMMETRY (tiling);
switch (property_id)
{
case PROP_X_INTERVAL:
if (sym->image)
{
gdouble new_x = g_value_get_double (value);
if (new_x < gimp_image_get_width (sym->image))
{
tiling->interval_x = new_x;
if (tiling->interval_x <= tiling->shift + G_DOUBLE_EPSILON)
{
GValue val = G_VALUE_INIT;
g_value_init (&val, G_TYPE_DOUBLE);
g_value_set_double (&val, 0.0);
g_object_set_property (G_OBJECT (object), "shift", &val);
}
if (sym->drawable)
gimp_tiling_update_strokes (sym, sym->drawable, sym->origin);
}
}
break;
case PROP_Y_INTERVAL:
{
gdouble new_y = g_value_get_double (value);
if (new_y < gimp_image_get_height (sym->image))
{
tiling->interval_y = new_y;
if (tiling->interval_y <= G_DOUBLE_EPSILON)
{
GValue val = G_VALUE_INIT;
g_value_init (&val, G_TYPE_DOUBLE);
g_value_set_double (&val, 0.0);
g_object_set_property (G_OBJECT (object), "shift", &val);
}
if (sym->drawable)
gimp_tiling_update_strokes (sym, sym->drawable, sym->origin);
}
}
break;
case PROP_SHIFT:
{
gdouble new_shift = g_value_get_double (value);
if (new_shift == 0.0 ||
(tiling->interval_y != 0.0 && new_shift < tiling->interval_x))
{
tiling->shift = new_shift;
if (sym->drawable)
gimp_tiling_update_strokes (sym, sym->drawable, sym->origin);
}
}
break;
case PROP_X_MAX:
tiling->max_x = g_value_get_int (value);
if (sym->drawable)
gimp_tiling_update_strokes (sym, sym->drawable, sym->origin);
break;
case PROP_Y_MAX:
tiling->max_y = g_value_get_int (value);
if (sym->drawable)
gimp_tiling_update_strokes (sym, sym->drawable, sym->origin);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static void
gimp_pdb_context_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec)
{
GimpPDBContext *options = GIMP_PDB_CONTEXT (object);
switch (property_id)
{
case PROP_ANTIALIAS:
g_value_set_boolean (value, options->antialias);
break;
case PROP_FEATHER:
g_value_set_boolean (value, options->feather);
break;
case PROP_FEATHER_RADIUS_X:
g_value_set_double (value, options->feather_radius_x);
break;
case PROP_FEATHER_RADIUS_Y:
g_value_set_double (value, options->feather_radius_y);
break;
case PROP_SAMPLE_MERGED:
g_value_set_boolean (value, options->sample_merged);
break;
case PROP_SAMPLE_CRITERION:
g_value_set_enum (value, options->sample_criterion);
break;
case PROP_SAMPLE_THRESHOLD:
g_value_set_double (value, options->sample_threshold);
break;
case PROP_SAMPLE_TRANSPARENT:
g_value_set_boolean (value, options->sample_transparent);
break;
case PROP_INTERPOLATION:
g_value_set_enum (value, options->interpolation);
break;
case PROP_TRANSFORM_DIRECTION:
g_value_set_enum (value, options->transform_direction);
break;
case PROP_TRANSFORM_RESIZE:
g_value_set_enum (value, options->transform_resize);
break;
case PROP_TRANSFORM_RECURSION:
g_value_set_int (value, options->transform_recursion);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
gboolean
gst_frei0r_get_property (f0r_instance_t * instance, GstFrei0rFuncTable * ftable,
GstFrei0rProperty * properties, gint n_properties,
GstFrei0rPropertyValue * property_cache, guint prop_id, GValue * value)
{
gint i;
GstFrei0rProperty *prop = NULL;
for (i = 0; i < n_properties; i++) {
if (properties[i].prop_id <= prop_id &&
properties[i].prop_id + properties[i].n_prop_ids > prop_id) {
prop = &properties[i];
break;
}
}
if (!prop)
return FALSE;
switch (prop->info.type) {
case F0R_PARAM_BOOL:{
gdouble d;
if (instance)
ftable->get_param_value (instance, &d, prop->prop_idx);
else
d = property_cache[prop->prop_idx].data.b;
g_value_set_boolean (value, (d < 0.5) ? FALSE : TRUE);
break;
}
case F0R_PARAM_DOUBLE:{
gdouble d;
if (instance)
ftable->get_param_value (instance, &d, prop->prop_idx);
else
d = property_cache[prop->prop_idx].data.d;
g_value_set_double (value, d);
break;
}
case F0R_PARAM_STRING:{
const gchar *s;
if (instance)
ftable->get_param_value (instance, &s, prop->prop_idx);
else
s = property_cache[prop->prop_idx].data.s;
g_value_set_string (value, s);
break;
}
case F0R_PARAM_COLOR:{
f0r_param_color_t color;
if (instance)
ftable->get_param_value (instance, &color, prop->prop_idx);
else
color = property_cache[prop->prop_idx].data.color;
switch (prop_id - prop->prop_id) {
case 0:
g_value_set_float (value, color.r);
break;
case 1:
g_value_set_float (value, color.g);
break;
case 2:
g_value_set_float (value, color.b);
break;
}
break;
}
case F0R_PARAM_POSITION:{
f0r_param_position_t position;
if (instance)
ftable->get_param_value (instance, &position, prop->prop_idx);
else
position = property_cache[prop->prop_idx].data.position;
switch (prop_id - prop->prop_id) {
case 0:
g_value_set_double (value, position.x);
break;
case 1:
g_value_set_double (value, position.y);
break;
}
break;
}
default:
g_assert_not_reached ();
break;
}
return TRUE;
}
static GstTagList *
ape_demux_parse_tags (const guint8 * data, gint size)
{
GstTagList *taglist = gst_tag_list_new ();
GST_LOG ("Reading tags from chunk of size %u bytes", size);
/* get rid of header/footer */
if (size >= 32 && memcmp (data, "APETAGEX", 8) == 0) {
data += 32;
size -= 32;
}
if (size > 32 && memcmp (data + size - 32, "APETAGEX", 8) == 0) {
size -= 32;
}
/* read actual tags - at least 10 bytes for tag header */
while (size >= 10) {
guint len, n = 8;
gchar *tag, *val;
const gchar *gst_tag;
GType gst_tag_type;
/* find tag type and size */
len = GST_READ_UINT32_LE (data);
while (n < size && data[n] != 0x0)
n++;
if (n == size)
break;
g_assert (data[n] == 0x0);
n++;
if (size - n < len)
break;
/* If the tag is empty, skip to the next one */
if (len == 0)
goto next_tag;
/* read */
tag = g_strndup ((gchar *) data + 8, n - 9);
val = g_strndup ((gchar *) data + n, len);
GST_LOG ("tag [%s], val[%s]", tag, val);
/* special-case 'media' tag, could be e.g. "CD 1/2" */
if (g_ascii_strcasecmp (tag, "media") == 0) {
gchar *sp, *sp2;
g_free (tag);
tag = g_strdup ("discnumber");
/* get rid of the medium in front */
sp = strchr (val, ' ');
while (sp != NULL && (sp2 = strchr (sp + 1, ' ')) != NULL)
sp = sp2;
if (sp) {
g_memmove (val, sp + 1, strlen (sp + 1) + 1);
}
}
if (ape_demux_get_gst_tag_from_tag (tag, &gst_tag, &gst_tag_type)) {
GValue v = { 0, };
switch (gst_tag_type) {
case G_TYPE_INT:{
gint v_int;
if (sscanf (val, "%d", &v_int) == 1) {
g_value_init (&v, G_TYPE_INT);
g_value_set_int (&v, v_int);
}
break;
}
case G_TYPE_UINT:{
guint v_uint, count;
if (strcmp (gst_tag, GST_TAG_TRACK_NUMBER) == 0) {
gint dummy;
if (sscanf (val, "%u", &v_uint) == 1 && v_uint > 0) {
g_value_init (&v, G_TYPE_UINT);
g_value_set_uint (&v, v_uint);
}
GST_LOG ("checking for track count: %s", val);
/* might be 0/N or -1/N to specify that there is only a count */
if (sscanf (val, "%d/%u", &dummy, &count) == 2 && count > 0) {
gst_tag_list_add (taglist, GST_TAG_MERGE_APPEND,
GST_TAG_TRACK_COUNT, count, NULL);
}
} else if (strcmp (gst_tag, GST_TAG_ALBUM_VOLUME_NUMBER) == 0) {
gint dummy;
if (sscanf (val, "%u", &v_uint) == 1 && v_uint > 0) {
g_value_init (&v, G_TYPE_UINT);
g_value_set_uint (&v, v_uint);
}
GST_LOG ("checking for volume count: %s", val);
/* might be 0/N or -1/N to specify that there is only a count */
if (sscanf (val, "%d/%u", &dummy, &count) == 2 && count > 0) {
gst_tag_list_add (taglist, GST_TAG_MERGE_APPEND,
GST_TAG_ALBUM_VOLUME_COUNT, count, NULL);
}
} else if (sscanf (val, "%u", &v_uint) == 1) {
g_value_init (&v, G_TYPE_UINT);
g_value_set_uint (&v, v_uint);
}
break;
}
case G_TYPE_STRING:{
g_value_init (&v, G_TYPE_STRING);
g_value_set_string (&v, val);
break;
}
case G_TYPE_DOUBLE:{
gdouble v_double;
gchar *endptr;
/* floating point strings can be "4,123" or "4.123" depending on
* the locale. We need to be able to parse and read either version
* no matter what our current locale is */
g_strdelimit (val, ",", '.');
v_double = g_ascii_strtod (val, &endptr);
if (endptr != val) {
g_value_init (&v, G_TYPE_DOUBLE);
g_value_set_double (&v, v_double);
}
break;
}
default:{
if (gst_tag_type == GST_TYPE_DATE) {
gint v_int;
if (sscanf (val, "%d", &v_int) == 1) {
GDate *date = g_date_new_dmy (1, 1, v_int);
g_value_init (&v, GST_TYPE_DATE);
gst_value_set_date (&v, date);
g_date_free (date);
}
} else {
GST_WARNING ("Unhandled tag type '%s' for tag '%s'",
g_type_name (gst_tag_type), gst_tag);
}
break;
}
}
if (G_VALUE_TYPE (&v) != 0) {
gst_tag_list_add_values (taglist, GST_TAG_MERGE_APPEND,
gst_tag, &v, NULL);
g_value_unset (&v);
}
}
GST_DEBUG ("Read tag %s: %s", tag, val);
g_free (tag);
g_free (val);
/* move data pointer */
next_tag:
size -= len + n;
data += len + n;
}
GST_DEBUG ("Taglist: %" GST_PTR_FORMAT, taglist);
return taglist;
}
static void
terminal_profile_gsettings_notify_cb (GSettings *settings,
gchar *key,
gpointer user_data)
{
TerminalProfile *profile = TERMINAL_PROFILE (user_data);
TerminalProfilePrivate *priv = profile->priv;
TerminalProfileClass *klass;
GVariant *settings_value;
GParamSpec *pspec;
GValue value = { 0, };
gboolean equal;
gboolean force_set = FALSE;
if (!key) return;
_terminal_debug_print (TERMINAL_DEBUG_PROFILE,
"GSettings notification for key %s [%s]\n",
key,
g_settings_is_writable (settings, key) ? "writable" : "LOCKED");
klass = TERMINAL_PROFILE_GET_CLASS (profile);
pspec = g_hash_table_lookup (klass->gsettings_keys, key);
if (!pspec)
return; /* ignore unknown keys, for future extensibility */
priv->locked[pspec->param_id] = !g_settings_is_writable (settings, key);
settings_value = g_settings_get_value (settings, key);
if (!settings_value)
return;
g_value_init (&value, G_PARAM_SPEC_VALUE_TYPE (pspec));
if (G_IS_PARAM_SPEC_BOOLEAN (pspec))
{
if (!g_variant_is_of_type (settings_value, G_VARIANT_TYPE_BOOLEAN))
goto out;
g_value_set_boolean (&value, g_variant_get_boolean (settings_value));
}
else if (G_IS_PARAM_SPEC_STRING (pspec))
{
if (!g_variant_is_of_type (settings_value, G_VARIANT_TYPE_STRING))
goto out;
g_value_set_string (&value, g_variant_get_string (settings_value, NULL));
}
else if (G_IS_PARAM_SPEC_ENUM (pspec))
{
if (!g_variant_is_of_type (settings_value, G_VARIANT_TYPE_STRING))
goto out;
g_value_set_enum (&value, g_settings_get_enum (settings, key));
}
else if (G_PARAM_SPEC_VALUE_TYPE (pspec) == GDK_TYPE_COLOR)
{
GdkColor color;
if (!g_variant_is_of_type (settings_value, G_VARIANT_TYPE_STRING))
goto out;
if (!gdk_color_parse (g_variant_get_string (settings_value, NULL), &color))
goto out;
g_value_set_boxed (&value, &color);
}
else if (G_PARAM_SPEC_VALUE_TYPE (pspec) == PANGO_TYPE_FONT_DESCRIPTION)
{
if (!g_variant_is_of_type (settings_value, G_VARIANT_TYPE_STRING))
goto out;
g_value_take_boxed (&value, pango_font_description_from_string (g_variant_get_string (settings_value, NULL)));
}
else if (G_IS_PARAM_SPEC_DOUBLE (pspec))
{
if (!g_variant_is_of_type (settings_value, G_VARIANT_TYPE_DOUBLE))
goto out;
g_value_set_double (&value, g_variant_get_double (settings_value));
}
else if (G_IS_PARAM_SPEC_INT (pspec))
{
if (!g_variant_is_of_type (settings_value, G_VARIANT_TYPE_INT16) &&
!g_variant_is_of_type (settings_value, G_VARIANT_TYPE_INT32) &&
!g_variant_is_of_type (settings_value, G_VARIANT_TYPE_INT64))
goto out;
g_value_set_int (&value, g_settings_get_int(settings, key));
}
else if (G_IS_PARAM_SPEC_VALUE_ARRAY (pspec) &&
G_PARAM_SPEC_VALUE_TYPE (G_PARAM_SPEC_VALUE_ARRAY (pspec)->element_spec) == GDK_TYPE_COLOR)
{
char **color_strings;
GdkColor *colors;
int n_colors, i;
if (!g_variant_is_of_type (settings_value, G_VARIANT_TYPE_STRING))
goto out;
color_strings = g_strsplit (g_variant_get_string (settings_value, NULL), ":", -1);
if (!color_strings)
goto out;
n_colors = g_strv_length (color_strings);
colors = g_new0 (GdkColor, n_colors);
for (i = 0; i < n_colors; ++i)
{
if (!gdk_color_parse (color_strings[i], &colors[i]))
continue; /* ignore errors */
}
g_strfreev (color_strings);
/* We continue even with a palette size != TERMINAL_PALETTE_SIZE,
* so we can change the palette size in future versions without
* causing too many issues.
*/
set_value_from_palette (&value, colors, n_colors);
g_free (colors);
}
else
{
g_printerr ("Unhandled value type %s of pspec %s\n", g_type_name (G_PARAM_SPEC_VALUE_TYPE (pspec)), pspec->name);
goto out;
}
if (g_param_value_validate (pspec, &value))
{
_terminal_debug_print (TERMINAL_DEBUG_PROFILE,
"Invalid value in GSettings for key %s was changed to comply with pspec %s\n",
key, pspec->name);
force_set = TRUE;
}
/* Only set the property if the value is different than our current value,
* so we don't go into an infinite loop.
*/
equal = values_equal (pspec, &value, g_value_array_get_nth (priv->properties, pspec->param_id));
#ifdef MATE_ENABLE_DEBUG
_TERMINAL_DEBUG_IF (TERMINAL_DEBUG_PROFILE)
{
if (!equal)
_terminal_debug_print (TERMINAL_DEBUG_PROFILE,
"Setting property %s to a different value\n"
" now: %s\n"
" new: %s\n",
pspec->name,
g_strdup_value_contents (g_value_array_get_nth (priv->properties, pspec->param_id)),
g_strdup_value_contents (&value));
}
#endif
if (!equal || force_set)
{
priv->gsettings_notification_pspec = pspec;
g_object_set_property (G_OBJECT (profile), pspec->name, &value);
priv->gsettings_notification_pspec = NULL;
}
out:
/* FIXME: if we arrive here through goto in the error cases,
* should we maybe reset the property to its default value?
*/
g_value_unset (&value);
g_variant_unref (settings_value);
}
static void
hildon_font_selection_dialog_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
gint i;
GdkColor color;
HildonFontSelectionDialogPrivate *priv =
HILDON_FONT_SELECTION_DIALOG_GET_PRIVATE(object);
g_assert (priv);
switch (prop_id)
{
case PROP_FAMILY:
i = gtk_combo_box_get_active (GTK_COMBO_BOX (priv->cbx_font_type));
if(i >= 0 && i < priv->n_families)
g_value_set_string(value,
pango_font_family_get_name (priv->families[i]));
else
g_value_set_string (value, "Sans");
/* FIXME Bad hardcoding here */
break;
case PROP_FAMILY_SET:
i = gtk_combo_box_get_active (GTK_COMBO_BOX (priv->cbx_font_type));
if(i >= 0 && i < priv->n_families)
g_value_set_boolean (value, TRUE);
else
g_value_set_boolean (value, FALSE);
break;
case PROP_SIZE:
i = gtk_combo_box_get_active (GTK_COMBO_BOX (priv->cbx_font_size));
if(i >= 0 && i < G_N_ELEMENTS (font_sizes))
g_value_set_int (value, font_sizes[i]);
else
g_value_set_int (value, 16);
break;
case PROP_SIZE_SET:
i = gtk_combo_box_get_active (GTK_COMBO_BOX (priv->cbx_font_size));
if(i >= 0 && i < G_N_ELEMENTS (font_sizes))
g_value_set_boolean (value, TRUE);
else
g_value_set_boolean (value, FALSE);
break;
case PROP_COLOR:
hildon_color_button_get_color
(HILDON_COLOR_BUTTON (priv->font_color_button), &color);
g_value_set_boxed (value, (gconstpointer) &color);
break;
case PROP_COLOR_SET:
g_value_set_boolean (value, priv->color_set);
break;
case PROP_BOLD:
g_value_set_boolean (value,
gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (priv->chk_bold)));
break;
case PROP_BOLD_SET:
g_value_set_boolean (value,
! gtk_toggle_button_get_inconsistent
(GTK_TOGGLE_BUTTON (priv->chk_bold)));
break;
case PROP_ITALIC:
g_value_set_boolean (value,
gtk_toggle_button_get_active
(GTK_TOGGLE_BUTTON (priv->chk_italic)));
break;
case PROP_ITALIC_SET:
g_value_set_boolean (value,
! gtk_toggle_button_get_inconsistent
(GTK_TOGGLE_BUTTON (priv->chk_italic)));
break;
case PROP_UNDERLINE:
g_value_set_boolean (value,
gtk_toggle_button_get_active
(GTK_TOGGLE_BUTTON (priv->chk_underline)));
break;
case PROP_UNDERLINE_SET:
g_value_set_boolean (value,
! gtk_toggle_button_get_inconsistent
(GTK_TOGGLE_BUTTON (priv->chk_underline)));
break;
case PROP_STRIKETHROUGH:
g_value_set_boolean(value,
gtk_toggle_button_get_active
(GTK_TOGGLE_BUTTON (priv->chk_strikethrough)));
break;
case PROP_STRIKETHROUGH_SET:
g_value_set_boolean(value,
! gtk_toggle_button_get_inconsistent
(GTK_TOGGLE_BUTTON (priv->chk_strikethrough)));
break;
case PROP_POSITION:
i = gtk_combo_box_get_active (GTK_COMBO_BOX (priv->cbx_positioning));
if(i == 1) /* super */
g_value_set_int (value, 1);
else if(i == 2)/* sub */
g_value_set_int (value, -1);
else
g_value_set_int (value, 0);
break;
case PROP_FONT_SCALING:
g_value_set_double (value, priv->font_scaling);
break;
case PROP_POSITION_SET:
i = gtk_combo_box_get_active (GTK_COMBO_BOX (priv->cbx_positioning));
if(i >= 0 && i < 3)
g_value_set_boolean (value, TRUE);
else
g_value_set_boolean (value, FALSE);
break;
case PROP_PREVIEW_TEXT:
g_value_set_string (value,
hildon_font_selection_dialog_get_preview_text (HILDON_FONT_SELECTION_DIALOG (object)));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static GValueArray *
brushes_get_brush_data_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GValueArray *args)
{
gboolean success = TRUE;
GValueArray *return_vals;
const gchar *name;
gchar *actual_name = NULL;
gdouble opacity = 0.0;
gint32 spacing = 0;
gint32 paint_mode = 0;
gint32 width = 0;
gint32 height = 0;
gint32 length = 0;
guint8 *mask_data = NULL;
name = g_value_get_string (&args->values[0]);
if (success)
{
GimpBrush *brush;
if (name && strlen (name))
{
brush = (GimpBrush *)
gimp_container_get_child_by_name (gimp->brush_factory->container, name);
}
else
{
brush = gimp_context_get_brush (context);
}
if (brush)
{
actual_name = g_strdup (gimp_object_get_name (GIMP_OBJECT (brush)));
opacity = 1.0;
spacing = gimp_brush_get_spacing (brush);
paint_mode = 0;
width = brush->mask->width;
height = brush->mask->height;
length = brush->mask->height * brush->mask->width;
mask_data = g_memdup (temp_buf_data (brush->mask), length);
}
else
success = FALSE;
}
return_vals = gimp_procedure_get_return_values (procedure, success);
if (success)
{
g_value_take_string (&return_vals->values[1], actual_name);
g_value_set_double (&return_vals->values[2], opacity);
g_value_set_int (&return_vals->values[3], spacing);
g_value_set_enum (&return_vals->values[4], paint_mode);
g_value_set_int (&return_vals->values[5], width);
g_value_set_int (&return_vals->values[6], height);
g_value_set_int (&return_vals->values[7], length);
gimp_value_take_int8array (&return_vals->values[8], mask_data, length);
}
return return_vals;
}
static gchar *
get_action_arg_widget_info (GtkWidget *arg_widget,
GUPnPServiceIntrospection *introspection,
GUPnPServiceActionInfo *action_info,
GValue **value)
{
GUPnPServiceActionArgInfo *arg_info;
const GUPnPServiceStateVariableInfo *variable_info;
gchar *arg_name;
g_assert (value != NULL);
arg_name = g_object_get_data (G_OBJECT (arg_widget),
"argument-name");
if (arg_name == NULL)
return NULL;
arg_info = get_action_argument (action_info, arg_name);
variable_info = gupnp_service_introspection_get_state_variable (
introspection,
arg_info->related_state_variable);
*value = g_slice_alloc0 (sizeof (GValue));
g_value_init (*value, variable_info->type);
if (arg_info->direction == GUPNP_SERVICE_ACTION_ARG_DIRECTION_OUT)
return arg_info->name;
if (variable_info->is_numeric) {
GValue double_value;
gdouble num;
memset (&double_value, 0, sizeof (GValue));
g_value_init (&double_value, G_TYPE_DOUBLE);
num = gtk_spin_button_get_value (GTK_SPIN_BUTTON (arg_widget));
g_value_set_double (&double_value, num);
g_value_transform (&double_value, *value);
g_value_unset (&double_value);
} else if (variable_info->type == G_TYPE_BOOLEAN) {
gboolean active;
active = gtk_toggle_button_get_active (
GTK_TOGGLE_BUTTON (arg_widget));
g_value_set_boolean (*value,
active);
} else {
GValue str_value;
memset (&str_value, 0, sizeof (GValue));
g_value_init (&str_value, G_TYPE_STRING);
if (GTK_IS_SCROLLED_WINDOW (arg_widget)) {
GtkWidget *text_view;
GtkTextBuffer *text_buffer;
GtkTextIter start, end;
const gchar *text;
text_view = gtk_bin_get_child (GTK_BIN (arg_widget));
text_buffer = gtk_text_view_get_buffer (
GTK_TEXT_VIEW (text_view));
gtk_text_buffer_get_bounds (text_buffer,
&start,
&end);
text = gtk_text_buffer_get_text (text_buffer,
&start,
&end,
FALSE);
g_value_set_string (&str_value, text);
}
else {
gchar *text;
text = gtk_combo_box_text_get_active_text (
GTK_COMBO_BOX_TEXT (arg_widget));
g_value_set_string (&str_value, text);
g_free (text);
}
g_value_transform (&str_value, *value);
g_value_unset (&str_value);
}
return arg_info->name;
}
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_boxed_free (RHYTHMDB_TYPE_ENTRY_TYPE, 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 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;
}
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);
}
}
}
}
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;
}
}
GladeAttribute *
glade_gtk_attribute_from_string (PangoAttrType type, const gchar *strval)
{
GladeAttribute *gattr;
GdkColor color;
gattr = g_new0 (GladeAttribute, 1);
gattr->type = type;
gattr->start = 0;
gattr->end = G_MAXUINT;
switch (type)
{
case PANGO_ATTR_LANGUAGE:
case PANGO_ATTR_FAMILY:
case PANGO_ATTR_FONT_DESC:
g_value_init (&(gattr->value), G_TYPE_STRING);
g_value_set_string (&(gattr->value), strval);
break;
case PANGO_ATTR_STYLE:
case PANGO_ATTR_WEIGHT:
case PANGO_ATTR_VARIANT:
case PANGO_ATTR_STRETCH:
case PANGO_ATTR_GRAVITY:
case PANGO_ATTR_GRAVITY_HINT:
/* Enums ... */
g_value_init (&(gattr->value), type_from_attr_type (type));
g_value_set_enum (&(gattr->value),
glade_utils_enum_value_from_string (type_from_attr_type (type), strval));
break;
case PANGO_ATTR_UNDERLINE:
case PANGO_ATTR_STRIKETHROUGH:
/* Booleans */
g_value_init (&(gattr->value), G_TYPE_BOOLEAN);
g_value_set_boolean (&(gattr->value), TRUE);
break;
/* PangoAttrSize */
case PANGO_ATTR_SIZE:
case PANGO_ATTR_ABSOLUTE_SIZE:
/* ints */
g_value_init (&(gattr->value), G_TYPE_INT);
g_value_set_int (&(gattr->value), strtol (strval, NULL, 10));
break;
/* PangoAttrFloat */
case PANGO_ATTR_SCALE:
/* doubles */
g_value_init (&(gattr->value), G_TYPE_DOUBLE);
g_value_set_double (&(gattr->value), g_ascii_strtod (strval, NULL));
break;
/* PangoAttrColor */
case PANGO_ATTR_FOREGROUND:
case PANGO_ATTR_BACKGROUND:
case PANGO_ATTR_UNDERLINE_COLOR:
case PANGO_ATTR_STRIKETHROUGH_COLOR:
/* boxed colours */
if (gdk_color_parse (strval, &color))
{
g_value_init (&(gattr->value), GDK_TYPE_COLOR);
g_value_set_boxed (&(gattr->value), &color);
}
else
g_critical ("Unable to parse color attribute '%s'", strval);
break;
/* PangoAttrShape */
case PANGO_ATTR_SHAPE:
/* Unsupported for now */
break;
case PANGO_ATTR_INVALID:
case PANGO_ATTR_LETTER_SPACING:
case PANGO_ATTR_RISE:
case PANGO_ATTR_FALLBACK:
default:
break;
}
return gattr;
}
static void
gimp_operation_tool_color_picked (GimpImageMapTool *im_tool,
gpointer identifier,
gdouble x,
gdouble y,
const Babl *sample_format,
const GimpRGB *color)
{
GimpOperationTool *tool = GIMP_OPERATION_TOOL (im_tool);
gchar **pspecs;
pspecs = g_strsplit (identifier, ":", 2);
if (pspecs[1])
{
GimpImageMapOptions *options = GIMP_IMAGE_MAP_TOOL_GET_OPTIONS (tool);
GimpDrawable *drawable = GIMP_TOOL (im_tool)->drawable;
GObjectClass *object_class = G_OBJECT_GET_CLASS (im_tool->config);
GParamSpec *pspec_x;
GParamSpec *pspec_y;
gint width = 1;
gint height = 1;
if (drawable)
{
gint off_x, off_y;
gimp_item_get_offset (GIMP_ITEM (drawable), &off_x, &off_y);
x -= off_x;
y -= off_y;
switch (options->region)
{
case GIMP_IMAGE_MAP_REGION_SELECTION:
if (gimp_item_mask_intersect (GIMP_ITEM (drawable),
&off_x, &off_y, &width, &height))
{
x -= off_x;
y -= off_y;
}
break;
case GIMP_IMAGE_MAP_REGION_DRAWABLE:
width = gimp_item_get_width (GIMP_ITEM (drawable));
height = gimp_item_get_height (GIMP_ITEM (drawable));
break;
}
}
pspec_x = g_object_class_find_property (object_class, pspecs[0]);
pspec_y = g_object_class_find_property (object_class, pspecs[1]);
if (pspec_x && pspec_y &&
G_PARAM_SPEC_TYPE (pspec_x) == G_PARAM_SPEC_TYPE (pspec_y))
{
GValue value_x = G_VALUE_INIT;
GValue value_y = G_VALUE_INIT;
g_value_init (&value_x, G_PARAM_SPEC_VALUE_TYPE (pspec_x));
g_value_init (&value_y, G_PARAM_SPEC_VALUE_TYPE (pspec_y));
#define HAS_KEY(p,k,v) gimp_gegl_param_spec_has_key (p, k, v)
if (HAS_KEY (pspec_x, "unit", "relative-coordinate") &&
HAS_KEY (pspec_y, "unit", "relative-coordinate"))
{
x /= (gdouble) width;
y /= (gdouble) height;
}
if (G_IS_PARAM_SPEC_INT (pspec_x))
{
g_value_set_int (&value_x, x);
g_value_set_int (&value_y, y);
g_param_value_validate (pspec_x, &value_x);
g_param_value_validate (pspec_y, &value_y);
g_object_set (im_tool->config,
pspecs[0], g_value_get_int (&value_x),
pspecs[1], g_value_get_int (&value_y),
NULL);
}
else if (G_IS_PARAM_SPEC_DOUBLE (pspec_x))
{
g_value_set_double (&value_x, x);
g_value_set_double (&value_y, y);
g_param_value_validate (pspec_x, &value_x);
g_param_value_validate (pspec_y, &value_y);
g_object_set (im_tool->config,
pspecs[0], g_value_get_double (&value_x),
pspecs[1], g_value_get_double (&value_y),
NULL);
}
else
{
g_warning ("%s: unhandled param spec of type %s",
G_STRFUNC, G_PARAM_SPEC_TYPE_NAME (pspec_x));
}
g_value_unset (&value_x);
g_value_unset (&value_y);
}
}
else
{
g_object_set (im_tool->config,
pspecs[0], color,
NULL);
}
g_strfreev (pspecs);
}
static gboolean
gst_rtp_jpeg_depay_setcaps (GstRTPBaseDepayload * depayload, GstCaps * caps)
{
GstRtpJPEGDepay *rtpjpegdepay;
GstStructure *structure;
gint clock_rate;
const gchar *media_attr;
rtpjpegdepay = GST_RTP_JPEG_DEPAY (depayload);
structure = gst_caps_get_structure (caps, 0);
GST_DEBUG_OBJECT (rtpjpegdepay, "Caps set: %" GST_PTR_FORMAT, caps);
if (!gst_structure_get_int (structure, "clock-rate", &clock_rate))
clock_rate = 90000;
depayload->clock_rate = clock_rate;
/* reset defaults */
rtpjpegdepay->width = 0;
rtpjpegdepay->height = 0;
rtpjpegdepay->media_width = 0;
rtpjpegdepay->media_height = 0;
rtpjpegdepay->frate_num = 0;
rtpjpegdepay->frate_denom = 1;
/* check for optional SDP attributes */
if ((media_attr = gst_structure_get_string (structure, "x-dimensions"))) {
gint w, h;
if (sscanf (media_attr, "%d,%d", &w, &h) == 2) {
rtpjpegdepay->media_width = w;
rtpjpegdepay->media_height = h;
}
}
if ((media_attr = gst_structure_get_string (structure, "a-framesize"))) {
gint w, h;
if (sscanf (media_attr, "%d-%d", &w, &h) == 2) {
rtpjpegdepay->media_width = w;
rtpjpegdepay->media_height = h;
}
}
/* try to get a framerate */
media_attr = gst_structure_get_string (structure, "a-framerate");
if (!media_attr)
media_attr = gst_structure_get_string (structure, "x-framerate");
if (media_attr) {
GValue src = { 0 };
GValue dest = { 0 };
gchar *s;
/* canonicalise floating point string so we can handle framerate strings
* in the form "24.930" or "24,930" irrespective of the current locale */
s = g_strdup (media_attr);
g_strdelimit (s, ",", '.');
/* convert the float to a fraction */
g_value_init (&src, G_TYPE_DOUBLE);
g_value_set_double (&src, g_ascii_strtod (s, NULL));
g_value_init (&dest, GST_TYPE_FRACTION);
g_value_transform (&src, &dest);
rtpjpegdepay->frate_num = gst_value_get_fraction_numerator (&dest);
rtpjpegdepay->frate_denom = gst_value_get_fraction_denominator (&dest);
g_free (s);
}
return TRUE;
}
static void i3ipc_con_get_property(GObject *object, guint property_id, GValue *value, GParamSpec *pspec) {
i3ipcCon *self = I3IPC_CON(object);
switch (property_id)
{
case PROP_ID:
g_value_set_int(value, self->priv->id);
break;
case PROP_NAME:
g_value_set_string(value, self->priv->name);
break;
case PROP_BORDER:
g_value_set_string(value, self->priv->border);
break;
case PROP_CURRENT_BORDER_WIDTH:
g_value_set_int(value, self->priv->current_border_width);
break;
case PROP_LAYOUT:
g_value_set_string(value, self->priv->layout);
break;
case PROP_ORIENTATION:
g_value_set_string(value, self->priv->orientation);
break;
case PROP_PERCENT:
g_value_set_double(value, self->priv->percent);
break;
case PROP_WINDOW:
g_value_set_int(value, self->priv->window);
break;
case PROP_URGENT:
g_value_set_boolean(value, self->priv->urgent);
break;
case PROP_FOCUSED:
g_value_set_boolean(value, self->priv->focused);
break;
case PROP_FULLSCREEN_MODE:
g_value_set_boolean(value, self->priv->fullscreen_mode);
break;
case PROP_TYPE:
g_value_set_string(value, self->priv->type);
break;
case PROP_WINDOW_CLASS:
g_value_set_string(value, self->priv->window_class);
break;
case PROP_MARK:
g_value_set_string(value, self->priv->mark);
break;
case PROP_RECT:
g_value_set_boxed(value, self->priv->rect);
break;
case PROP_DECO_RECT:
g_value_set_boxed(value, self->priv->deco_rect);
break;
case PROP_PARENT:
g_value_set_object(value, self->priv->parent);
break;
case PROP_NODES:
g_value_set_pointer(value, self->priv->nodes);
break;
case PROP_FLOATING_NODES:
g_value_set_pointer(value, self->priv->floating_nodes);
break;
case PROP_FOCUS:
g_value_set_pointer(value, self->priv->focus);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
break;
}
}
static void
cheese_gconf_get_property (GObject *object, guint prop_id, GValue *value,
GParamSpec *pspec)
{
CheeseGConf *self;
self = CHEESE_GCONF (object);
CheeseGConfPrivate *priv = CHEESE_GCONF_GET_PRIVATE (self);
char *effects;
GSList *list, *tmp;
switch (prop_id)
{
case GCONF_PROP_COUNTDOWN:
g_value_set_boolean (value, gconf_client_get_bool (priv->client,
CHEESE_GCONF_PREFIX "/countdown",
NULL));
break;
case GCONF_PROP_FLASH:
g_value_set_boolean (value, gconf_client_get_bool (priv->client,
CHEESE_GCONF_PREFIX "/flash",
NULL));
break;
case GCONF_PROP_CAMERA:
g_value_set_string (value, gconf_client_get_string (priv->client,
CHEESE_GCONF_PREFIX "/camera",
NULL));
break;
case GCONF_PROP_SELECTED_EFFECTS:
effects = NULL;
list = gconf_client_get_list (priv->client,
CHEESE_GCONF_PREFIX "/selected_effects",
GCONF_VALUE_STRING,
NULL);
tmp = list;
while (tmp != NULL)
{
char *str = tmp->data;
int j;
str[0] = g_ascii_toupper (str[0]);
for (j = 1; j < g_utf8_strlen (str, -1); j++)
{
if (str[j] == '-')
{
str[j] = ' ';
str[j + 1] = g_ascii_toupper (str[j + 1]);
}
else if (str[j] == '_')
{
str[j] = '/';
str[j + 1] = g_ascii_toupper (str[j + 1]);
}
}
if (effects == NULL)
effects = g_strdup (str);
else
{
gchar *dummy = effects;
effects = g_strjoin (",", effects, str, NULL);
g_free (dummy);
}
g_free (tmp->data);
tmp = g_slist_next (tmp);
}
g_value_set_string (value, effects);
g_slist_free (list);
g_slist_free (tmp);
break;
case GCONF_PROP_X_RESOLUTION:
g_value_set_int (value, gconf_client_get_int (priv->client,
CHEESE_GCONF_PREFIX "/x_resolution",
NULL));
break;
case GCONF_PROP_Y_RESOLUTION:
g_value_set_int (value, gconf_client_get_int (priv->client,
CHEESE_GCONF_PREFIX "/y_resolution",
NULL));
break;
case GCONF_PROP_BRIGHTNESS:
if (!gconf_client_get (priv->client,
CHEESE_GCONF_PREFIX "/brightness",
NULL))
g_value_set_double (value, G_PARAM_SPEC_DOUBLE (pspec)->default_value);
else
g_value_set_double (value, gconf_client_get_float (priv->client,
CHEESE_GCONF_PREFIX "/brightness",
NULL));
break;
case GCONF_PROP_CONTRAST:
if (!gconf_client_get (priv->client,
CHEESE_GCONF_PREFIX "/contrast",
NULL))
g_value_set_double (value, G_PARAM_SPEC_DOUBLE (pspec)->default_value);
else
g_value_set_double (value, gconf_client_get_float (priv->client,
CHEESE_GCONF_PREFIX "/contrast",
NULL));
break;
case GCONF_PROP_SATURATION:
if (!gconf_client_get (priv->client,
CHEESE_GCONF_PREFIX "/saturation",
NULL))
g_value_set_double (value, G_PARAM_SPEC_DOUBLE (pspec)->default_value);
else
g_value_set_double (value, gconf_client_get_float (priv->client,
CHEESE_GCONF_PREFIX "/saturation",
NULL));
break;
case GCONF_PROP_HUE:
if (!gconf_client_get (priv->client,
CHEESE_GCONF_PREFIX "/hue",
NULL))
g_value_set_double (value, G_PARAM_SPEC_DOUBLE (pspec)->default_value);
else
g_value_set_double (value, gconf_client_get_float (priv->client,
CHEESE_GCONF_PREFIX "/hue",
NULL));
break;
case GCONF_PROP_VIDEO_PATH:
g_value_set_string (value, gconf_client_get_string (priv->client,
CHEESE_GCONF_PREFIX "/video_path",
NULL));
break;
case GCONF_PROP_PHOTO_PATH:
g_value_set_string (value, gconf_client_get_string (priv->client,
CHEESE_GCONF_PREFIX "/photo_path",
NULL));
break;
case GCONF_PROP_ENABLE_DELETE:
g_value_set_boolean (value, gconf_client_get_bool (priv->client,
CHEESE_GCONF_PREFIX "/enable_delete",
NULL));
break;
case GCONF_PROP_WIDE_MODE:
g_value_set_boolean (value, gconf_client_get_bool (priv->client,
CHEESE_GCONF_PREFIX "/wide_mode",
NULL));
break;
case GCONF_PROP_BURST_DELAY:
g_value_set_int (value, gconf_client_get_int (priv->client,
CHEESE_GCONF_PREFIX "/burst_delay",
NULL));
break;
case GCONF_PROP_BURST_REPEAT:
g_value_set_int (value, gconf_client_get_int (priv->client,
CHEESE_GCONF_PREFIX "/burst_repeat",
NULL));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
GimpValueArray *
plug_in_params_to_args (GParamSpec **pspecs,
gint n_pspecs,
GPParam *params,
gint n_params,
gboolean return_values,
gboolean full_copy)
{
GimpValueArray *args;
gint i;
g_return_val_if_fail ((pspecs != NULL && n_pspecs > 0) ||
(pspecs == NULL && n_pspecs == 0), NULL);
g_return_val_if_fail ((params != NULL && n_params > 0) ||
(params == NULL && n_params == 0), NULL);
args = gimp_value_array_new (n_params);
for (i = 0; i < n_params; i++)
{
GValue value = { 0, };
GType type;
gint count;
/* first get the fallback compat GType that matches the pdb type */
type = gimp_pdb_compat_arg_type_to_gtype (params[i].type);
/* then try to try to be more specific by looking at the param
* spec (return values have one additional value (the status),
* skip that, it's not in the array of param specs)
*/
if (i > 0 || ! return_values)
{
gint pspec_index = i;
if (return_values)
pspec_index--;
/* are there param specs left? */
if (pspec_index < n_pspecs)
{
GType pspec_gtype;
GimpPDBArgType pspec_arg_type;
pspec_gtype = G_PARAM_SPEC_VALUE_TYPE (pspecs[pspec_index]);
pspec_arg_type = gimp_pdb_compat_arg_type_from_gtype (pspec_gtype);
/* if the param spec's GType, mapped to a pdb type, matches
* the passed pdb type, use the param spec's GType
*/
if (pspec_arg_type == params[i].type)
type = pspec_gtype;
}
}
g_value_init (&value, type);
switch (gimp_pdb_compat_arg_type_from_gtype (type))
{
case GIMP_PDB_INT32:
if (G_VALUE_HOLDS_INT (&value))
g_value_set_int (&value, params[i].data.d_int32);
else if (G_VALUE_HOLDS_UINT (&value))
g_value_set_uint (&value, params[i].data.d_int32);
else if (G_VALUE_HOLDS_ENUM (&value))
g_value_set_enum (&value, params[i].data.d_int32);
else if (G_VALUE_HOLDS_BOOLEAN (&value))
g_value_set_boolean (&value, params[i].data.d_int32 ? TRUE : FALSE);
else
{
g_printerr ("%s: unhandled GIMP_PDB_INT32 type: %s\n",
G_STRFUNC, g_type_name (G_VALUE_TYPE (&value)));
g_return_val_if_reached (args);
}
break;
case GIMP_PDB_INT16:
g_value_set_int (&value, params[i].data.d_int16);
break;
case GIMP_PDB_INT8:
g_value_set_uint (&value, params[i].data.d_int8);
break;
case GIMP_PDB_FLOAT:
g_value_set_double (&value, params[i].data.d_float);
break;
case GIMP_PDB_STRING:
if (full_copy)
g_value_set_string (&value, params[i].data.d_string);
else
g_value_set_static_string (&value, params[i].data.d_string);
break;
case GIMP_PDB_INT32ARRAY:
count = g_value_get_int (gimp_value_array_index (args, i - 1));
if (full_copy)
gimp_value_set_int32array (&value,
params[i].data.d_int32array,
count);
else
gimp_value_set_static_int32array (&value,
params[i].data.d_int32array,
count);
break;
case GIMP_PDB_INT16ARRAY:
count = g_value_get_int (gimp_value_array_index (args, i - 1));
if (full_copy)
gimp_value_set_int16array (&value,
params[i].data.d_int16array,
count);
else
gimp_value_set_static_int16array (&value,
params[i].data.d_int16array,
count);
break;
case GIMP_PDB_INT8ARRAY:
count = g_value_get_int (gimp_value_array_index (args, i - 1));
if (full_copy)
gimp_value_set_int8array (&value,
params[i].data.d_int8array,
count);
else
gimp_value_set_static_int8array (&value,
params[i].data.d_int8array,
count);
break;
case GIMP_PDB_FLOATARRAY:
count = g_value_get_int (gimp_value_array_index (args, i - 1));
if (full_copy)
gimp_value_set_floatarray (&value,
params[i].data.d_floatarray,
count);
else
gimp_value_set_static_floatarray (&value,
params[i].data.d_floatarray,
count);
break;
case GIMP_PDB_STRINGARRAY:
count = g_value_get_int (gimp_value_array_index (args, i - 1));
if (full_copy)
gimp_value_set_stringarray (&value,
(const gchar **) params[i].data.d_stringarray,
count);
else
gimp_value_set_static_stringarray (&value,
(const gchar **) params[i].data.d_stringarray,
count);
break;
case GIMP_PDB_COLOR:
gimp_value_set_rgb (&value, ¶ms[i].data.d_color);
break;
case GIMP_PDB_ITEM:
g_value_set_int (&value, params[i].data.d_item);
break;
case GIMP_PDB_DISPLAY:
g_value_set_int (&value, params[i].data.d_display);
break;
case GIMP_PDB_IMAGE:
g_value_set_int (&value, params[i].data.d_image);
break;
case GIMP_PDB_LAYER:
g_value_set_int (&value, params[i].data.d_layer);
break;
case GIMP_PDB_CHANNEL:
g_value_set_int (&value, params[i].data.d_channel);
break;
case GIMP_PDB_DRAWABLE:
g_value_set_int (&value, params[i].data.d_drawable);
break;
case GIMP_PDB_SELECTION:
g_value_set_int (&value, params[i].data.d_selection);
break;
case GIMP_PDB_COLORARRAY:
count = g_value_get_int (gimp_value_array_index (args, i - 1));
if (full_copy)
gimp_value_set_colorarray (&value,
params[i].data.d_colorarray,
count);
else
gimp_value_set_static_colorarray (&value,
params[i].data.d_colorarray,
count);
break;
case GIMP_PDB_VECTORS:
g_value_set_int (&value, params[i].data.d_vectors);
break;
case GIMP_PDB_PARASITE:
if (full_copy)
g_value_set_boxed (&value, ¶ms[i].data.d_parasite);
else
g_value_set_static_boxed (&value, ¶ms[i].data.d_parasite);
break;
case GIMP_PDB_STATUS:
g_value_set_enum (&value, params[i].data.d_status);
break;
case GIMP_PDB_END:
break;
}
gimp_value_array_append (args, &value);
g_value_unset (&value);
}
return args;
}
gint
main (gint argc, gchar ** argv)
{
gint res = 1;
GstElement *src, *sink;
GstElement *bin;
GstController *ctrl;
GstInterpolationControlSource *csource1, *csource2;
GstClock *clock;
GstClockID clock_id;
GstClockReturn wait_ret;
GValue vol = { 0, };
gst_init (&argc, &argv);
gst_controller_init (&argc, &argv);
/* build pipeline */
bin = gst_pipeline_new ("pipeline");
clock = gst_pipeline_get_clock (GST_PIPELINE (bin));
src = gst_element_factory_make ("audiotestsrc", "gen_audio");
if (!src) {
GST_WARNING ("need audiotestsrc from gst-plugins-base");
goto Error;
}
sink = gst_element_factory_make ("autoaudiosink", "play_audio");
if (!sink) {
GST_WARNING ("need autoaudiosink from gst-plugins-base");
goto Error;
}
gst_bin_add_many (GST_BIN (bin), src, sink, NULL);
if (!gst_element_link (src, sink)) {
GST_WARNING ("can't link elements");
goto Error;
}
/* square wave
g_object_set (G_OBJECT(src), "wave", 1, NULL);
*/
/* add a controller to the source */
if (!(ctrl = gst_controller_new (G_OBJECT (src), "freq", "volume", NULL))) {
GST_WARNING ("can't control source element");
goto Error;
}
csource1 = gst_interpolation_control_source_new ();
csource2 = gst_interpolation_control_source_new ();
gst_controller_set_control_source (ctrl, "volume",
GST_CONTROL_SOURCE (csource1));
gst_controller_set_control_source (ctrl, "freq",
GST_CONTROL_SOURCE (csource2));
/* Set interpolation mode */
gst_interpolation_control_source_set_interpolation_mode (csource1,
GST_INTERPOLATE_LINEAR);
gst_interpolation_control_source_set_interpolation_mode (csource2,
GST_INTERPOLATE_LINEAR);
/* set control values */
g_value_init (&vol, G_TYPE_DOUBLE);
g_value_set_double (&vol, 0.0);
gst_interpolation_control_source_set (csource1, 0 * GST_SECOND, &vol);
g_value_set_double (&vol, 1.0);
gst_interpolation_control_source_set (csource1, 5 * GST_SECOND, &vol);
g_object_unref (csource1);
g_value_set_double (&vol, 220.0);
gst_interpolation_control_source_set (csource2, 0 * GST_SECOND, &vol);
g_value_set_double (&vol, 3520.0);
gst_interpolation_control_source_set (csource2, 3 * GST_SECOND, &vol);
g_value_set_double (&vol, 440.0);
gst_interpolation_control_source_set (csource2, 6 * GST_SECOND, &vol);
g_object_unref (csource2);
clock_id =
gst_clock_new_single_shot_id (clock,
gst_clock_get_time (clock) + (7 * GST_SECOND));
/* run for 7 seconds */
if (gst_element_set_state (bin, GST_STATE_PLAYING)) {
if ((wait_ret = gst_clock_id_wait (clock_id, NULL)) != GST_CLOCK_OK) {
GST_WARNING ("clock_id_wait returned: %d", wait_ret);
}
gst_element_set_state (bin, GST_STATE_NULL);
}
/* cleanup */
g_object_unref (G_OBJECT (ctrl));
gst_clock_id_unref (clock_id);
gst_object_unref (G_OBJECT (clock));
gst_object_unref (G_OBJECT (bin));
res = 0;
Error:
return (res);
}
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_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 GstMessage *
update_rms_from_buffer (GstVideoFrameAudioLevel * self, GstBuffer * inbuf)
{
GstMapInfo map;
guint8 *in_data;
gsize in_size;
gdouble CS;
guint i;
guint num_frames, frames;
guint num_int_samples = 0; /* number of interleaved samples
* ie. total count for all channels combined */
gint channels, rate, bps;
GValue v = G_VALUE_INIT;
GValue va = G_VALUE_INIT;
GValueArray *a;
GstStructure *s;
GstMessage *msg;
GstClockTime duration, running_time;
channels = GST_AUDIO_INFO_CHANNELS (&self->ainfo);
bps = GST_AUDIO_INFO_BPS (&self->ainfo);
rate = GST_AUDIO_INFO_RATE (&self->ainfo);
gst_buffer_map (inbuf, &map, GST_MAP_READ);
in_data = map.data;
in_size = map.size;
num_int_samples = in_size / bps;
GST_LOG_OBJECT (self, "analyzing %u sample frames at ts %" GST_TIME_FORMAT,
num_int_samples, GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (inbuf)));
g_return_val_if_fail (num_int_samples % channels == 0, NULL);
num_frames = num_int_samples / channels;
frames = num_frames;
duration = GST_FRAMES_TO_CLOCK_TIME (frames, rate);
if (num_frames > 0) {
for (i = 0; i < channels; ++i) {
self->process (in_data + (bps * i), num_int_samples, channels, &CS);
GST_LOG_OBJECT (self,
"[%d]: cumulative squares %lf, over %d samples/%d channels",
i, CS, num_int_samples, channels);
self->CS[i] += CS;
}
in_data += num_frames * bps;
self->total_frames += num_frames;
}
running_time =
self->first_time + gst_util_uint64_scale (self->total_frames, GST_SECOND,
rate);
a = g_value_array_new (channels);
s = gst_structure_new ("videoframe-audiolevel", "running-time", G_TYPE_UINT64,
running_time, "duration", G_TYPE_UINT64, duration, NULL);
g_value_init (&v, G_TYPE_DOUBLE);
g_value_init (&va, G_TYPE_VALUE_ARRAY);
for (i = 0; i < channels; i++) {
gdouble rms;
if (frames == 0 || self->CS[i] == 0) {
rms = 0; /* empty buffer */
} else {
rms = sqrt (self->CS[i] / frames);
}
self->CS[i] = 0.0;
g_value_set_double (&v, rms);
g_value_array_append (a, &v);
}
g_value_take_boxed (&va, a);
gst_structure_take_value (s, "rms", &va);
msg = gst_message_new_element (GST_OBJECT (self), s);
gst_buffer_unmap (inbuf, &map);
return msg;
}
static gboolean
trough_paging_cb (StScrollBar *self)
{
gfloat handle_pos, event_pos, tx, ty;
gdouble value;
gdouble page_increment;
gboolean ret;
gulong mode;
ClutterAnimation *a;
GValue v = { 0, };
ClutterTimeline *t;
if (self->priv->paging_event_no == 0)
{
/* Scroll on after initial timeout. */
mode = CLUTTER_EASE_OUT_CUBIC;
ret = FALSE;
self->priv->paging_event_no = 1;
self->priv->paging_source_id = g_timeout_add (
PAGING_INITIAL_REPEAT_TIMEOUT,
(GSourceFunc) trough_paging_cb,
self);
g_source_set_name_by_id (self->priv->paging_source_id, "[gnome-shell] trough_paging_cb");
}
else if (self->priv->paging_event_no == 1)
{
/* Scroll on after subsequent timeout. */
ret = FALSE;
mode = CLUTTER_EASE_IN_CUBIC;
self->priv->paging_event_no = 2;
self->priv->paging_source_id = g_timeout_add (
PAGING_SUBSEQUENT_REPEAT_TIMEOUT,
(GSourceFunc) trough_paging_cb,
self);
g_source_set_name_by_id (self->priv->paging_source_id, "[gnome-shell] trough_paging_cb");
}
else
{
/* Keep scrolling. */
ret = TRUE;
mode = CLUTTER_LINEAR;
self->priv->paging_event_no++;
}
/* Do the scrolling */
st_adjustment_get_values (self->priv->adjustment,
&value, NULL, NULL,
NULL, &page_increment, NULL);
if (self->priv->vertical)
handle_pos = clutter_actor_get_y (self->priv->handle);
else
handle_pos = clutter_actor_get_x (self->priv->handle);
clutter_actor_transform_stage_point (CLUTTER_ACTOR (self->priv->trough),
self->priv->move_x,
self->priv->move_y,
&tx, &ty);
if (self->priv->vertical)
event_pos = ty;
else
event_pos = tx;
if (event_pos > handle_pos)
{
if (self->priv->paging_direction == NONE)
{
/* Remember direction. */
self->priv->paging_direction = DOWN;
}
if (self->priv->paging_direction == UP)
{
/* Scrolled far enough. */
return FALSE;
}
value += page_increment;
}
else
{
if (self->priv->paging_direction == NONE)
{
/* Remember direction. */
self->priv->paging_direction = UP;
}
if (self->priv->paging_direction == DOWN)
{
/* Scrolled far enough. */
return FALSE;
}
value -= page_increment;
}
if (self->priv->paging_animation)
{
clutter_animation_completed (self->priv->paging_animation);
}
/* FIXME: Creating a new animation for each scroll is probably not the best
* idea, but it's a lot less involved than extenind the current animation */
a = self->priv->paging_animation = g_object_new (CLUTTER_TYPE_ANIMATION,
"object", self->priv->adjustment,
"duration", (guint)(PAGING_SUBSEQUENT_REPEAT_TIMEOUT * st_slow_down_factor),
"mode", mode,
NULL);
g_value_init (&v, G_TYPE_DOUBLE);
g_value_set_double (&v, value);
clutter_animation_bind (self->priv->paging_animation, "value", &v);
t = clutter_animation_get_timeline (self->priv->paging_animation);
g_signal_connect (a, "completed", G_CALLBACK (animation_completed_cb),
self->priv);
clutter_timeline_start (t);
return ret;
}
static void
test_copying (void)
{
GValue value = { 0, };
gchar *error;
{
gchar c = 0;
g_value_init (&value, G_TYPE_CHAR);
g_value_set_char (&value, 'c');
error = lcopy (&value, &c);
g_assert (error == NULL);
g_assert (c == 'c');
}
{
guchar c = 0;
g_value_unset (&value);
g_value_init (&value, G_TYPE_UCHAR);
g_value_set_uchar (&value, 129);
error = lcopy (&value, &c);
g_assert (error == NULL);
g_assert (c == 129);
}
{
gint c = 0;
g_value_unset (&value);
g_value_init (&value, G_TYPE_INT);
g_value_set_int (&value, G_MAXINT);
error = lcopy (&value, &c);
g_assert (error == NULL);
g_assert (c == G_MAXINT);
}
{
guint c = 0;
g_value_unset (&value);
g_value_init (&value, G_TYPE_UINT);
g_value_set_uint (&value, G_MAXUINT);
error = lcopy (&value, &c);
g_assert (error == NULL);
g_assert (c == G_MAXUINT);
}
{
glong c = 0;
g_value_unset (&value);
g_value_init (&value, G_TYPE_LONG);
g_value_set_long (&value, G_MAXLONG);
error = lcopy (&value, &c);
g_assert (error == NULL);
g_assert (c == G_MAXLONG);
}
{
gulong c = 0;
g_value_unset (&value);
g_value_init (&value, G_TYPE_ULONG);
g_value_set_ulong (&value, G_MAXULONG);
error = lcopy (&value, &c);
g_assert (error == NULL);
g_assert (c == G_MAXULONG);
}
{
gint64 c = 0;
g_value_unset (&value);
g_value_init (&value, G_TYPE_INT64);
g_value_set_int64 (&value, G_MAXINT64);
error = lcopy (&value, &c);
g_assert (error == NULL);
g_assert (c == G_MAXINT64);
}
{
guint64 c = 0;
g_value_unset (&value);
g_value_init (&value, G_TYPE_UINT64);
g_value_set_uint64 (&value, G_MAXUINT64);
error = lcopy (&value, &c);
g_assert (error == NULL);
g_assert (c == G_MAXUINT64);
}
{
gfloat c = 0;
g_value_unset (&value);
g_value_init (&value, G_TYPE_FLOAT);
g_value_set_float (&value, G_MAXFLOAT);
error = lcopy (&value, &c);
g_assert (error == NULL);
g_assert (c == G_MAXFLOAT);
}
{
gdouble c = 0;
g_value_unset (&value);
g_value_init (&value, G_TYPE_DOUBLE);
g_value_set_double (&value, G_MAXDOUBLE);
error = lcopy (&value, &c);
g_assert (error == NULL);
g_assert (c == G_MAXDOUBLE);
}
{
gchar *c = NULL;
g_value_unset (&value);
g_value_init (&value, G_TYPE_STRING);
g_value_set_string (&value, "string ?");
error = lcopy (&value, &c);
g_assert (error == NULL);
g_assert (strcmp (c, "string ?") == 0);
}
{
GType c = G_TYPE_NONE;
g_value_unset (&value);
g_value_init (&value, G_TYPE_GTYPE);
g_value_set_gtype (&value, G_TYPE_BOXED);
error = lcopy (&value, &c);
g_assert (error == NULL);
g_assert (c == G_TYPE_BOXED);
}
}
static void
gimp_text_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec)
{
GimpText *text = GIMP_TEXT (object);
switch (property_id)
{
case PROP_TEXT:
g_value_set_string (value, text->text);
break;
case PROP_MARKUP:
g_value_set_string (value, text->markup);
break;
case PROP_FONT:
g_value_set_string (value, text->font);
break;
case PROP_FONT_SIZE:
g_value_set_double (value, text->font_size);
break;
case PROP_UNIT:
g_value_set_int (value, text->unit);
break;
case PROP_ANTIALIAS:
g_value_set_boolean (value, text->antialias);
break;
case PROP_HINT_STYLE:
g_value_set_enum (value, text->hint_style);
break;
case PROP_KERNING:
g_value_set_boolean (value, text->kerning);
break;
case PROP_BASE_DIR:
g_value_set_enum (value, text->base_dir);
break;
case PROP_LANGUAGE:
g_value_set_string (value, text->language);
break;
case PROP_COLOR:
g_value_set_boxed (value, &text->color);
break;
case PROP_OUTLINE:
g_value_set_enum (value, text->outline);
break;
case PROP_JUSTIFICATION:
g_value_set_enum (value, text->justify);
break;
case PROP_INDENTATION:
g_value_set_double (value, text->indent);
break;
case PROP_LINE_SPACING:
g_value_set_double (value, text->line_spacing);
break;
case PROP_LETTER_SPACING:
g_value_set_double (value, text->letter_spacing);
break;
case PROP_BOX_MODE:
g_value_set_enum (value, text->box_mode);
break;
case PROP_BOX_WIDTH:
g_value_set_double (value, text->box_width);
break;
case PROP_BOX_HEIGHT:
g_value_set_double (value, text->box_height);
break;
case PROP_BOX_UNIT:
g_value_set_int (value, text->box_unit);
break;
case PROP_TRANSFORMATION:
g_value_set_boxed (value, &text->transformation);
break;
case PROP_OFFSET_X:
g_value_set_double (value, text->offset_x);
break;
case PROP_OFFSET_Y:
g_value_set_double (value, text->offset_y);
break;
case PROP_HINTING:
g_value_set_boolean (value,
text->hint_style != GIMP_TEXT_HINT_STYLE_NONE);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
gboolean
pgm_query_get_gvalue( PgmQuery *query, gint row, gint column, GValue *gvalue )
{
GType type;
gchar *value;
g_return_val_if_fail( query != NULL, FALSE );
g_return_val_if_fail( column >= 0, FALSE );
g_return_val_if_fail( column < pgm_query_get_columns( query ), FALSE );
g_return_val_if_fail( row >= 0, FALSE );
g_return_val_if_fail( row < pgm_query_get_rows( query ), FALSE );
type = pgm_query_get_column_gtype( query, column );
g_value_init( gvalue, type );
value = PQgetvalue( query->result, row, column );
if( PQgetisnull( query->result, row, column ) )
return TRUE;
switch( type )
{
case G_TYPE_BOOLEAN:
{
if( value[ 0 ] == 't' )
g_value_set_boolean( gvalue, TRUE );
else
g_value_set_boolean( gvalue, FALSE );
break;
}
case G_TYPE_INT:
{
int val = (int)g_strtod( value, NULL );
g_value_set_int( gvalue, val );
break;
}
case G_TYPE_LONG:
{
long val = (long)g_strtod( value, NULL );
g_value_set_long( gvalue, val );
break;
}
case G_TYPE_ULONG:
{
unsigned long val = (unsigned long)g_strtod( value, NULL );
g_value_set_ulong( gvalue, val );
break;
}
case G_TYPE_DOUBLE:
{
double val = g_strtod( value, NULL );
g_value_set_double( gvalue, val );
break;
}
case G_TYPE_FLOAT:
{
float val = (float)g_strtod( value, NULL );
g_value_set_float( gvalue, val );
}
default:
{
g_value_set_string( gvalue, value );
}
}
return TRUE;
}
static void
gst_pocketsphinx_get_property(GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec)
{
GstPocketSphinx *ps = GST_POCKETSPHINX(object);
switch (prop_id) {
case PROP_DECODER:
g_value_set_boxed(value, ps->ps);
break;
case PROP_CONFIGURED:
g_value_set_boolean(value, ps->ps != NULL);
break;
case PROP_HMM_DIR:
g_value_set_string(value, cmd_ln_str_r(ps->config, "-hmm"));
break;
case PROP_LM_FILE:
g_value_set_string(value, cmd_ln_str_r(ps->config, "-lm"));
break;
case PROP_LMCTL_FILE:
g_value_set_string(value, cmd_ln_str_r(ps->config, "-lmctl"));
break;
case PROP_LM_NAME:
g_value_set_string(value, cmd_ln_str_r(ps->config, "-lmname"));
break;
case PROP_DICT_FILE:
g_value_set_string(value, cmd_ln_str_r(ps->config, "-dict"));
break;
case PROP_MLLR_FILE:
g_value_set_string(value, cmd_ln_str_r(ps->config, "-mllr"));
break;
case PROP_FSG_FILE:
g_value_set_string(value, cmd_ln_str_r(ps->config, "-fsg"));
break;
case PROP_FWDFLAT:
g_value_set_boolean(value, cmd_ln_boolean_r(ps->config, "-fwdflat"));
break;
case PROP_BESTPATH:
g_value_set_boolean(value, cmd_ln_boolean_r(ps->config, "-bestpath"));
break;
case PROP_LATDIR:
g_value_set_string(value, ps->latdir);
break;
case PROP_LATTICE: {
ps_lattice_t *dag;
if (ps->ps && (dag = ps_get_lattice(ps->ps)))
g_value_set_boxed(value, dag);
else
g_value_set_boxed(value, NULL);
break;
}
case PROP_MAXHMMPF:
g_value_set_int(value, cmd_ln_int32_r(ps->config, "-maxhmmpf"));
break;
case PROP_MAXWPF:
g_value_set_int(value, cmd_ln_int32_r(ps->config, "-maxwpf"));
break;
case PROP_BEAM:
g_value_set_double(value, cmd_ln_float_r(ps->config, "-beam"));
break;
case PROP_PBEAM:
g_value_set_double(value, cmd_ln_float_r(ps->config, "-pbeam"));
break;
case PROP_WBEAM:
g_value_set_double(value, cmd_ln_float_r(ps->config, "-wbeam"));
break;
case PROP_DSRATIO:
g_value_set_int(value, cmd_ln_int32_r(ps->config, "-ds"));
break;
case PROP_NBEST_SIZE:
g_value_set_int(value, ps->n_best_size);
break;
case PROP_NBEST: {
int i = 0, out_score = 0;
GValueArray *arr;
if (!ps->ps) {
break;
}
arr = g_value_array_new(1);
ps_nbest_t *ps_nbest_list = ps_nbest(ps->ps, 0, -1, NULL, NULL);
if (ps_nbest_list) {
ps_nbest_list = ps_nbest_next(ps_nbest_list);
while ((i < ps->n_best_size) && (ps_nbest_list != NULL)) {
GValue value1 = { 0 };
g_value_init (&value1, G_TYPE_STRING);
const char* hyp = ps_nbest_hyp(ps_nbest_list, &out_score);
g_value_set_string(&value1, hyp);
g_value_array_append(arr, &value1);
ps_nbest_list = ps_nbest_next(ps_nbest_list);
i++;
}
if (ps_nbest_list) {
ps_nbest_free(ps_nbest_list);
}
}
g_value_set_boxed (value, arr);
break;
}
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
break;
}
}
/**
* 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_LUMINOSITY:
g_value_set_double (value, device->priv->luminosity);
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_TEMPERATURE:
g_value_set_double (value, device->priv->temperature);
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;
}
}
