/** * 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; }