static void
gimp_operation_tool_relink_chains (GimpOperationTool *op_tool)
{
GimpFilterTool *filter_tool = GIMP_FILTER_TOOL (op_tool);
GObject *options_gui = g_weak_ref_get (&op_tool->options_gui_ref);
GList *chains;
g_return_if_fail (options_gui != NULL);
chains = g_object_get_data (options_gui, "chains");
while (chains)
{
GimpChainButton *chain = chains->data;
if (g_object_get_data (G_OBJECT (chain), "was-active"))
{
const gchar *name_x = g_object_get_data (chains->data, "x-property");
const gchar *name_y = g_object_get_data (chains->data, "y-property");
const gchar *names[2] = { name_x, name_y };
GValue values[2] = { G_VALUE_INIT, G_VALUE_INIT };
GValue double_x = G_VALUE_INIT;
GValue double_y = G_VALUE_INIT;
g_object_getv (filter_tool->config, 2, names, values);
g_value_init (&double_x, G_TYPE_DOUBLE);
g_value_init (&double_y, G_TYPE_DOUBLE);
if (g_value_transform (&values[0], &double_x) &&
g_value_transform (&values[1], &double_y) &&
g_value_get_double (&double_x) ==
g_value_get_double (&double_y))
{
gimp_chain_button_set_active (chain, TRUE);
g_signal_emit_by_name (chain, "toggled");
}
g_value_unset (&double_x);
g_value_unset (&double_y);
g_value_unset (&values[0]);
g_value_unset (&values[1]);
g_object_set_data (G_OBJECT (chain), "was-active", NULL);
}
chains = chains->next;
}
g_object_unref (options_gui);
}
gboolean
ghb_value_boolean(const GValue *val)
{
gboolean result;
if (val == NULL) return FALSE;
GValue xform = {0,};
if (G_VALUE_TYPE(val) != G_TYPE_BOOLEAN)
{
g_value_init(&xform, G_TYPE_BOOLEAN);
if (!g_value_transform(val, &xform))
{
debug_show_type(G_VALUE_TYPE(val));
g_warning("boolean can't transform");
return FALSE;
}
result = g_value_get_boolean(&xform);
g_value_unset(&xform);
}
else
{
result = g_value_get_boolean(val);
}
return result;
}
gchar*
ghb_value_string(const GValue *val)
{
gchar *result;
if (val == NULL) return 0;
GValue xform = {0,};
if (G_VALUE_TYPE(val) != G_TYPE_STRING)
{
g_value_init(&xform, G_TYPE_STRING);
if (!g_value_transform(val, &xform))
{
debug_show_type(G_VALUE_TYPE(val));
g_warning("string can't transform");
return NULL;
}
result = g_strdup(g_value_get_string(&xform));
g_value_unset(&xform);
}
else
{
result = g_strdup(g_value_get_string(val));
}
return result;
}
gdouble
ghb_value_double(const GValue *val)
{
gdouble result;
if (val == NULL) return 0;
GValue xform = {0,};
if (G_VALUE_TYPE(val) != G_TYPE_DOUBLE)
{
g_value_init(&xform, G_TYPE_DOUBLE);
if (!g_value_transform(val, &xform))
{
debug_show_type(G_VALUE_TYPE(val));
g_warning("double can't transform");
return 0;
}
result = g_value_get_double(&xform);
g_value_unset(&xform);
}
else
{
result = g_value_get_double(val);
}
return result;
}
gint64
ghb_value_int64(const GValue *val)
{
gint64 result;
if (val == NULL) return 0;
GValue xform = {0,};
if (G_VALUE_TYPE(val) != G_TYPE_INT64)
{
g_value_init(&xform, G_TYPE_INT64);
if (!g_value_transform(val, &xform))
{
debug_show_type(G_VALUE_TYPE(val));
g_warning("int64 can't transform");
return 0;
}
result = g_value_get_int64(&xform);
g_value_unset(&xform);
}
else
{
result = g_value_get_int64(val);
}
return result;
}
static gboolean
_append_extra_header (GQuark field_id, const GValue * value, gpointer user_data)
{
GstSoupHTTPSrc *src = GST_SOUP_HTTP_SRC (user_data);
const gchar *field_name = g_quark_to_string (field_id);
gchar *field_content = NULL;
if (G_VALUE_TYPE (value) == G_TYPE_STRING) {
field_content = g_value_dup_string (value);
} else {
GValue dest = { 0, };
g_value_init (&dest, G_TYPE_STRING);
if (g_value_transform (value, &dest)) {
field_content = g_value_dup_string (&dest);
}
}
if (field_content == NULL) {
GST_ERROR_OBJECT (src, "extra-headers field '%s' contains no value "
"or can't be converted to a string", field_name);
return FALSE;
}
GST_DEBUG_OBJECT (src, "Appending extra header: \"%s: %s\"", field_name,
field_content);
soup_message_headers_append (src->msg->request_headers, field_name,
field_content);
g_free (field_content);
return TRUE;
}
static void
gst_egl_sink_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec)
{
GstEGLSink *egl_sink;
g_return_if_fail (GST_IS_EGL_SINK (object));
egl_sink = GST_EGL_SINK (object);
switch (prop_id) {
case ARG_DISPLAY:
g_value_set_string (value, egl_sink->display_name);
break;
case PROP_FORCE_ASPECT_RATIO:
g_value_set_boolean (value, egl_sink->keep_aspect_ratio);
break;
case PROP_PIXEL_ASPECT_RATIO:
if (egl_sink->par)
g_value_transform (egl_sink->par, value);
else
g_value_set_static_string(value, "1/1");
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
/********************
* fact_field_value
********************/
static char *
fact_field_value(OhmFact *fact, char *field, char *buf, size_t size)
{
GValue *value, gstr = {0,};
if ((value = ohm_fact_get(fact, field)) == NULL)
return NULL;
if (G_VALUE_HOLDS_STRING(value)) {
snprintf(buf, size, (char *)g_value_get_string(value));
return buf;
}
if (!g_value_type_transformable(G_VALUE_TYPE(value), G_TYPE_STRING))
return NULL;
g_value_init(&gstr, G_TYPE_STRING);
if (!g_value_transform(value, &gstr))
return NULL;
snprintf(buf, size, "%s", g_value_get_string(&gstr));
g_value_unset(&gstr);
return buf;
}
void remote_client_send_param (RemoteClient* self,
ParameterHolder* ph,
const gchar* name)
{
/* Serialize one parameter value, and send it to the server */
GValue val, strval;
const gchar* string;
GParamSpec *spec = g_object_class_find_property(G_OBJECT_GET_CLASS(ph), name);
g_assert(spec != NULL);
memset(&val, 0, sizeof(val));
g_value_init(&val, spec->value_type);
g_object_get_property(G_OBJECT(ph), name, &val);
memset(&strval, 0, sizeof(strval));
g_value_init(&strval, G_TYPE_STRING);
g_value_transform(&val, &strval);
string = g_value_get_string(&strval);
/* 'string' will be NULL if the value couldn't be serialized- currently
* this happens for colors, since we get the GdkColor property rather than
* the corresponding string property. Currently this isn't a problem since
* render nodes don't deal with colors, but it's something to be aware of.
*/
if (string) {
self->pending_param_changes++;
remote_client_command(self, set_param_callback, NULL, "set_param %s = %s",
name, string);
}
g_value_unset(&strval);
g_value_unset(&val);
}
static gchar *
g_value_to_string (const GValue * val)
{
if (G_VALUE_TYPE (val) == GST_TYPE_BUFFER) {
GstBuffer *buf = gst_value_get_buffer (val);
GstMapInfo map;
gchar *ret;
gst_buffer_map (buf, &map, GST_MAP_READ);
ret = g_base64_encode (map.data, map.size);
gst_buffer_unmap (buf, &map);
return ret;
} else {
GValue s = { 0, };
gchar *ret;
g_value_init (&s, G_TYPE_STRING);
if (!g_value_transform (val, &s)) {
return NULL;
}
ret = g_value_dup_string (&s);
g_value_unset (&s);
return ret;
}
}
static gboolean
gdk_x11_screen_get_setting (GdkScreen *screen,
const gchar *name,
GValue *value)
{
GdkX11Screen *x11_screen = GDK_X11_SCREEN (screen);
const GValue *setting;
if (x11_screen->xsettings == NULL)
goto out;
setting = g_hash_table_lookup (x11_screen->xsettings, name);
if (setting == NULL)
goto out;
if (!g_value_transform (setting, value))
{
g_warning ("Cannot transform xsetting %s of type %s to type %s\n",
name,
g_type_name (G_VALUE_TYPE (setting)),
g_type_name (G_VALUE_TYPE (value)));
goto out;
}
return TRUE;
out:
return _gdk_x11_get_xft_setting (screen, name, value);
}
void notified (GObject *gobject, GParamSpec *pspec,
gpointer user_data)
{
GValue value = { 0, };
GValue strvalue = { 0, };
g_return_if_fail (gobject != NULL);
g_return_if_fail (pspec != NULL);
g_value_init (&value, pspec->value_type);
g_value_init (&strvalue, G_TYPE_STRING);
g_object_get_property (gobject, pspec->name, &value);
if (pspec->value_type == G_TYPE_STRV) {
gchar** p = (gchar **)g_value_get_boxed (&value);
g_message ("notify::%s == ", pspec->name);
while (*p)
g_message ("%s", *p++);
} else if (G_TYPE_IS_OBJECT(pspec->value_type)) {
GObject *o = g_value_get_object (&value);
g_message ("notify::%s == %s", pspec->name, o ? G_OBJECT_TYPE_NAME (o) : "null");
} else {
g_value_transform (&value, &strvalue);
g_message ("notify::%s = %s", pspec->name, g_value_get_string (&strvalue));
}
g_value_unset (&value);
g_value_unset (&strvalue);
}
static void
gst_glimage_sink_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec)
{
GstGLImageSink *glimage_sink;
g_return_if_fail (GST_IS_GLIMAGE_SINK (object));
glimage_sink = GST_GLIMAGE_SINK (object);
switch (prop_id) {
case ARG_DISPLAY:
g_value_set_string (value, glimage_sink->display_name);
break;
case PROP_FORCE_ASPECT_RATIO:
g_value_set_boolean (value, glimage_sink->keep_aspect_ratio);
break;
case PROP_PIXEL_ASPECT_RATIO:
if (!glimage_sink->par) {
glimage_sink->par = g_new0 (GValue, 1);
g_value_init (glimage_sink->par, GST_TYPE_FRACTION);
gst_value_set_fraction (glimage_sink->par, 1, 1);
}
if (!g_value_transform (glimage_sink->par, value))
g_warning ("Could not transform string to aspect ratio");
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
void print_tree_selection(GtkTreeModel *model,
GtkTreePath *path,
GtkTreeIter *iter,
gpointer data)
{
gint columns = gtk_tree_model_get_n_columns(model);
// Print the path of the selection
g_printf("\t%s", gtk_tree_path_to_string(path));
// Print all the text columns
for (gint i = 0; i < columns; ++i) {
GValue value = {0};
GValue str_value = {0};
gtk_tree_model_get_value(model, iter, i, &value);
g_value_init(&str_value, G_TYPE_STRING);
if (g_value_type_transformable(G_VALUE_TYPE(&value), G_TYPE_STRING)) {
g_value_transform(&value, &str_value);
g_printf("\t%s", g_value_get_string(&str_value));
}
g_value_unset(&value);
}
}
static void
gst_vdp_sink_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec)
{
VdpSink *vdp_sink;
g_return_if_fail (GST_IS_VDP_SINK (object));
vdp_sink = GST_VDP_SINK (object);
switch (prop_id) {
case PROP_DISPLAY:
g_value_set_string (value, vdp_sink->display_name);
break;
case PROP_SYNCHRONOUS:
g_value_set_boolean (value, vdp_sink->synchronous);
break;
case PROP_PIXEL_ASPECT_RATIO:
if (vdp_sink->par)
g_value_transform (vdp_sink->par, value);
break;
case PROP_HANDLE_EVENTS:
g_value_set_boolean (value, vdp_sink->handle_events);
break;
case PROP_HANDLE_EXPOSE:
g_value_set_boolean (value, vdp_sink->handle_expose);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static GTokenType
gimp_config_deserialize_any (GValue *value,
GParamSpec *prop_spec,
GScanner *scanner)
{
GValue src = { 0, };
if (!g_value_type_transformable (G_TYPE_STRING, prop_spec->value_type))
{
g_warning ("%s: %s can not be transformed from a string",
G_STRFUNC, g_type_name (prop_spec->value_type));
return G_TOKEN_NONE;
}
if (g_scanner_peek_next_token (scanner) != G_TOKEN_IDENTIFIER)
return G_TOKEN_IDENTIFIER;
g_scanner_get_next_token (scanner);
g_value_init (&src, G_TYPE_STRING);
g_value_set_static_string (&src, scanner->value.v_identifier);
g_value_transform (&src, value);
g_value_unset (&src);
return G_TOKEN_RIGHT_PAREN;
}
static void
egg_property_cell_renderer_spin_edited_cb (GtkCellRendererText *renderer,
gchar *path,
gchar *new_text,
gpointer user_data)
{
EggPropertyCellRendererPrivate *priv;
gchar *prop_name;
priv = (EggPropertyCellRendererPrivate *) user_data;
prop_name = get_prop_name_from_tree_model (GTK_TREE_MODEL (priv->list_store), path);
if (prop_name != NULL) {
GParamSpec *pspec;
GValue from = { 0 };
GValue to = { 0 };
pspec = get_pspec_from_object (priv->object, prop_name);
g_value_init (&from, G_TYPE_DOUBLE);
g_value_init (&to, pspec->value_type);
g_value_set_double (&from, strtod (new_text, NULL));
if (g_value_transform (&from, &to))
g_object_set_property (priv->object, prop_name, &to);
else
g_warning ("Could not transform %s to %s\n",
g_value_get_string (&from), g_type_name (pspec->value_type));
g_free (prop_name);
}
}
static gchar *
g_value_to_string (const GValue * val)
{
if (G_VALUE_TYPE (val) == GST_TYPE_BUFFER) {
#if GLIB_CHECK_VERSION (2,16,0)
const GstBuffer *buf = gst_value_get_buffer (val);
gchar *ret = g_base64_encode (GST_BUFFER_DATA (buf), GST_BUFFER_SIZE (buf));
#else
gchar *ret = gst_value_serialize (val);
#endif
return ret;
} else {
GValue s = { 0, };
gchar *ret;
g_value_init (&s, G_TYPE_STRING);
if (!g_value_transform (val, &s)) {
return NULL;
}
ret = g_value_dup_string (&s);
g_value_unset (&s);
return ret;
}
}
static void
gst_egl_sink_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec)
{
GstEGLSink *egl_sink;
g_return_if_fail (GST_IS_EGL_SINK (object));
egl_sink = GST_EGL_SINK (object);
switch (prop_id) {
case ARG_DISPLAY:
{
g_free (egl_sink->display_name);
egl_sink->display_name = g_strdup (g_value_get_string (value));
break;
}
case PROP_CLIENT_SET_CAPS_CALLBACK:
{
egl_sink->set_caps_callback = g_value_get_pointer (value);
break;
}
case PROP_CLIENT_GET_BUFFER_CALLBACK:
{
egl_sink->get_buffer_callback = g_value_get_pointer (value);
break;
}
case PROP_CLIENT_DRAW_CALLBACK:
{
egl_sink->draw_callback = g_value_get_pointer (value);
break;
}
case PROP_CLIENT_DATA:
{
egl_sink->client_data = g_value_get_pointer (value);
break;
}
case PROP_FORCE_ASPECT_RATIO:
{
egl_sink->keep_aspect_ratio = g_value_get_boolean (value);
break;
}
case PROP_PIXEL_ASPECT_RATIO:
{
g_free (egl_sink->par);
egl_sink->par = g_new0 (GValue, 1);
g_value_init (egl_sink->par, GST_TYPE_FRACTION);
if (!g_value_transform (value, egl_sink->par)) {
g_warning ("Could not transform string to aspect ratio");
gst_value_set_fraction (egl_sink->par, 1, 1);
}
break;
}
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static GimpValueArray *
file_save_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GimpValueArray *args,
GError **error)
{
GimpValueArray *new_args;
GimpValueArray *return_vals;
GimpPlugInProcedure *file_proc;
GimpProcedure *proc;
gchar *uri;
gint i;
uri = file_utils_filename_to_uri (gimp,
g_value_get_string (gimp_value_array_index (args, 3)),
error);
if (! uri)
return gimp_procedure_get_return_values (procedure, FALSE,
error ? *error : NULL);
file_proc =
file_procedure_find (gimp->plug_in_manager->save_procs, uri, NULL);
if (! file_proc)
file_proc = file_procedure_find (gimp->plug_in_manager->export_procs, uri, error);
g_free (uri);
if (! file_proc)
return gimp_procedure_get_return_values (procedure, FALSE,
error ? *error : NULL);
proc = GIMP_PROCEDURE (file_proc);
new_args = gimp_procedure_get_arguments (proc);
for (i = 0; i < 5; i++)
g_value_transform (gimp_value_array_index (args, i),
gimp_value_array_index (new_args, i));
for (i = 5; i < proc->num_args; i++)
if (G_IS_PARAM_SPEC_STRING (proc->args[i]))
g_value_set_static_string (gimp_value_array_index (new_args, i), "");
return_vals =
gimp_pdb_execute_procedure_by_name_args (gimp->pdb,
context, progress, error,
gimp_object_get_name (proc),
new_args);
gimp_value_array_unref (new_args);
return return_vals;
}
/* Print header, or parts of header.
*/
static int
print_header( IMAGE *im, gboolean many )
{
if( !main_option_field ) {
printf( "%s: ", im->filename );
vips_object_print_summary( VIPS_OBJECT( im ) );
if( main_option_all )
(void) vips_image_map( im, print_field_fn, &many );
}
else if( strcmp( main_option_field, "getext" ) == 0 ) {
if( im__has_extension_block( im ) ) {
void *buf;
int size;
if( !(buf = im__read_extension_block( im, &size )) )
return( -1 );
printf( "%s", (char *) buf );
im_free( buf );
}
}
else if( strcmp( main_option_field, "Hist" ) == 0 )
printf( "%s", im_history_get( im ) );
else {
GValue value = { 0 };
GType type;
if( im_header_get( im, main_option_field, &value ) )
return( -1 );
/* Display the save form, if there is one. This way we display
* something useful for ICC profiles, xml fields, etc.
*/
type = G_VALUE_TYPE( &value );
if( g_value_type_transformable( type, IM_TYPE_SAVE_STRING ) ) {
GValue save_value = { 0 };
g_value_init( &save_value, IM_TYPE_SAVE_STRING );
if( !g_value_transform( &value, &save_value ) )
return( -1 );
printf( "%s\n", im_save_string_get( &save_value ) );
g_value_unset( &save_value );
}
else {
char *str_value;
str_value = g_strdup_value_contents( &value );
printf( "%s\n", str_value );
g_free( str_value );
}
g_value_unset( &value );
}
return( 0 );
}
static void
gst_vdp_sink_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec)
{
VdpSink *vdp_sink;
g_return_if_fail (GST_IS_VDP_SINK (object));
vdp_sink = GST_VDP_SINK (object);
switch (prop_id) {
case PROP_DISPLAY:
vdp_sink->display_name = g_strdup (g_value_get_string (value));
break;
case PROP_SYNCHRONOUS:
vdp_sink->synchronous = g_value_get_boolean (value);
if (vdp_sink->device) {
GST_DEBUG_OBJECT (vdp_sink, "XSynchronize called with %s",
vdp_sink->synchronous ? "TRUE" : "FALSE");
g_mutex_lock (vdp_sink->x_lock);
XSynchronize (vdp_sink->device->display, vdp_sink->synchronous);
g_mutex_unlock (vdp_sink->x_lock);
}
break;
case PROP_PIXEL_ASPECT_RATIO:
{
GValue *tmp;
tmp = g_new0 (GValue, 1);
g_value_init (tmp, GST_TYPE_FRACTION);
if (!g_value_transform (value, tmp)) {
GST_WARNING_OBJECT (vdp_sink,
"Could not transform string to aspect ratio");
g_free (tmp);
} else {
GST_DEBUG_OBJECT (vdp_sink, "set PAR to %d/%d",
gst_value_get_fraction_numerator (tmp),
gst_value_get_fraction_denominator (tmp));
g_free (vdp_sink->par);
vdp_sink->par = tmp;
}
}
break;
case PROP_HANDLE_EVENTS:
gst_vdp_sink_set_event_handling (GST_X_OVERLAY (vdp_sink),
g_value_get_boolean (value));
break;
case PROP_HANDLE_EXPOSE:
vdp_sink->handle_expose = g_value_get_boolean (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
test_enum_transformation (void)
{
GType type;
GValue orig = { 0, };
GValue xform = { 0, };
GEnumValue values[] = { {0,"0","0"}, {1,"1","1"}};
type = g_enum_register_static ("TestEnum", values);
g_value_init (&orig, type);
g_value_set_enum (&orig, 1);
memset (&xform, 0, sizeof (GValue));
g_value_init (&xform, G_TYPE_CHAR);
g_value_transform (&orig, &xform);
g_assert (g_value_get_char (&xform) == 1);
memset (&xform, 0, sizeof (GValue));
g_value_init (&xform, G_TYPE_UCHAR);
g_value_transform (&orig, &xform);
g_assert (g_value_get_uchar (&xform) == 1);
memset (&xform, 0, sizeof (GValue));
g_value_init (&xform, G_TYPE_INT);
g_value_transform (&orig, &xform);
g_assert (g_value_get_int (&xform) == 1);
memset (&xform, 0, sizeof (GValue));
g_value_init (&xform, G_TYPE_UINT);
g_value_transform (&orig, &xform);
g_assert (g_value_get_uint (&xform) == 1);
memset (&xform, 0, sizeof (GValue));
g_value_init (&xform, G_TYPE_LONG);
g_value_transform (&orig, &xform);
g_assert (g_value_get_long (&xform) == 1);
memset (&xform, 0, sizeof (GValue));
g_value_init (&xform, G_TYPE_ULONG);
g_value_transform (&orig, &xform);
g_assert (g_value_get_ulong (&xform) == 1);
memset (&xform, 0, sizeof (GValue));
g_value_init (&xform, G_TYPE_INT64);
g_value_transform (&orig, &xform);
g_assert (g_value_get_int64 (&xform) == 1);
memset (&xform, 0, sizeof (GValue));
g_value_init (&xform, G_TYPE_UINT64);
g_value_transform (&orig, &xform);
g_assert (g_value_get_uint64 (&xform) == 1);
}
/**
* rb_gst_process_tag_string:
* @taglist: a #GstTagList containing a string tag
* @tag: tag name
* @field: returns the #RBMetaDataField corresponding to the tag
* @value: returns the tag value
*
* Processes a tag string, determining the metadata field identifier
* corresponding to the tag name, and converting the tag data into the
* appropriate value type.
*
* Return value: %TRUE if the tag was successfully converted.
*/
gboolean
rb_gst_process_tag_string (const GstTagList *taglist,
const char *tag,
RBMetaDataField *field,
GValue *value)
{
const GValue *tagval;
if (gst_tag_list_get_tag_size (taglist, tag) < 0) {
rb_debug ("no values in taglist for tag %s", tag);
return FALSE;
}
/* only handle a few fields here */
if (!strcmp (tag, GST_TAG_TITLE))
*field = RB_METADATA_FIELD_TITLE;
else if (!strcmp (tag, GST_TAG_GENRE))
*field = RB_METADATA_FIELD_GENRE;
else if (!strcmp (tag, GST_TAG_COMMENT))
*field = RB_METADATA_FIELD_COMMENT;
else if (!strcmp (tag, GST_TAG_BITRATE))
*field = RB_METADATA_FIELD_BITRATE;
else if (!strcmp (tag, GST_TAG_MUSICBRAINZ_TRACKID))
*field = RB_METADATA_FIELD_MUSICBRAINZ_TRACKID;
else {
rb_debug ("tag %s doesn't correspond to a metadata field we're interested in", tag);
return FALSE;
}
/* most of the fields we care about are strings */
switch (*field) {
case RB_METADATA_FIELD_BITRATE:
g_value_init (value, G_TYPE_ULONG);
break;
case RB_METADATA_FIELD_TITLE:
case RB_METADATA_FIELD_GENRE:
case RB_METADATA_FIELD_COMMENT:
case RB_METADATA_FIELD_MUSICBRAINZ_TRACKID:
default:
g_value_init (value, G_TYPE_STRING);
break;
}
tagval = gst_tag_list_get_value_index (taglist, tag, 0);
if (!g_value_transform (tagval, value)) {
rb_debug ("Could not transform tag value type %s into %s",
g_type_name (G_VALUE_TYPE (tagval)),
g_type_name (G_VALUE_TYPE (value)));
g_value_unset (value);
return FALSE;
}
return TRUE;
}
static gboolean
glide_binding_transform_negate (const GValue *src_value,
GValue *dst_value)
{
if (!g_value_transform (src_value, dst_value))
return FALSE;
g_value_set_boolean (dst_value, !g_value_get_boolean (dst_value));
return TRUE;
}
/*
* assign_parameters_values
*
* Tries to assign a value for each parameter in @plist, from the context
*
* Returns: TRUE on success
*/
static gboolean
assign_parameters_values (GdaReportEngine *engine, RunContext *context, GdaSet *plist, GError **error)
{
if (plist) {
GSList *list;
for (list = plist->holders; list; list = list->next) {
GdaHolder *source_param;
source_param = run_context_find_param (engine, context,
BAD_CAST gda_holder_get_id (GDA_HOLDER (list->data)));
if (!source_param) {
g_set_error (error, 0, 0,
_("Unknown parameter '%s'"),
gda_holder_get_id (GDA_HOLDER (list->data)));
return FALSE;
}
gda_holder_set_not_null (GDA_HOLDER (list->data), FALSE);
GType ptype, source_ptype;
ptype = gda_holder_get_g_type (GDA_HOLDER (list->data));
source_ptype = gda_holder_get_g_type (source_param);
if (ptype == source_ptype) {
if (! gda_holder_set_bind (GDA_HOLDER (list->data), source_param, error))
return FALSE;
}
else {
const GValue *source_value;
source_value = gda_holder_get_value (source_param);
if (source_value && !gda_value_is_null (source_value)) {
GValue *trans;
trans = gda_value_new (ptype);
if (g_value_transform (source_value, trans)) {
if (! gda_holder_set_value (GDA_HOLDER (list->data), trans, error)) {
gda_value_free (trans);
return FALSE;
}
gda_value_free (trans);
}
else {
gda_value_free (trans);
g_set_error (error, 0, 0,
_("Cannot cast parameter from type '%s' to type '%s'"),
g_type_name (source_ptype), g_type_name (ptype));
return FALSE;
}
}
else
if (! gda_holder_set_value (GDA_HOLDER (list->data), NULL, error))
return FALSE;
}
}
}
return TRUE;
}
static void
gst_glimage_sink_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec)
{
GstGLImageSink *glimage_sink;
g_return_if_fail (GST_IS_GLIMAGE_SINK (object));
glimage_sink = GST_GLIMAGE_SINK (object);
switch (prop_id) {
case ARG_DISPLAY:
{
g_free (glimage_sink->display_name);
glimage_sink->display_name = g_strdup (g_value_get_string (value));
break;
}
case PROP_CLIENT_RESHAPE_CALLBACK:
{
glimage_sink->clientReshapeCallback = g_value_get_pointer (value);
break;
}
case PROP_CLIENT_DRAW_CALLBACK:
{
glimage_sink->clientDrawCallback = g_value_get_pointer (value);
break;
}
case PROP_CLIENT_DATA:
{
glimage_sink->client_data = g_value_get_pointer (value);
break;
}
case PROP_FORCE_ASPECT_RATIO:
{
glimage_sink->keep_aspect_ratio = g_value_get_boolean (value);
break;
}
case PROP_PIXEL_ASPECT_RATIO:
{
g_free (glimage_sink->par);
glimage_sink->par = g_new0 (GValue, 1);
g_value_init (glimage_sink->par, GST_TYPE_FRACTION);
if (!g_value_transform (value, glimage_sink->par)) {
g_warning ("Could not transform string to aspect ratio");
gst_value_set_fraction (glimage_sink->par, 1, 1);
}
break;
}
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
clutter_list_model_iter_set_value (ClutterModelIter *iter,
guint column,
const GValue *value)
{
ClutterListModelIter *iter_default;
GValueArray *value_array;
GValue *iter_value;
GValue real_value = { 0, };
gboolean converted = FALSE;
iter_default = CLUTTER_LIST_MODEL_ITER (iter);
g_assert (iter_default->seq_iter != NULL);
value_array = g_sequence_get (iter_default->seq_iter);
iter_value = g_value_array_get_nth (value_array, column);
g_assert (iter_value != NULL);
if (!g_type_is_a (G_VALUE_TYPE (value), G_VALUE_TYPE (iter_value)))
{
if (!g_value_type_compatible (G_VALUE_TYPE (value),
G_VALUE_TYPE (iter_value)) &&
!g_value_type_compatible (G_VALUE_TYPE (iter_value),
G_VALUE_TYPE (value)))
{
g_warning ("%s: Unable to convert from %s to %s\n",
G_STRLOC,
g_type_name (G_VALUE_TYPE (value)),
g_type_name (G_VALUE_TYPE (iter_value)));
return;
}
if (!g_value_transform (value, &real_value))
{
g_warning ("%s: Unable to make conversion from %s to %s\n",
G_STRLOC,
g_type_name (G_VALUE_TYPE (value)),
g_type_name (G_VALUE_TYPE (iter_value)));
g_value_unset (&real_value);
}
converted = TRUE;
}
if (converted)
{
g_value_copy (&real_value, iter_value);
g_value_unset (&real_value);
}
else
g_value_copy (value, iter_value);
}
static gboolean
snra_json_structure_get_as (const GstStructure * structure,
const gchar * fieldname, GType t, GValue * dest)
{
const GValue *v1 = gst_structure_get_value (structure, fieldname);
if (v1 == NULL)
return FALSE;
g_value_init (dest, t);
g_value_transform (v1, dest);
return TRUE;
}
static int
test_load (const char *uri)
{
RBMetaData *md;
GError *error = NULL;
int rv = 0;
char **missing_plugins;
char **plugin_descriptions;
md = rb_metadata_new ();
rb_metadata_load (md, uri, &error);
if (error) {
g_print ("Error loading metadata from %s: %s\n", uri, error->message);
g_clear_error (&error);
g_print ("media type: %s\n", rb_metadata_get_media_type (md));
rv = -1;
} else {
int i;
g_print ("media type: %s\n", rb_metadata_get_media_type (md));
for (i=0; i<RB_METADATA_FIELD_LAST; i++) {
GValue v = {0,};
GValue sv = {0,};
if (rb_metadata_get (md, i, &v)) {
g_value_init (&sv, G_TYPE_STRING);
g_value_transform (&v, &sv);
g_print ("%s: %s\n", rb_metadata_get_field_name (i), g_value_get_string (&sv));
g_value_unset (&v);
g_value_unset (&sv);
}
}
}
g_print ("has audio: %d\n", rb_metadata_has_audio (md));
g_print ("has video: %d\n", rb_metadata_has_video (md));
g_print ("has other: %d\n", rb_metadata_has_other_data (md));
if (rb_metadata_get_missing_plugins (md, &missing_plugins, &plugin_descriptions)) {
int i = 0;
g_print ("missing plugins:\n");
while (missing_plugins[i] != NULL) {
g_print ("\t%s (%s)\n", missing_plugins[i], plugin_descriptions[i]);
i++;
}
g_strfreev (missing_plugins);
}
g_object_unref (G_OBJECT (md));
return rv;
}
