G_GNUC_UNUSED static gboolean
_g_value_equal (const GValue *a, const GValue *b)
{
gboolean ret = FALSE;
g_assert (G_VALUE_TYPE (a) == G_VALUE_TYPE (b));
switch (G_VALUE_TYPE (a))
{
case G_TYPE_BOOLEAN:
ret = (g_value_get_boolean (a) == g_value_get_boolean (b));
break;
case G_TYPE_UCHAR:
ret = (g_value_get_uchar (a) == g_value_get_uchar (b));
break;
case G_TYPE_INT:
ret = (g_value_get_int (a) == g_value_get_int (b));
break;
case G_TYPE_UINT:
ret = (g_value_get_uint (a) == g_value_get_uint (b));
break;
case G_TYPE_INT64:
ret = (g_value_get_int64 (a) == g_value_get_int64 (b));
break;
case G_TYPE_UINT64:
ret = (g_value_get_uint64 (a) == g_value_get_uint64 (b));
break;
case G_TYPE_DOUBLE:
{
/* Avoid -Wfloat-equal warnings by doing a direct bit compare */
gdouble da = g_value_get_double (a);
gdouble db = g_value_get_double (b);
ret = memcmp (&da, &db, sizeof (gdouble)) == 0;
}
break;
case G_TYPE_STRING:
ret = (g_strcmp0 (g_value_get_string (a), g_value_get_string (b)) == 0);
break;
case G_TYPE_VARIANT:
ret = _g_variant_equal0 (g_value_get_variant (a), g_value_get_variant (b));
break;
default:
if (G_VALUE_TYPE (a) == G_TYPE_STRV)
ret = _g_strv_equal0 (g_value_get_boxed (a), g_value_get_boxed (b));
else
g_critical ("_g_value_equal() does not handle type %s", g_type_name (G_VALUE_TYPE (a)));
break;
}
return ret;
}
static void
gtk_button_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
GtkButton *button = GTK_BUTTON (object);
switch (prop_id)
{
case PROP_LABEL:
gtk_button_set_label (button, g_value_get_string (value));
break;
case PROP_RELIEF:
gtk_button_set_relief (button, g_value_get_enum (value));
break;
case PROP_USE_UNDERLINE:
gtk_button_set_use_underline (button, g_value_get_boolean (value));
break;
case PROP_ICON_NAME:
gtk_button_set_icon_name (button, g_value_get_string (value));
break;
case PROP_ACTION_NAME:
gtk_button_set_action_name (GTK_ACTIONABLE (button), g_value_get_string (value));
break;
case PROP_ACTION_TARGET:
gtk_button_set_action_target_value (GTK_ACTIONABLE (button), g_value_get_variant (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
cc_sound_panel_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec)
{
CcSoundPanel *self = CC_SOUND_PANEL (object);
switch (property_id) {
case PROP_PARAMETERS: {
GVariant *parameters;
parameters = g_value_get_variant (value);
if (parameters && g_variant_n_children (parameters) > 1) {
GVariant *v;
/* Skip the first child, we don't expect any flag */
g_variant_get_child (parameters, 1, "v", &v);
gvc_mixer_dialog_set_page (self->dialog, g_variant_get_string (v, NULL));
g_variant_unref (v);
}
break;
}
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
}
}
GVariant *signon_hash_table_to_variant (const GHashTable *hash_table)
{
GVariantBuilder builder;
GHashTableIter iter;
const gchar *key;
const GValue *value;
if (hash_table == NULL) return NULL;
g_variant_builder_init (&builder, G_VARIANT_TYPE_VARDICT);
g_hash_table_iter_init (&iter, (GHashTable *)hash_table);
while (g_hash_table_iter_next (&iter, (gpointer)&key, (gpointer)&value))
{
GVariant *val;
if (G_VALUE_TYPE (value) == G_TYPE_VARIANT)
{
val = g_value_get_variant (value);
}
else
{
const GVariantType *type;
type = signon_gtype_to_variant_type (G_VALUE_TYPE (value));
val = g_dbus_gvalue_to_gvariant (value, type);
}
g_variant_builder_add (&builder, "{sv}", key, val);
}
return g_variant_builder_end (&builder);
}
static void
workman_attribute_set_property(GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
WorkmanAttribute *self = WORKMAN_ATTRIBUTE(object);
WorkmanState state;
switch (prop_id) {
case PROP_NAME:
self->priv->name = g_value_dup_string(value);
break;
case PROP_VALUE:
workman_attribute_set_value(self,
g_value_get_variant(value),
NULL);
break;
case PROP_WRITABLE:
self->priv->writable = g_value_get_boolean(value);
break;
case PROP_STATE:
state = g_value_get_flags(value);
g_return_if_fail(state != WORKMAN_STATE_ALL);
self->priv->state = state;
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
break;
}
}
static void
cc_wacom_panel_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec)
{
CcWacomPanel *self;
self = CC_WACOM_PANEL (object);
switch (property_id)
{
case PROP_PARAMETERS: {
GVariant *parameters;
parameters = g_value_get_variant (value);
if (parameters == NULL || g_variant_n_children (parameters) <= 1)
return;
run_operation_from_params (self, parameters);
break;
}
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
}
}
static void
gtk_switch_set_property (GObject *gobject,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
GtkSwitch *sw = GTK_SWITCH (gobject);
switch (prop_id)
{
case PROP_ACTIVE:
gtk_switch_set_active (sw, g_value_get_boolean (value));
break;
case PROP_STATE:
gtk_switch_set_state (sw, g_value_get_boolean (value));
break;
case PROP_ACTION_NAME:
gtk_switch_set_action_name (GTK_ACTIONABLE (sw), g_value_get_string (value));
break;
case PROP_ACTION_TARGET:
gtk_switch_set_action_target_value (GTK_ACTIONABLE (sw), g_value_get_variant (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
}
}
static GVariant*
_settings_map_set_variant (const GValue *value,
const GVariantType *expected_type,
gpointer user_data)
{
g_return_val_if_fail (g_variant_is_of_type (g_value_get_variant (value), expected_type), NULL);
return g_value_dup_variant (value);
}
static void
g_simple_action_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
GSimpleAction *simple = G_SIMPLE_ACTION (object);
switch (prop_id)
{
case PROP_NAME:
g_assert (simple->priv->name == NULL);
simple->priv->name = g_value_dup_string (value);
break;
case PROP_PARAMETER_TYPE:
g_assert (simple->priv->parameter_type == NULL);
simple->priv->parameter_type = g_value_dup_boxed (value);
break;
case PROP_ENABLED:
g_simple_action_set_enabled (simple, g_value_get_boolean (value));
break;
case PROP_STATE:
/* PROP_STATE is marked as G_PARAM_CONSTRUCT so we always get a
* call during object construction, even if it is NULL. We treat
* that first call differently, for a number of reasons.
*
* First, we don't want the value to be rejected by the
* possibly-overridden .set_state() function. Second, we don't
* want to be tripped by the assertions in g_simple_action_set_state()
* that would enforce the catch22 that we only provide a value of
* the same type as the existing value (when there is not yet an
* existing value).
*/
if (simple->priv->state_set)
g_simple_action_set_state (G_ACTION (simple),
g_value_get_variant (value));
else /* this is the special case */
{
/* only do it the first time. */
simple->priv->state_set = TRUE;
/* blindly set it. */
simple->priv->state = g_value_dup_variant (value);
}
break;
default:
g_assert_not_reached ();
}
}
void scp_tree_data_from_value(ScpTreeData *data, GValue *value, gboolean copy)
{
switch (scp_tree_data_get_fundamental_type(G_VALUE_TYPE(value)))
{
case G_TYPE_INT : data->v_int = g_value_get_int(value); break;
case G_TYPE_UINT : data->v_uint = g_value_get_uint(value); break;
case G_TYPE_STRING :
{
data->v_string = copy ? g_value_dup_string(value) :
(char *) g_value_get_string(value);
break;
}
case G_TYPE_BOOLEAN : data->v_int = g_value_get_boolean(value); break;
case G_TYPE_LONG : data->v_long = g_value_get_long(value); break;
case G_TYPE_ULONG : data->v_ulong = g_value_get_ulong(value); break;
case G_TYPE_FLOAT : data->v_float = g_value_get_float(value); break;
case G_TYPE_DOUBLE : data->v_double = g_value_get_double(value); break;
#if GLIB_CHECK_VERSION(2, 32, 0)
case G_TYPE_CHAR : data->v_char = g_value_get_schar(value); break;
#else
case G_TYPE_CHAR : data->v_char = g_value_get_char(value); break;
#endif
case G_TYPE_UCHAR : data->v_uchar = g_value_get_uchar(value); break;
case G_TYPE_INT64 : data->v_int64 = g_value_get_int64(value); break;
case G_TYPE_UINT64 : data->v_uint64 = g_value_get_uint64(value); break;
case G_TYPE_ENUM : data->v_int = g_value_get_enum(value); break;
case G_TYPE_FLAGS : data->v_uint = g_value_get_flags(value); break;
case G_TYPE_POINTER : data->v_pointer = g_value_get_pointer(value); break;
case G_TYPE_OBJECT :
{
data->v_pointer = copy ? g_value_dup_object(value) :
g_value_get_object(value);
break;
}
case G_TYPE_BOXED :
{
data->v_pointer = copy ? g_value_dup_boxed(value) :
g_value_get_boxed(value);
break;
}
#if GLIB_CHECK_VERSION(2, 26, 0)
case G_TYPE_VARIANT :
{
data->v_pointer = copy ? g_value_dup_variant(value) :
g_value_get_variant(value);
break;
}
#endif
default : scp_tree_data_warn_unsupported_type(G_STRFUNC, G_VALUE_TYPE(value));
}
}
static void
cc_keyboard_panel_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec)
{
CcKeyboardPanel *panel = CC_KEYBOARD_PANEL (object);
switch (property_id)
{
case PROP_PARAMETERS: {
GVariant *parameters, *v;
const gchar *page, *section;
parameters = g_value_get_variant (value);
if (!parameters)
break;
page = section = NULL;
switch (g_variant_n_children (parameters))
{
case 3:
g_variant_get_child (parameters, 2, "v", &v);
section = g_variant_get_string (v, NULL);
g_variant_unref (v);
/* fall-through */
case 2:
g_variant_get_child (parameters, 1, "v", &v);
page = g_variant_get_string (v, NULL);
g_variant_unref (v);
cc_keyboard_panel_set_page (panel, page, section);
/* fall-through */
case 1:
/* No flags expected, fall-through */
case 0:
break;
default:
g_warning ("Unexpected parameters found, ignore request");
}
break;
}
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
}
}
static void g_cclosure_user_marshal_VOID__STRING_VARIANT (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data) {
typedef void (*GMarshalFunc_VOID__STRING_VARIANT) (gpointer data1, const char* arg_1, gpointer arg_2, gpointer data2);
register GMarshalFunc_VOID__STRING_VARIANT callback;
register GCClosure * cc;
register gpointer data1;
register gpointer data2;
cc = (GCClosure *) closure;
g_return_if_fail (n_param_values == 3);
if (G_CCLOSURE_SWAP_DATA (closure)) {
data1 = closure->data;
data2 = param_values->data[0].v_pointer;
} else {
data1 = param_values->data[0].v_pointer;
data2 = closure->data;
}
callback = (GMarshalFunc_VOID__STRING_VARIANT) (marshal_data ? marshal_data : cc->callback);
callback (data1, g_value_get_string (param_values + 1), g_value_get_variant (param_values + 2), data2);
}
static void
_ncm_matrix_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
{
NcmMatrix *m = NCM_MATRIX (object);
g_return_if_fail (NCM_IS_MATRIX (object));
switch (prop_id)
{
case PROP_VALS:
{
GVariant *var = g_value_get_variant (value);
ncm_matrix_set_from_variant (m, var);
break;
}
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
gb_preferences_switch_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
GbPreferencesSwitch *self = GB_PREFERENCES_SWITCH (object);
switch (prop_id)
{
case PROP_TITLE:
gtk_label_set_label (self->title_label, g_value_get_string (value));
break;
case PROP_DESCRIPTION:
gtk_label_set_label (self->description_label, g_value_get_string (value));
break;
case PROP_IS_RADIO:
gb_preferences_switch_set_is_radio (self, g_value_get_boolean (value));
break;
case PROP_SETTINGS:
gb_preferences_switch_set_settings (self, g_value_get_object (value));
break;
case PROP_SETTINGS_SCHEMA_KEY:
gb_preferences_switch_set_settings_schema_key (self, g_value_get_string (value));
break;
case PROP_SETTINGS_SCHEMA_VALUE:
gb_preferences_switch_set_settings_schema_value (self, g_value_get_variant (value));
break;
case PROP_SIZE_GROUP:
gb_preferences_switch_set_size_group (self, g_value_get_object (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
}
static void
photos_tool_filter_button_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
{
PhotosToolFilterButton *self = PHOTOS_TOOL_FILTER_BUTTON (object);
switch (prop_id)
{
case PROP_GROUP:
self->group = GTK_RADIO_BUTTON (g_value_get_object (value));
break;
case PROP_LABEL:
self->label = g_value_dup_string (value);
break;
case PROP_ACTION_NAME:
{
const gchar *action_name;
action_name = g_value_get_string (value);
photos_tool_filter_button_set_action_name (GTK_ACTIONABLE (self), action_name);
break;
}
case PROP_ACTION_TARGET:
{
GVariant *action_target;
action_target = g_value_get_variant (value);
photos_tool_filter_button_set_action_target_value (GTK_ACTIONABLE (self), action_target);
break;
}
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
dbus_signal_meta_marshal (GClosure *closure,
GValue *return_value,
guint n_param_values,
const GValue *param_values,
gpointer invocation_hint,
gpointer marshal_data)
{
NMDBusSignalData *sd = marshal_data;
const char *signal_name;
GVariant *parameters, *param;
GValue *closure_params;
gsize n_params, i;
g_return_if_fail (n_param_values == 4);
signal_name = g_value_get_string (¶m_values[2]);
parameters = g_value_get_variant (¶m_values[3]);
if (strcmp (signal_name, sd->signal_name) != 0)
return;
if (sd->signature) {
if (!g_variant_is_of_type (parameters, sd->signature)) {
g_warning ("%p: got signal '%s' but parameters were of type '%s', not '%s'",
g_value_get_object (¶m_values[0]),
signal_name, g_variant_get_type_string (parameters),
g_variant_type_peek_string (sd->signature));
return;
}
n_params = g_variant_n_children (parameters) + 1;
} else
n_params = 1;
closure_params = g_new0 (GValue, n_params);
g_value_init (&closure_params[0], G_TYPE_OBJECT);
g_value_copy (¶m_values[0], &closure_params[0]);
for (i = 1; i < n_params; i++) {
param = g_variant_get_child_value (parameters, i - 1);
if ( g_variant_is_of_type (param, G_VARIANT_TYPE ("ay"))
|| g_variant_is_of_type (param, G_VARIANT_TYPE ("aay"))) {
/* g_dbus_gvariant_to_gvalue() thinks 'ay' means "non-UTF-8 NUL-terminated string" */
g_value_init (&closure_params[i], G_TYPE_VARIANT);
g_value_set_variant (&closure_params[i], param);
} else
g_dbus_gvariant_to_gvalue (param, &closure_params[i]);
g_variant_unref (param);
}
g_cclosure_marshal_generic (closure,
NULL,
n_params,
closure_params,
invocation_hint,
NULL);
for (i = 0; i < n_params; i++)
g_value_unset (&closure_params[i]);
g_free (closure_params);
}
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;
}
