/**
* thunar_g_initialize_transformations:
*
* Registers various transformation functions to the
* GLib Type System, which are used by g_value_transform()
* to transform between different kinds of values.
**/
void
thunar_g_initialize_transformations (void)
{
if (!g_value_type_transformable (G_TYPE_STRING, G_TYPE_BOOLEAN))
g_value_register_transform_func (G_TYPE_STRING, G_TYPE_BOOLEAN, transform_string_to_boolean);
if (!g_value_type_transformable (G_TYPE_STRING, G_TYPE_INT))
g_value_register_transform_func (G_TYPE_STRING, G_TYPE_INT, transform_string_to_int);
if (!g_value_type_transformable (G_TYPE_STRING, G_TYPE_UINT))
g_value_register_transform_func (G_TYPE_STRING, G_TYPE_UINT, transform_string_to_uint);
/* register a transformation function string->enum unconditionally */
g_value_register_transform_func (G_TYPE_STRING, G_TYPE_ENUM, transform_string_to_enum);
}
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_type_transformable (G_VALUE_TYPE (setting), G_VALUE_TYPE (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;
}
g_value_transform (setting, value);
return TRUE;
out:
return _gdk_x11_get_xft_setting (screen, name, value);
}
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;
}
void
gjs_gtk_container_child_set_property (GtkContainer *container,
GtkWidget *child,
const gchar *property,
const GValue *value)
{
GParamSpec *pspec;
pspec = gtk_container_class_find_child_property (G_OBJECT_GET_CLASS (container),
property);
if (pspec == NULL) {
g_warning ("%s does not have a property called %s",
g_type_name (G_OBJECT_TYPE (container)), property);
return;
}
if ((G_VALUE_TYPE (value) == G_TYPE_POINTER) &&
(g_value_get_pointer (value) == NULL) &&
!g_value_type_transformable (G_VALUE_TYPE (value), pspec->value_type)) {
/* Set an empty value. This will happen when we set a NULL value from JS.
* Since GJS doesn't know the GParamSpec for this property, it
* will just put NULL into a G_TYPE_POINTER GValue, which will later
* fail when trying to transform it to the GParamSpec's GType.
*/
GValue null_value = G_VALUE_INIT;
g_value_init (&null_value, pspec->value_type);
gtk_container_child_set_property (container, child,
property, &null_value);
g_value_unset (&null_value);
} else {
gtk_container_child_set_property (container, child,
property, value);
}
}
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);
}
}
/********************
* 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;
}
/* 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 );
}
Handle<Value> gvalue_to_v8(const GValue *gv) {
switch(G_VALUE_TYPE(gv)) {
case G_TYPE_STRING:
return gchararray_to_v8(gv);
case G_TYPE_BOOLEAN:
return Nan::New<Boolean>(g_value_get_boolean(gv));
case G_TYPE_INT:
return Nan::New<Number>(g_value_get_int(gv));
case G_TYPE_UINT:
return Nan::New<Number>(g_value_get_uint(gv));
case G_TYPE_FLOAT:
return Nan::New<Number>(g_value_get_float(gv));
case G_TYPE_DOUBLE:
return Nan::New<Number>(g_value_get_double(gv));
}
if(GST_VALUE_HOLDS_ARRAY(gv)) {
return gstvaluearray_to_v8(gv);
} else if(GST_VALUE_HOLDS_BUFFER(gv)) {
GstBuffer *buf = gst_value_get_buffer(gv);
return gstbuffer_to_v8(buf);
} else if(GST_VALUE_HOLDS_SAMPLE(gv)) {
GstSample *sample = gst_value_get_sample(gv);
Local<Object> caps = Nan::New<Object>();
GstCaps *gcaps = gst_sample_get_caps(sample);
if (gcaps) {
const GstStructure *structure = gst_caps_get_structure(gcaps,0);
if (structure) gst_structure_to_v8(caps, structure);
}
Local<Object> result = Nan::New<Object>();
result->Set(Nan::New("buf").ToLocalChecked(), gstsample_to_v8(sample));
result->Set(Nan::New("caps").ToLocalChecked(), caps);
return result;
}
//printf("Value is of unhandled type %s\n", G_VALUE_TYPE_NAME(gv));
/* Attempt to transform it into a GValue of type STRING */
if(g_value_type_transformable (G_VALUE_TYPE(gv), G_TYPE_STRING)) {
GValue b = G_VALUE_INIT;
g_value_init(&b, G_TYPE_STRING);
g_value_transform(gv, &b);
return gchararray_to_v8(&b);
}
return Nan::Undefined();
}
static gboolean
check_transform (const gchar *xsettings_name,
GType src_type,
GType dest_type)
{
if (!g_value_type_transformable (src_type, dest_type))
{
g_warning ("Cannot transform xsetting %s of type %s to type %s\n",
xsettings_name,
g_type_name (src_type),
g_type_name (dest_type));
return FALSE;
}
else
return TRUE;
}
/**
* gda_sql_value_stringify
* @value: a #GValue pointer
*
* Simplified version of gda_value_stringify().
*
* Returns: a new string
*/
gchar *
gda_sql_value_stringify (const GValue *value)
{
if (value && !GDA_VALUE_HOLDS_NULL (value)) {
if (g_value_type_transformable (G_VALUE_TYPE (value), G_TYPE_STRING)) {
GValue *string;
gchar *str;
string = g_value_init (g_new0 (GValue, 1), G_TYPE_STRING);
g_value_transform (value, string);
str = g_value_dup_string (string);
gda_value_free (string);
return str;
}
else {
GType type = G_VALUE_TYPE (value);
if (type == G_TYPE_DATE) {
GDate *date;
date = (GDate *) g_value_get_boxed (value);
if (date) {
if (g_date_valid (date))
return g_strdup_printf ("%04u-%02u-%02u",
g_date_get_year (date),
g_date_get_month (date),
g_date_get_day (date));
else
return g_strdup_printf ("%04u-%02u-%02u",
date->year, date->month, date->day);
}
else
return g_strdup ("0000-00-00");
}
else
return g_strdup ("<type not transformable to string>");
}
}
else
return g_strdup ("NULL");
}
static inline gboolean
default_transform (const GValue *value_a,
GValue *value_b)
{
/* if it's not the same type, try to convert it using the GValue
* transformation API; otherwise just copy it
*/
if (!g_type_is_a (G_VALUE_TYPE (value_a), G_VALUE_TYPE (value_b)))
{
/* are these two types compatible (can be directly copied)? */
if (g_value_type_compatible (G_VALUE_TYPE (value_a),
G_VALUE_TYPE (value_b)))
{
g_value_copy (value_a, value_b);
goto done;
}
if (g_value_type_transformable (G_VALUE_TYPE (value_a),
G_VALUE_TYPE (value_b)))
{
if (g_value_transform (value_a, value_b))
goto done;
g_warning ("%s: Unable to convert a value of type %s to a "
"value of type %s",
G_STRLOC,
g_type_name (G_VALUE_TYPE (value_a)),
g_type_name (G_VALUE_TYPE (value_b)));
return FALSE;
}
}
else
g_value_copy (value_a, value_b);
done:
return TRUE;
}
static void
gimp_thumbnail_debug_notify (GObject *object,
GParamSpec *pspec)
{
GValue value = { 0, };
gchar *str = NULL;
const gchar *name;
g_value_init (&value, pspec->value_type);
g_object_get_property (object, pspec->name, &value);
if (G_VALUE_HOLDS_STRING (&value))
{
str = g_value_dup_string (&value);
}
else if (g_value_type_transformable (pspec->value_type, G_TYPE_STRING))
{
GValue tmp = { 0, };
g_value_init (&tmp, G_TYPE_STRING);
g_value_transform (&value, &tmp);
str = g_value_dup_string (&tmp);
g_value_unset (&tmp);
}
g_value_unset (&value);
name = GIMP_THUMBNAIL (object)->image_uri;
g_printerr (" GimpThumb (%s) %s: %s\n",
name ? name : "(null)", pspec->name, str);
g_free (str);
}
static gboolean
compare_record_property (DMAPRecord * record, const gchar * property_name,
const gchar * property_value)
{
GParamSpec *pspec;
GValue value = { 0, };
/* Note that this string belongs to value and will not be freed explicitely. */
const gchar *str_value;
gboolean accept;
pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (record),
property_name);
if (pspec == NULL)
// Can't find the property in this record, so don't accept it.
return FALSE;
// Get the property value as a GValue set to the type of this
// property.
g_value_init (&value, G_PARAM_SPEC_VALUE_TYPE (pspec));
g_object_get_property (G_OBJECT (record), property_name, &value);
if (G_VALUE_HOLDS_STRING (&value)) {
str_value = g_value_get_string (&value);
} else if (G_VALUE_HOLDS_BOOLEAN (&value)) {
g_debug ("Compare %s (boolean): %d %s", property_name, g_value_get_boolean (&value), property_value);
accept = (g_value_get_boolean (&value) &&
g_strcmp0 (property_value, "1") == 0);
g_value_unset (&value);
return accept;
} else if (g_value_type_transformable
(G_VALUE_TYPE (&value), G_TYPE_LONG)) {
// Prefer integer conversion.
GValue dest = { 0, };
g_value_init (&dest, G_TYPE_LONG);
if (!g_value_transform (&value, &dest)) {
g_warning
("Failed to convert value into long for property %s",
property_name);
g_value_unset (&value);
return FALSE;
}
g_debug ("Compare %s (long): %ld %s", property_name, g_value_get_long (&dest), property_value);
accept = (g_value_get_long (&dest) ==
strtol (property_value, NULL, 10));
g_value_unset (&value);
return accept;
} else if (g_value_type_transformable
(G_VALUE_TYPE (&value), G_TYPE_STRING)) {
// Use standard transform functions from GLib (note that these
// functions are unreliable and known cases should be handled
// above).
GValue dest;
g_value_init (&dest, G_TYPE_STRING);
if (!g_value_transform (&value, &dest)) {
g_warning
("Failed to convert value into string for property %s",
property_name);
g_value_unset (&value);
return FALSE;
}
str_value = g_value_dup_string (&dest);
g_value_reset (&value);
//Sets the string to value so that it will be freed later.
g_value_take_string (&value, (gchar *) str_value);
g_value_unset (&dest);
} else {
g_warning ("Attempt to compare unhandled type");
g_value_unset (&value);
return FALSE;
}
// Only arrive here if we are handling strings.
g_debug ("Compare %s (string): %s %s", property_name, str_value, property_value);
if (str_value != NULL && property_value != NULL &&
g_ascii_strcasecmp (str_value, property_value) == 0) {
accept = TRUE;
} else if (str_value == NULL && property_value == NULL) {
accept = TRUE;
} else {
accept = FALSE;
}
// This will destroy str_value since it belongs to value.
g_value_unset (&value);
return accept;
}
static gboolean
gimp_procedure_validate_args (GimpProcedure *procedure,
GParamSpec **param_specs,
gint n_param_specs,
GValueArray *args,
gboolean return_vals,
GError **error)
{
gint i;
for (i = 0; i < MIN (args->n_values, n_param_specs); i++)
{
GValue *arg = &args->values[i];
GParamSpec *pspec = param_specs[i];
GType arg_type = G_VALUE_TYPE (arg);
GType spec_type = G_PARAM_SPEC_VALUE_TYPE (pspec);
if (arg_type != spec_type)
{
if (return_vals)
{
g_set_error (error,
GIMP_PDB_ERROR, GIMP_PDB_INVALID_RETURN_VALUE,
_("Procedure '%s' returned a wrong value type "
"for return value '%s' (#%d). "
"Expected %s, got %s."),
gimp_object_get_name (procedure),
g_param_spec_get_name (pspec),
i + 1, g_type_name (spec_type),
g_type_name (arg_type));
}
else
{
g_set_error (error,
GIMP_PDB_ERROR, GIMP_PDB_INVALID_ARGUMENT,
_("Procedure '%s' has been called with a "
"wrong value type for argument '%s' (#%d). "
"Expected %s, got %s."),
gimp_object_get_name (procedure),
g_param_spec_get_name (pspec),
i + 1, g_type_name (spec_type),
g_type_name (arg_type));
}
return FALSE;
}
else if (! (pspec->flags & GIMP_PARAM_NO_VALIDATE))
{
GValue string_value = { 0, };
g_value_init (&string_value, G_TYPE_STRING);
if (g_value_type_transformable (arg_type, G_TYPE_STRING))
g_value_transform (arg, &string_value);
else
g_value_set_static_string (&string_value,
"<not transformable to string>");
if (g_param_value_validate (pspec, arg))
{
if (GIMP_IS_PARAM_SPEC_DRAWABLE_ID (pspec) &&
g_value_get_int (arg) == -1)
{
if (return_vals)
{
g_set_error (error,
GIMP_PDB_ERROR, GIMP_PDB_INVALID_RETURN_VALUE,
_("Procedure '%s' returned an "
"invalid ID for argument '%s'. "
"Most likely a plug-in is trying "
"to work on a layer that doesn't "
"exist any longer."),
gimp_object_get_name (procedure),
g_param_spec_get_name (pspec));
}
else
{
g_set_error (error,
GIMP_PDB_ERROR, GIMP_PDB_INVALID_ARGUMENT,
_("Procedure '%s' has been called with an "
"invalid ID for argument '%s'. "
"Most likely a plug-in is trying "
"to work on a layer that doesn't "
"exist any longer."),
gimp_object_get_name (procedure),
g_param_spec_get_name (pspec));
}
}
else if (GIMP_IS_PARAM_SPEC_IMAGE_ID (pspec) &&
g_value_get_int (arg) == -1)
{
if (return_vals)
{
g_set_error (error,
GIMP_PDB_ERROR, GIMP_PDB_INVALID_RETURN_VALUE,
_("Procedure '%s' returned an "
"invalid ID for argument '%s'. "
"Most likely a plug-in is trying "
"to work on an image that doesn't "
"exist any longer."),
gimp_object_get_name (procedure),
g_param_spec_get_name (pspec));
}
else
{
g_set_error (error,
GIMP_PDB_ERROR, GIMP_PDB_INVALID_ARGUMENT,
_("Procedure '%s' has been called with an "
"invalid ID for argument '%s'. "
"Most likely a plug-in is trying "
"to work on an image that doesn't "
"exist any longer."),
gimp_object_get_name (procedure),
g_param_spec_get_name (pspec));
}
}
else
{
const gchar *value = g_value_get_string (&string_value);
if (value == NULL)
value = "(null)";
if (return_vals)
{
g_set_error (error,
GIMP_PDB_ERROR, GIMP_PDB_INVALID_RETURN_VALUE,
_("Procedure '%s' returned "
"'%s' as return value '%s' "
"(#%d, type %s). "
"This value is out of range."),
gimp_object_get_name (procedure),
value,
g_param_spec_get_name (pspec),
i + 1, g_type_name (spec_type));
}
else
{
g_set_error (error,
GIMP_PDB_ERROR, GIMP_PDB_INVALID_ARGUMENT,
_("Procedure '%s' has been called with "
"value '%s' for argument '%s' "
"(#%d, type %s). "
"This value is out of range."),
gimp_object_get_name (procedure),
value,
g_param_spec_get_name (pspec),
i + 1, g_type_name (spec_type));
}
}
return FALSE;
}
g_value_unset (&string_value);
}
}
return TRUE;
}
static gboolean
gst_lfo_control_source_bind (GstControlSource * source, GParamSpec * pspec)
{
GType type, base;
GstLFOControlSource *self = GST_LFO_CONTROL_SOURCE (source);
gboolean ret = TRUE;
/* get the fundamental base type */
self->priv->type = base = type = G_PARAM_SPEC_VALUE_TYPE (pspec);
while ((type = g_type_parent (type)))
base = type;
self->priv->base = base;
/* restore type */
type = self->priv->type;
switch (base) {
case G_TYPE_INT:{
GParamSpecInt *tpspec = G_PARAM_SPEC_INT (pspec);
g_value_init (&self->priv->minimum_value, type);
g_value_set_int (&self->priv->minimum_value, tpspec->minimum);
g_value_init (&self->priv->maximum_value, type);
g_value_set_int (&self->priv->maximum_value, tpspec->maximum);
if (!G_IS_VALUE (&self->priv->amplitude)) {
g_value_init (&self->priv->amplitude, type);
g_value_set_int (&self->priv->amplitude, 0);
}
if (!G_IS_VALUE (&self->priv->offset)) {
g_value_init (&self->priv->offset, type);
g_value_set_int (&self->priv->offset, tpspec->default_value);
}
break;
}
case G_TYPE_UINT:{
GParamSpecUInt *tpspec = G_PARAM_SPEC_UINT (pspec);
g_value_init (&self->priv->minimum_value, type);
g_value_set_uint (&self->priv->minimum_value, tpspec->minimum);
g_value_init (&self->priv->maximum_value, type);
g_value_set_uint (&self->priv->maximum_value, tpspec->maximum);
if (!G_IS_VALUE (&self->priv->amplitude)) {
g_value_init (&self->priv->amplitude, type);
g_value_set_uint (&self->priv->amplitude, 0);
}
if (!G_IS_VALUE (&self->priv->offset)) {
g_value_init (&self->priv->offset, type);
g_value_set_uint (&self->priv->offset, tpspec->default_value);
}
break;
}
case G_TYPE_LONG:{
GParamSpecLong *tpspec = G_PARAM_SPEC_LONG (pspec);
g_value_init (&self->priv->minimum_value, type);
g_value_set_long (&self->priv->minimum_value, tpspec->minimum);
g_value_init (&self->priv->maximum_value, type);
g_value_set_long (&self->priv->maximum_value, tpspec->maximum);
if (!G_IS_VALUE (&self->priv->amplitude)) {
g_value_init (&self->priv->amplitude, type);
g_value_set_long (&self->priv->amplitude, 0);
}
if (!G_IS_VALUE (&self->priv->offset)) {
g_value_init (&self->priv->offset, type);
g_value_set_long (&self->priv->offset, tpspec->default_value);
}
break;
}
case G_TYPE_ULONG:{
GParamSpecULong *tpspec = G_PARAM_SPEC_ULONG (pspec);
g_value_init (&self->priv->minimum_value, type);
g_value_set_ulong (&self->priv->minimum_value, tpspec->minimum);
g_value_init (&self->priv->maximum_value, type);
g_value_set_ulong (&self->priv->maximum_value, tpspec->maximum);
if (!G_IS_VALUE (&self->priv->amplitude)) {
g_value_init (&self->priv->amplitude, type);
g_value_set_ulong (&self->priv->amplitude, 0);
}
if (!G_IS_VALUE (&self->priv->offset)) {
g_value_init (&self->priv->offset, type);
g_value_set_ulong (&self->priv->offset, tpspec->default_value);
}
break;
}
case G_TYPE_INT64:{
GParamSpecInt64 *tpspec = G_PARAM_SPEC_INT64 (pspec);
g_value_init (&self->priv->minimum_value, type);
g_value_set_int64 (&self->priv->minimum_value, tpspec->minimum);
g_value_init (&self->priv->maximum_value, type);
g_value_set_int64 (&self->priv->maximum_value, tpspec->maximum);
if (!G_IS_VALUE (&self->priv->amplitude)) {
g_value_init (&self->priv->amplitude, type);
g_value_set_int64 (&self->priv->amplitude, 0);
}
if (!G_IS_VALUE (&self->priv->offset)) {
g_value_init (&self->priv->offset, type);
g_value_set_int64 (&self->priv->offset, tpspec->default_value);
}
break;
}
case G_TYPE_UINT64:{
GParamSpecUInt64 *tpspec = G_PARAM_SPEC_UINT64 (pspec);
g_value_init (&self->priv->minimum_value, type);
g_value_set_uint64 (&self->priv->minimum_value, tpspec->minimum);
g_value_init (&self->priv->maximum_value, type);
g_value_set_uint64 (&self->priv->maximum_value, tpspec->maximum);
if (!G_IS_VALUE (&self->priv->amplitude)) {
g_value_init (&self->priv->amplitude, type);
g_value_set_uint64 (&self->priv->amplitude, 0);
}
if (!G_IS_VALUE (&self->priv->offset)) {
g_value_init (&self->priv->offset, type);
g_value_set_uint64 (&self->priv->offset, tpspec->default_value);
}
break;
}
case G_TYPE_FLOAT:{
GParamSpecFloat *tpspec = G_PARAM_SPEC_FLOAT (pspec);
g_value_init (&self->priv->minimum_value, type);
g_value_set_float (&self->priv->minimum_value, tpspec->minimum);
g_value_init (&self->priv->maximum_value, type);
g_value_set_float (&self->priv->maximum_value, tpspec->maximum);
if (!G_IS_VALUE (&self->priv->amplitude)) {
g_value_init (&self->priv->amplitude, type);
g_value_set_float (&self->priv->amplitude, 0.0);
}
if (!G_IS_VALUE (&self->priv->offset)) {
g_value_init (&self->priv->offset, type);
g_value_set_float (&self->priv->offset, tpspec->default_value);
}
break;
}
case G_TYPE_DOUBLE:{
GParamSpecDouble *tpspec = G_PARAM_SPEC_DOUBLE (pspec);
g_value_init (&self->priv->minimum_value, type);
g_value_set_double (&self->priv->minimum_value, tpspec->minimum);
g_value_init (&self->priv->maximum_value, type);
g_value_set_double (&self->priv->maximum_value, tpspec->maximum);
if (!G_IS_VALUE (&self->priv->amplitude)) {
g_value_init (&self->priv->amplitude, type);
g_value_set_float (&self->priv->amplitude, 0.0);
}
if (!G_IS_VALUE (&self->priv->offset)) {
g_value_init (&self->priv->offset, type);
g_value_set_float (&self->priv->offset, tpspec->default_value);
}
break;
}
default:
GST_WARNING ("incomplete implementation for paramspec type '%s'",
G_PARAM_SPEC_TYPE_NAME (pspec));
ret = FALSE;
break;
}
if (ret) {
GValue amp = { 0, }
, off = {
0,};
/* This should never fail unless the user already set amplitude or offset
* with an incompatible type before _bind () */
if (!g_value_type_transformable (G_VALUE_TYPE (&self->priv->amplitude),
base)
|| !g_value_type_transformable (G_VALUE_TYPE (&self->priv->offset),
base)) {
GST_WARNING ("incompatible types for amplitude or offset");
gst_lfo_control_source_reset (self);
return FALSE;
}
/* Generate copies and transform to the correct type */
g_value_init (&, base);
g_value_transform (&self->priv->amplitude, &);
g_value_init (&off, base);
g_value_transform (&self->priv->offset, &off);
ret = gst_lfo_control_source_set_waveform (self, self->priv->waveform);
g_value_unset (&self->priv->amplitude);
g_value_init (&self->priv->amplitude, self->priv->base);
g_value_transform (&, &self->priv->amplitude);
g_value_unset (&self->priv->offset);
g_value_init (&self->priv->offset, self->priv->base);
g_value_transform (&off, &self->priv->offset);
g_value_unset (&);
g_value_unset (&off);
}
if (!ret)
gst_lfo_control_source_reset (self);
return ret;
}
static GtkWidget *
attribute_editor (GObject *object,
GParamSpec *spec,
GtkInspectorPropEditor *editor)
{
gpointer layout;
GtkCellArea *area;
GtkTreeModel *model = NULL;
gint col = -1;
GtkWidget *label;
GtkWidget *button;
GtkWidget *vbox;
GtkWidget *box;
GtkWidget *combo;
gchar *text;
gint i;
gboolean sensitive;
GtkCellRenderer *renderer;
GtkListStore *store;
GtkTreeIter iter;
layout = g_object_get_data (object, "gtk-inspector-cell-layout");
if (GTK_IS_CELL_LAYOUT (layout))
{
area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (layout));
col = gtk_cell_area_attribute_get_column (area,
GTK_CELL_RENDERER (object),
editor->priv->name);
model = gtk_cell_layout_get_model (GTK_CELL_LAYOUT (layout));
}
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
label = gtk_label_new (_("Attribute mapping"));
gtk_widget_set_margin_top (label, 10);
gtk_container_add (GTK_CONTAINER (vbox), label);
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
gtk_container_add (GTK_CONTAINER (box), gtk_label_new (_("Model:")));
text = g_strdup_printf (_("%p (%s)"), model, g_type_name (G_TYPE_FROM_INSTANCE (model)));
gtk_container_add (GTK_CONTAINER (box), gtk_label_new (text));
g_free (text);
button = gtk_button_new_with_label (_("Properties"));
g_object_set_data (G_OBJECT (button), "model", model);
g_signal_connect (button, "clicked", G_CALLBACK (model_properties), editor);
gtk_container_add (GTK_CONTAINER (box), button);
gtk_container_add (GTK_CONTAINER (vbox), box);
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
gtk_container_add (GTK_CONTAINER (box), gtk_label_new (_("Column:")));
store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_BOOLEAN);
combo = gtk_combo_box_new_with_model (GTK_TREE_MODEL (store));
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), renderer, FALSE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo), renderer,
"text", 0,
"sensitive", 1,
NULL);
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter, 0, _("None"), 1, TRUE, -1);
for (i = 0; i < gtk_tree_model_get_n_columns (model); i++)
{
text = g_strdup_printf ("%d", i);
sensitive = g_value_type_transformable (gtk_tree_model_get_column_type (model, i),
spec->value_type);
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter, 0, text, 1, sensitive, -1);
g_free (text);
}
gtk_combo_box_set_active (GTK_COMBO_BOX (combo), col + 1);
attribute_mapping_changed (GTK_COMBO_BOX (combo), editor);
g_signal_connect (combo, "changed",
G_CALLBACK (attribute_mapping_changed), editor);
gtk_container_add (GTK_CONTAINER (box), combo);
gtk_container_add (GTK_CONTAINER (vbox), box);
gtk_widget_show_all (vbox);
return vbox;
}
/**
* g_strdup_value_contents:
* @value: #GValue which contents are to be described.
*
* Return a newly allocated string, which describes the contents of a
* #GValue. The main purpose of this function is to describe #GValue
* contents for debugging output, the way in which the contents are
* described may change between different GLib versions.
*
* Returns: Newly allocated string.
*/
gchar*
g_strdup_value_contents (const GValue *value)
{
const gchar *src;
gchar *contents;
g_return_val_if_fail (G_IS_VALUE (value), NULL);
if (G_VALUE_HOLDS_STRING (value))
{
src = g_value_get_string (value);
if (!src)
contents = g_strdup ("NULL");
else
{
gchar *s = g_strescape (src, NULL);
contents = g_strdup_printf ("\"%s\"", s);
g_free (s);
}
}
else if (g_value_type_transformable (G_VALUE_TYPE (value), G_TYPE_STRING))
{
GValue tmp_value = { 0, };
gchar *s;
g_value_init (&tmp_value, G_TYPE_STRING);
g_value_transform (value, &tmp_value);
s = g_strescape (g_value_get_string (&tmp_value), NULL);
g_value_unset (&tmp_value);
if (G_VALUE_HOLDS_ENUM (value) || G_VALUE_HOLDS_FLAGS (value))
contents = g_strdup_printf ("((%s) %s)",
g_type_name (G_VALUE_TYPE (value)),
s);
else
contents = g_strdup (s ? s : "NULL");
g_free (s);
}
else if (g_value_fits_pointer (value))
{
gpointer p = g_value_peek_pointer (value);
if (!p)
contents = g_strdup ("NULL");
else if (G_VALUE_HOLDS_OBJECT (value))
contents = g_strdup_printf ("((%s*) %p)", G_OBJECT_TYPE_NAME (p), p);
else if (G_VALUE_HOLDS_PARAM (value))
contents = g_strdup_printf ("((%s*) %p)", G_PARAM_SPEC_TYPE_NAME (p), p);
else if (G_VALUE_HOLDS (value, G_TYPE_STRV))
{
GStrv strv = g_value_get_boxed (value);
GString *tmp = g_string_new ("[");
while (*strv != NULL)
{
gchar *escaped = g_strescape (*strv, NULL);
g_string_append_printf (tmp, "\"%s\"", escaped);
g_free (escaped);
if (*++strv != NULL)
g_string_append (tmp, ", ");
}
g_string_append (tmp, "]");
contents = g_string_free (tmp, FALSE);
}
else if (G_VALUE_HOLDS_BOXED (value))
contents = g_strdup_printf ("((%s*) %p)", g_type_name (G_VALUE_TYPE (value)), p);
else if (G_VALUE_HOLDS_POINTER (value))
contents = g_strdup_printf ("((gpointer) %p)", p);
else
contents = g_strdup ("???");
}
else
contents = g_strdup ("???");
return contents;
}
static void
gst_lfo_control_source_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec)
{
GstLFOControlSource *self = GST_LFO_CONTROL_SOURCE (object);
switch (prop_id) {
case PROP_WAVEFORM:
g_mutex_lock (self->lock);
gst_lfo_control_source_set_waveform (self, g_value_get_enum (value));
g_mutex_unlock (self->lock);
break;
case PROP_FREQUENCY:{
gdouble frequency = g_value_get_double (value);
g_return_if_fail (frequency > 0
|| ((GstClockTime) (GST_SECOND / frequency)) != 0);
g_mutex_lock (self->lock);
self->priv->frequency = frequency;
self->priv->period = GST_SECOND / frequency;
g_mutex_unlock (self->lock);
break;
}
case PROP_TIMESHIFT:
g_mutex_lock (self->lock);
self->priv->timeshift = g_value_get_uint64 (value);
g_mutex_unlock (self->lock);
break;
case PROP_AMPLITUDE:{
GValue *val = g_value_get_boxed (value);
if (self->priv->type != G_TYPE_INVALID) {
g_return_if_fail (g_value_type_transformable (self->priv->type,
G_VALUE_TYPE (val)));
g_mutex_lock (self->lock);
if (G_IS_VALUE (&self->priv->amplitude))
g_value_unset (&self->priv->amplitude);
g_value_init (&self->priv->amplitude, self->priv->type);
g_value_transform (val, &self->priv->amplitude);
g_mutex_unlock (self->lock);
} else {
g_mutex_lock (self->lock);
if (G_IS_VALUE (&self->priv->amplitude))
g_value_unset (&self->priv->amplitude);
g_value_init (&self->priv->amplitude, G_VALUE_TYPE (val));
g_value_copy (val, &self->priv->amplitude);
g_mutex_unlock (self->lock);
}
break;
}
case PROP_OFFSET:{
GValue *val = g_value_get_boxed (value);
if (self->priv->type != G_TYPE_INVALID) {
g_return_if_fail (g_value_type_transformable (self->priv->type,
G_VALUE_TYPE (val)));
g_mutex_lock (self->lock);
if (G_IS_VALUE (&self->priv->offset))
g_value_unset (&self->priv->offset);
g_value_init (&self->priv->offset, self->priv->type);
g_value_transform (val, &self->priv->offset);
g_mutex_unlock (self->lock);
} else {
g_mutex_lock (self->lock);
if (G_IS_VALUE (&self->priv->offset))
g_value_unset (&self->priv->offset);
g_value_init (&self->priv->offset, G_VALUE_TYPE (val));
g_value_copy (val, &self->priv->offset);
g_mutex_unlock (self->lock);
}
break;
}
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static JSBool
gjs_value_to_g_value_internal(JSContext *context,
jsval value,
GValue *gvalue,
gboolean no_copy)
{
GType gtype;
gtype = G_VALUE_TYPE(gvalue);
if (gtype == 0) {
gtype = gjs_value_guess_g_type(context, value);
if (gtype == G_TYPE_INVALID) {
gjs_throw(context, "Could not guess unspecified GValue type");
return JS_FALSE;
}
gjs_debug_marshal(GJS_DEBUG_GCLOSURE,
"Guessed GValue type %s from JS Value",
g_type_name(gtype));
g_value_init(gvalue, gtype);
}
gjs_debug_marshal(GJS_DEBUG_GCLOSURE,
"Converting jsval to gtype %s",
g_type_name(gtype));
if (gtype == G_TYPE_STRING) {
/* Don't use ValueToString since we don't want to just toString()
* everything automatically
*/
if (JSVAL_IS_NULL(value)) {
g_value_set_string(gvalue, NULL);
} else if (JSVAL_IS_STRING(value)) {
gchar *utf8_string;
if (!gjs_string_to_utf8(context, value, &utf8_string))
return JS_FALSE;
g_value_take_string(gvalue, utf8_string);
} else {
gjs_throw(context,
"Wrong type %s; string expected",
gjs_get_type_name(value));
return JS_FALSE;
}
} else if (gtype == G_TYPE_CHAR) {
gint32 i;
if (JS_ValueToInt32(context, value, &i) && i >= SCHAR_MIN && i <= SCHAR_MAX) {
g_value_set_schar(gvalue, (signed char)i);
} else {
gjs_throw(context,
"Wrong type %s; char expected",
gjs_get_type_name(value));
return JS_FALSE;
}
} else if (gtype == G_TYPE_UCHAR) {
guint16 i;
if (JS_ValueToUint16(context, value, &i) && i <= UCHAR_MAX) {
g_value_set_uchar(gvalue, (unsigned char)i);
} else {
gjs_throw(context,
"Wrong type %s; unsigned char expected",
gjs_get_type_name(value));
return JS_FALSE;
}
} else if (gtype == G_TYPE_INT) {
gint32 i;
if (JS_ValueToInt32(context, value, &i)) {
g_value_set_int(gvalue, i);
} else {
gjs_throw(context,
"Wrong type %s; integer expected",
gjs_get_type_name(value));
return JS_FALSE;
}
} else if (gtype == G_TYPE_DOUBLE) {
gdouble d;
if (JS_ValueToNumber(context, value, &d)) {
g_value_set_double(gvalue, d);
} else {
gjs_throw(context,
"Wrong type %s; double expected",
gjs_get_type_name(value));
return JS_FALSE;
}
} else if (gtype == G_TYPE_FLOAT) {
gdouble d;
if (JS_ValueToNumber(context, value, &d)) {
g_value_set_float(gvalue, d);
} else {
gjs_throw(context,
"Wrong type %s; float expected",
gjs_get_type_name(value));
return JS_FALSE;
}
} else if (gtype == G_TYPE_UINT) {
guint32 i;
if (JS_ValueToECMAUint32(context, value, &i)) {
g_value_set_uint(gvalue, i);
} else {
gjs_throw(context,
"Wrong type %s; unsigned integer expected",
gjs_get_type_name(value));
return JS_FALSE;
}
} else if (gtype == G_TYPE_BOOLEAN) {
JSBool b;
/* JS_ValueToBoolean() pretty much always succeeds,
* which is maybe surprising sometimes, but could
* be handy also...
*/
if (JS_ValueToBoolean(context, value, &b)) {
g_value_set_boolean(gvalue, b);
} else {
gjs_throw(context,
"Wrong type %s; boolean expected",
gjs_get_type_name(value));
return JS_FALSE;
}
} else if (g_type_is_a(gtype, G_TYPE_OBJECT) || g_type_is_a(gtype, G_TYPE_INTERFACE)) {
GObject *gobj;
gobj = NULL;
if (JSVAL_IS_NULL(value)) {
/* nothing to do */
} else if (JSVAL_IS_OBJECT(value)) {
JSObject *obj;
obj = JSVAL_TO_OBJECT(value);
if (!gjs_typecheck_object(context, obj,
gtype, JS_TRUE))
return JS_FALSE;
gobj = gjs_g_object_from_object(context, obj);
} else {
gjs_throw(context,
"Wrong type %s; object %s expected",
gjs_get_type_name(value),
g_type_name(gtype));
return JS_FALSE;
}
g_value_set_object(gvalue, gobj);
} else if (gtype == G_TYPE_STRV) {
if (JSVAL_IS_NULL(value)) {
/* do nothing */
} else if (gjs_object_has_property(context,
JSVAL_TO_OBJECT(value),
"length")) {
jsval length_value;
guint32 length;
if (!gjs_object_require_property(context,
JSVAL_TO_OBJECT(value), NULL,
"length",
&length_value) ||
!JS_ValueToECMAUint32(context, length_value, &length)) {
gjs_throw(context,
"Wrong type %s; strv expected",
gjs_get_type_name(value));
return JS_FALSE;
} else {
void *result;
char **strv;
if (!gjs_array_to_strv (context,
value,
length, &result))
return JS_FALSE;
/* cast to strv in a separate step to avoid type-punning */
strv = result;
g_value_take_boxed (gvalue, strv);
}
} else {
gjs_throw(context,
"Wrong type %s; strv expected",
gjs_get_type_name(value));
return JS_FALSE;
}
} else if (g_type_is_a(gtype, G_TYPE_BOXED)) {
void *gboxed;
gboxed = NULL;
if (JSVAL_IS_NULL(value)) {
/* nothing to do */
} else if (JSVAL_IS_OBJECT(value)) {
JSObject *obj;
obj = JSVAL_TO_OBJECT(value);
if (g_type_is_a(gtype, G_TYPE_ERROR)) {
/* special case GError */
if (!gjs_typecheck_gerror(context, obj, JS_TRUE))
return JS_FALSE;
gboxed = gjs_gerror_from_error(context, obj);
} else {
/* First try a union, if that fails,
assume a boxed struct. Distinguishing
which one is expected would require checking
the associated GIBaseInfo, which is not necessary
possible, if e.g. we see the GType without
loading the typelib.
*/
if (gjs_typecheck_union(context, obj,
NULL, gtype, JS_FALSE)) {
gboxed = gjs_c_union_from_union(context, obj);
} else {
if (!gjs_typecheck_boxed(context, obj,
NULL, gtype, JS_TRUE))
return JS_FALSE;
gboxed = gjs_c_struct_from_boxed(context, obj);
}
}
} else {
gjs_throw(context,
"Wrong type %s; boxed type %s expected",
gjs_get_type_name(value),
g_type_name(gtype));
return JS_FALSE;
}
if (no_copy)
g_value_set_static_boxed(gvalue, gboxed);
else
g_value_set_boxed(gvalue, gboxed);
} else if (g_type_is_a(gtype, G_TYPE_VARIANT)) {
GVariant *variant = NULL;
if (JSVAL_IS_NULL(value)) {
/* nothing to do */
} else if (JSVAL_IS_OBJECT(value)) {
JSObject *obj = JSVAL_TO_OBJECT(value);
if (!gjs_typecheck_boxed(context, obj,
NULL, G_TYPE_VARIANT, JS_TRUE))
return JS_FALSE;
variant = gjs_c_struct_from_boxed(context, obj);
} else {
gjs_throw(context,
"Wrong type %s; boxed type %s expected",
gjs_get_type_name(value),
g_type_name(gtype));
return JS_FALSE;
}
g_value_set_variant (gvalue, variant);
} else if (g_type_is_a(gtype, G_TYPE_ENUM)) {
gint64 value_int64;
if (gjs_value_to_int64 (context, value, &value_int64)) {
GEnumValue *v;
/* See arg.c:_gjs_enum_to_int() */
v = g_enum_get_value(G_ENUM_CLASS(g_type_class_peek(gtype)),
(int)value_int64);
if (v == NULL) {
gjs_throw(context,
"%d is not a valid value for enumeration %s",
JSVAL_TO_INT(value), g_type_name(gtype));
return JS_FALSE;
}
g_value_set_enum(gvalue, v->value);
} else {
gjs_throw(context,
"Wrong type %s; enum %s expected",
gjs_get_type_name(value),
g_type_name(gtype));
return JS_FALSE;
}
} else if (g_type_is_a(gtype, G_TYPE_FLAGS)) {
gint64 value_int64;
if (gjs_value_to_int64 (context, value, &value_int64)) {
if (!_gjs_flags_value_is_valid(context, gtype, value_int64))
return JS_FALSE;
/* See arg.c:_gjs_enum_to_int() */
g_value_set_flags(gvalue, (int)value_int64);
} else {
gjs_throw(context,
"Wrong type %s; flags %s expected",
gjs_get_type_name(value),
g_type_name(gtype));
return JS_FALSE;
}
} else if (g_type_is_a(gtype, G_TYPE_PARAM)) {
void *gparam;
gparam = NULL;
if (JSVAL_IS_NULL(value)) {
/* nothing to do */
} else if (JSVAL_IS_OBJECT(value)) {
JSObject *obj;
obj = JSVAL_TO_OBJECT(value);
if (!gjs_typecheck_param(context, obj, gtype, JS_TRUE))
return JS_FALSE;
gparam = gjs_g_param_from_param(context, obj);
} else {
gjs_throw(context,
"Wrong type %s; param type %s expected",
gjs_get_type_name(value),
g_type_name(gtype));
return JS_FALSE;
}
g_value_set_param(gvalue, gparam);
} else if (g_type_is_a(gtype, G_TYPE_GTYPE)) {
GType type;
if (!JSVAL_IS_OBJECT(value)) {
gjs_throw(context, "Wrong type %s; expect a GType object",
gjs_get_type_name(value));
return JS_FALSE;
}
type = gjs_gtype_get_actual_gtype(context, JSVAL_TO_OBJECT(value));
g_value_set_gtype(gvalue, type);
} else if (g_type_is_a(gtype, G_TYPE_POINTER)) {
if (JSVAL_IS_NULL(value)) {
/* Nothing to do */
} else {
gjs_throw(context,
"Cannot convert non-null JS value to G_POINTER");
return JS_FALSE;
}
} else if (JSVAL_IS_NUMBER(value) &&
g_value_type_transformable(G_TYPE_INT, gtype)) {
/* Only do this crazy gvalue transform stuff after we've
* exhausted everything else. Adding this for
* e.g. ClutterUnit.
*/
gint32 i;
if (JS_ValueToInt32(context, value, &i)) {
GValue int_value = { 0, };
g_value_init(&int_value, G_TYPE_INT);
g_value_set_int(&int_value, i);
g_value_transform(&int_value, gvalue);
} else {
gjs_throw(context,
"Wrong type %s; integer expected",
gjs_get_type_name(value));
return JS_FALSE;
}
} else {
gjs_debug(GJS_DEBUG_GCLOSURE, "jsval is number %d gtype fundamental %d transformable to int %d from int %d",
JSVAL_IS_NUMBER(value),
G_TYPE_IS_FUNDAMENTAL(gtype),
g_value_type_transformable(gtype, G_TYPE_INT),
g_value_type_transformable(G_TYPE_INT, gtype));
gjs_throw(context,
"Don't know how to convert JavaScript object to GType %s",
g_type_name(gtype));
return JS_FALSE;
}
return JS_TRUE;
}
static JSBool
gjs_value_from_g_value_internal(JSContext *context,
jsval *value_p,
const GValue *gvalue,
gboolean no_copy,
GSignalQuery *signal_query,
gint arg_n)
{
GType gtype;
gtype = G_VALUE_TYPE(gvalue);
gjs_debug_marshal(GJS_DEBUG_GCLOSURE,
"Converting gtype %s to jsval",
g_type_name(gtype));
if (gtype == G_TYPE_STRING) {
const char *v;
v = g_value_get_string(gvalue);
if (v == NULL) {
gjs_debug_marshal(GJS_DEBUG_GCLOSURE,
"Converting NULL string to JSVAL_NULL");
*value_p = JSVAL_NULL;
} else {
if (!gjs_string_from_utf8(context, v, -1, value_p))
return JS_FALSE;
}
} else if (gtype == G_TYPE_CHAR) {
char v;
v = g_value_get_schar(gvalue);
*value_p = INT_TO_JSVAL(v);
} else if (gtype == G_TYPE_UCHAR) {
unsigned char v;
v = g_value_get_uchar(gvalue);
*value_p = INT_TO_JSVAL(v);
} else if (gtype == G_TYPE_INT) {
int v;
v = g_value_get_int(gvalue);
return JS_NewNumberValue(context, v, value_p);
} else if (gtype == G_TYPE_UINT) {
uint v;
v = g_value_get_uint(gvalue);
return JS_NewNumberValue(context, v, value_p);
} else if (gtype == G_TYPE_DOUBLE) {
double d;
d = g_value_get_double(gvalue);
return JS_NewNumberValue(context, d, value_p);
} else if (gtype == G_TYPE_FLOAT) {
double d;
d = g_value_get_float(gvalue);
return JS_NewNumberValue(context, d, value_p);
} else if (gtype == G_TYPE_BOOLEAN) {
gboolean v;
v = g_value_get_boolean(gvalue);
*value_p = BOOLEAN_TO_JSVAL(v);
} else if (g_type_is_a(gtype, G_TYPE_OBJECT) || g_type_is_a(gtype, G_TYPE_INTERFACE)) {
GObject *gobj;
JSObject *obj;
gobj = g_value_get_object(gvalue);
obj = gjs_object_from_g_object(context, gobj);
*value_p = OBJECT_TO_JSVAL(obj);
} else if (gtype == G_TYPE_STRV) {
if (!gjs_array_from_strv (context,
value_p,
g_value_get_boxed (gvalue))) {
gjs_throw(context, "Failed to convert strv to array");
return JS_FALSE;
}
} else if (g_type_is_a(gtype, G_TYPE_HASH_TABLE) ||
g_type_is_a(gtype, G_TYPE_ARRAY) ||
g_type_is_a(gtype, G_TYPE_BYTE_ARRAY) ||
g_type_is_a(gtype, G_TYPE_PTR_ARRAY)) {
gjs_throw(context,
"Unable to introspect element-type of container in GValue");
return JS_FALSE;
} else if (g_type_is_a(gtype, G_TYPE_BOXED) ||
g_type_is_a(gtype, G_TYPE_VARIANT)) {
GjsBoxedCreationFlags boxed_flags;
GIBaseInfo *info;
void *gboxed;
JSObject *obj;
if (g_type_is_a(gtype, G_TYPE_BOXED))
gboxed = g_value_get_boxed(gvalue);
else
gboxed = g_value_get_variant(gvalue);
boxed_flags = GJS_BOXED_CREATION_NONE;
/* special case GError */
if (g_type_is_a(gtype, G_TYPE_ERROR)) {
obj = gjs_error_from_gerror(context, gboxed, FALSE);
*value_p = OBJECT_TO_JSVAL(obj);
return TRUE;
}
/* The only way to differentiate unions and structs is from
* their g-i info as both GBoxed */
info = g_irepository_find_by_gtype(g_irepository_get_default(),
gtype);
if (info == NULL) {
gjs_throw(context,
"No introspection information found for %s",
g_type_name(gtype));
return JS_FALSE;
}
if (g_base_info_get_type(info) == GI_INFO_TYPE_STRUCT &&
g_struct_info_is_foreign((GIStructInfo*)info)) {
JSBool ret;
GIArgument arg;
arg.v_pointer = gboxed;
ret = gjs_struct_foreign_convert_from_g_argument(context, value_p, info, &arg);
g_base_info_unref(info);
return ret;
}
switch (g_base_info_get_type(info)) {
case GI_INFO_TYPE_BOXED:
case GI_INFO_TYPE_STRUCT:
if (no_copy)
boxed_flags |= GJS_BOXED_CREATION_NO_COPY;
obj = gjs_boxed_from_c_struct(context, (GIStructInfo *)info, gboxed, boxed_flags);
break;
case GI_INFO_TYPE_UNION:
obj = gjs_union_from_c_union(context, (GIUnionInfo *)info, gboxed);
break;
default:
gjs_throw(context,
"Unexpected introspection type %d for %s",
g_base_info_get_type(info),
g_type_name(gtype));
g_base_info_unref(info);
return JS_FALSE;
}
*value_p = OBJECT_TO_JSVAL(obj);
g_base_info_unref(info);
} else if (g_type_is_a(gtype, G_TYPE_ENUM)) {
return convert_int_to_enum(context, value_p, gtype, g_value_get_enum(gvalue));
} else if (g_type_is_a(gtype, G_TYPE_PARAM)) {
GParamSpec *gparam;
JSObject *obj;
gparam = g_value_get_param(gvalue);
obj = gjs_param_from_g_param(context, gparam);
*value_p = OBJECT_TO_JSVAL(obj);
} else if (signal_query && g_type_is_a(gtype, G_TYPE_POINTER)) {
JSBool res;
GArgument arg;
GIArgInfo *arg_info;
GIBaseInfo *obj;
GISignalInfo *signal_info;
GITypeInfo type_info;
obj = g_irepository_find_by_gtype(NULL, signal_query->itype);
if (!obj) {
gjs_throw(context, "Signal argument with GType %s isn't introspectable",
g_type_name(signal_query->itype));
return JS_FALSE;
}
signal_info = g_object_info_find_signal((GIObjectInfo*)obj, signal_query->signal_name);
if (!signal_info) {
gjs_throw(context, "Unknown signal.");
g_base_info_unref((GIBaseInfo*)obj);
return JS_FALSE;
}
arg_info = g_callable_info_get_arg(signal_info, arg_n - 1);
g_arg_info_load_type(arg_info, &type_info);
arg.v_pointer = g_value_get_pointer(gvalue);
res = gjs_value_from_g_argument(context, value_p, &type_info, &arg, TRUE);
g_base_info_unref((GIBaseInfo*)arg_info);
g_base_info_unref((GIBaseInfo*)signal_info);
g_base_info_unref((GIBaseInfo*)obj);
return res;
} else if (g_type_is_a(gtype, G_TYPE_POINTER)) {
gpointer pointer;
pointer = g_value_get_pointer(gvalue);
if (pointer == NULL) {
*value_p = JSVAL_NULL;
} else {
gjs_throw(context,
"Can't convert non-null pointer to JS value");
return JS_FALSE;
}
} else if (g_value_type_transformable(gtype, G_TYPE_DOUBLE)) {
GValue double_value = { 0, };
double v;
g_value_init(&double_value, G_TYPE_DOUBLE);
g_value_transform(gvalue, &double_value);
v = g_value_get_double(&double_value);
return JS_NewNumberValue(context, v, value_p);
} else if (g_value_type_transformable(gtype, G_TYPE_INT)) {
GValue int_value = { 0, };
int v;
g_value_init(&int_value, G_TYPE_INT);
g_value_transform(gvalue, &int_value);
v = g_value_get_int(&int_value);
return JS_NewNumberValue(context, v, value_p);
} else {
gjs_throw(context,
"Don't know how to convert GType %s to JavaScript object",
g_type_name(gtype));
return JS_FALSE;
}
return JS_TRUE;
}
gboolean
gvalue_util_set_value_from_string (GValue *value,
const char *str)
{
GValue tmp_value = {0, };
int i;
long l;
double d;
g_return_val_if_fail (str != NULL, FALSE);
switch (G_VALUE_TYPE (value)) {
case G_TYPE_STRING:
g_value_set_string (value, str);
break;
case G_TYPE_CHAR:
#if GLIB_CHECK_VERSION(2,32,0)
g_value_set_schar (value, *str);
#else
g_value_set_char (value, *str);
#endif
break;
case G_TYPE_UCHAR:
g_value_set_uchar (value, *str);
break;
case G_TYPE_INT:
i = atoi (str);
g_value_set_int (value, i);
break;
case G_TYPE_UINT:
i = atoi (str);
g_value_set_uint (value, (guint) i);
break;
case G_TYPE_INT64:
i = atoi (str);
g_value_set_int64 (value, (gint64) i);
break;
case G_TYPE_UINT64:
i = atoi (str);
g_value_set_uint64 (value, (guint64) i);
break;
case G_TYPE_LONG:
l = atol (str);
g_value_set_long (value, l);
break;
case G_TYPE_ULONG:
l = atol (str);
g_value_set_ulong (value, (gulong) l);
break;
case G_TYPE_FLOAT:
d = atof (str);
g_value_set_float (value, (float) d);
break;
case G_TYPE_DOUBLE:
d = atof (str);
g_value_set_float (value, d);
break;
case G_TYPE_BOOLEAN:
if (g_ascii_strcasecmp (str, "true") == 0 ||
g_ascii_strcasecmp (str, "yes") == 0)
g_value_set_boolean (value, TRUE);
else if (g_ascii_strcasecmp (str, "false") == 0 ||
g_ascii_strcasecmp (str, "no") == 0)
g_value_set_boolean (value, FALSE);
else {
int i;
i = atoi (str);
g_value_set_boolean (value, i ? TRUE : FALSE);
}
break;
default:
/* Try to convert */
if (g_value_type_transformable (G_TYPE_STRING,
G_VALUE_TYPE (value))) {
g_value_init (&tmp_value, G_TYPE_STRING);
g_value_set_static_string (&tmp_value, str);
g_value_transform (&tmp_value, value);
g_value_unset (&tmp_value);
} else if (g_value_type_transformable (G_TYPE_INT,
G_VALUE_TYPE (value))) {
i = atoi (str);
g_value_init (&tmp_value, G_TYPE_INT);
g_value_set_int (&tmp_value, i);
g_value_transform (&tmp_value, value);
g_value_unset (&tmp_value);
} else {
g_warning ("Failed to transform integer "
"value to type %s",
G_VALUE_TYPE_NAME (value));
return FALSE;
}
break;
}
return TRUE;
}
static gboolean
thunar_preferences_load_idle (gpointer user_data)
{
ThunarPreferences *preferences = THUNAR_PREFERENCES (user_data);
const gchar *string;
GParamSpec **specs;
GParamSpec *spec;
XfceRc *rc;
GValue dst = { 0, };
GValue src = { 0, };
gchar *option;
guint nspecs;
guint n;
rc = xfce_rc_config_open (XFCE_RESOURCE_CONFIG, "Thunar/thunarrc", TRUE);
if (G_UNLIKELY (rc == NULL))
{
g_warning ("Failed to load thunar preferences.");
return FALSE;
}
g_object_freeze_notify (G_OBJECT (preferences));
xfce_rc_set_group (rc, "Configuration");
preferences->loading_in_progress = TRUE;
specs = g_object_class_list_properties (G_OBJECT_GET_CLASS (preferences), &nspecs);
for (n = 0; n < nspecs; ++n)
{
spec = specs[n];
option = property_name_to_option_name (spec->name);
string = xfce_rc_read_entry (rc, option, NULL);
g_free (option);
if (G_UNLIKELY (string == NULL))
continue;
g_value_init (&src, G_TYPE_STRING);
g_value_set_static_string (&src, string);
if (spec->value_type == G_TYPE_STRING)
{
g_object_set_property (G_OBJECT (preferences), spec->name, &src);
}
else if (g_value_type_transformable (G_TYPE_STRING, spec->value_type))
{
g_value_init (&dst, spec->value_type);
if (g_value_transform (&src, &dst))
g_object_set_property (G_OBJECT (preferences), spec->name, &dst);
g_value_unset (&dst);
}
else
{
g_warning ("Failed to load property \"%s\"", spec->name);
}
g_value_unset (&src);
}
g_free (specs);
preferences->loading_in_progress = FALSE;
xfce_rc_close (rc);
g_object_thaw_notify (G_OBJECT (preferences));
return FALSE;
}
