forked from AuroraMiddleware/gtk
d1f4068b94
The only cases of stateful actions we've seen so far have been boolean properties, and we don't really want to add much state handling API, so lets just go with property actions for now. Adapt the only user in GtkText.
593 lines
18 KiB
C
593 lines
18 KiB
C
/*
|
||
* Copyright © 2010 Novell, Inc.
|
||
*
|
||
* This library is free software; you can redistribute it and/or
|
||
* modify it under the terms of the GNU Lesser General Public
|
||
* License as published by the Free Software Foundation; either
|
||
* version 2.1 of the License, or (at your option) any later version.
|
||
*
|
||
* This library is distributed in the hope that it will be useful,
|
||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||
* Lesser General Public License for more details.
|
||
*
|
||
* You should have received a copy of the GNU Lesser General Public
|
||
* License along with this library; if not, see <http://www.gnu.org/licenses/>.
|
||
*
|
||
* Author: Vincent Untz <vuntz@gnome.org>
|
||
*/
|
||
|
||
#include "config.h"
|
||
|
||
#include "gsettings-mapping.h"
|
||
|
||
static GVariant *
|
||
g_settings_set_mapping_int (const GValue *value,
|
||
const GVariantType *expected_type)
|
||
{
|
||
GVariant *variant = NULL;
|
||
gint64 l;
|
||
|
||
if (G_VALUE_HOLDS_INT (value))
|
||
l = g_value_get_int (value);
|
||
else if (G_VALUE_HOLDS_INT64 (value))
|
||
l = g_value_get_int64 (value);
|
||
else
|
||
return NULL;
|
||
|
||
if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_INT16))
|
||
{
|
||
if (G_MININT16 <= l && l <= G_MAXINT16)
|
||
variant = g_variant_new_int16 ((gint16) l);
|
||
}
|
||
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_UINT16))
|
||
{
|
||
if (0 <= l && l <= G_MAXUINT16)
|
||
variant = g_variant_new_uint16 ((guint16) l);
|
||
}
|
||
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_INT32))
|
||
{
|
||
if (G_MININT32 <= l && l <= G_MAXINT32)
|
||
variant = g_variant_new_int32 ((gint) l);
|
||
}
|
||
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_UINT32))
|
||
{
|
||
if (0 <= l && l <= G_MAXUINT32)
|
||
variant = g_variant_new_uint32 ((guint) l);
|
||
}
|
||
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_INT64))
|
||
{
|
||
if (G_MININT64 <= l && l <= G_MAXINT64)
|
||
variant = g_variant_new_int64 ((gint64) l);
|
||
}
|
||
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_UINT64))
|
||
{
|
||
if (0 <= l && l <= G_MAXUINT64)
|
||
variant = g_variant_new_uint64 ((guint64) l);
|
||
}
|
||
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_HANDLE))
|
||
{
|
||
if (0 <= l && l <= G_MAXUINT32)
|
||
variant = g_variant_new_handle ((guint) l);
|
||
}
|
||
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_DOUBLE))
|
||
variant = g_variant_new_double ((gdouble) l);
|
||
|
||
return variant;
|
||
}
|
||
|
||
static GVariant *
|
||
g_settings_set_mapping_float (const GValue *value,
|
||
const GVariantType *expected_type)
|
||
{
|
||
GVariant *variant = NULL;
|
||
gdouble d;
|
||
gint64 l;
|
||
|
||
if (G_VALUE_HOLDS_DOUBLE (value))
|
||
d = g_value_get_double (value);
|
||
else
|
||
return NULL;
|
||
|
||
l = (gint64) d;
|
||
if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_INT16))
|
||
{
|
||
if (G_MININT16 <= l && l <= G_MAXINT16)
|
||
variant = g_variant_new_int16 ((gint16) l);
|
||
}
|
||
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_UINT16))
|
||
{
|
||
if (0 <= l && l <= G_MAXUINT16)
|
||
variant = g_variant_new_uint16 ((guint16) l);
|
||
}
|
||
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_INT32))
|
||
{
|
||
if (G_MININT32 <= l && l <= G_MAXINT32)
|
||
variant = g_variant_new_int32 ((gint) l);
|
||
}
|
||
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_UINT32))
|
||
{
|
||
if (0 <= l && l <= G_MAXUINT32)
|
||
variant = g_variant_new_uint32 ((guint) l);
|
||
}
|
||
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_INT64))
|
||
{
|
||
if (G_MININT64 <= l && l <= G_MAXINT64)
|
||
variant = g_variant_new_int64 ((gint64) l);
|
||
}
|
||
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_UINT64))
|
||
{
|
||
if (0 <= l && l <= G_MAXUINT64)
|
||
variant = g_variant_new_uint64 ((guint64) l);
|
||
}
|
||
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_HANDLE))
|
||
{
|
||
if (0 <= l && l <= G_MAXUINT32)
|
||
variant = g_variant_new_handle ((guint) l);
|
||
}
|
||
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_DOUBLE))
|
||
variant = g_variant_new_double ((gdouble) d);
|
||
|
||
return variant;
|
||
}
|
||
static GVariant *
|
||
g_settings_set_mapping_unsigned_int (const GValue *value,
|
||
const GVariantType *expected_type)
|
||
{
|
||
GVariant *variant = NULL;
|
||
guint64 u;
|
||
|
||
if (G_VALUE_HOLDS_UINT (value))
|
||
u = g_value_get_uint (value);
|
||
else if (G_VALUE_HOLDS_UINT64 (value))
|
||
u = g_value_get_uint64 (value);
|
||
else
|
||
return NULL;
|
||
|
||
if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_INT16))
|
||
{
|
||
if (u <= G_MAXINT16)
|
||
variant = g_variant_new_int16 ((gint16) u);
|
||
}
|
||
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_UINT16))
|
||
{
|
||
if (u <= G_MAXUINT16)
|
||
variant = g_variant_new_uint16 ((guint16) u);
|
||
}
|
||
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_INT32))
|
||
{
|
||
if (u <= G_MAXINT32)
|
||
variant = g_variant_new_int32 ((gint) u);
|
||
}
|
||
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_UINT32))
|
||
{
|
||
if (u <= G_MAXUINT32)
|
||
variant = g_variant_new_uint32 ((guint) u);
|
||
}
|
||
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_INT64))
|
||
{
|
||
if (u <= G_MAXINT64)
|
||
variant = g_variant_new_int64 ((gint64) u);
|
||
}
|
||
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_UINT64))
|
||
{
|
||
if (u <= G_MAXUINT64)
|
||
variant = g_variant_new_uint64 ((guint64) u);
|
||
}
|
||
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_HANDLE))
|
||
{
|
||
if (u <= G_MAXUINT32)
|
||
variant = g_variant_new_handle ((guint) u);
|
||
}
|
||
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_DOUBLE))
|
||
variant = g_variant_new_double ((gdouble) u);
|
||
|
||
return variant;
|
||
}
|
||
|
||
static gboolean
|
||
g_settings_get_mapping_int (GValue *value,
|
||
GVariant *variant)
|
||
{
|
||
const GVariantType *type;
|
||
gint64 l;
|
||
|
||
type = g_variant_get_type (variant);
|
||
|
||
if (g_variant_type_equal (type, G_VARIANT_TYPE_INT16))
|
||
l = g_variant_get_int16 (variant);
|
||
else if (g_variant_type_equal (type, G_VARIANT_TYPE_INT32))
|
||
l = g_variant_get_int32 (variant);
|
||
else if (g_variant_type_equal (type, G_VARIANT_TYPE_INT64))
|
||
l = g_variant_get_int64 (variant);
|
||
else
|
||
return FALSE;
|
||
|
||
if (G_VALUE_HOLDS_INT (value))
|
||
{
|
||
g_value_set_int (value, l);
|
||
return (G_MININT32 <= l && l <= G_MAXINT32);
|
||
}
|
||
else if (G_VALUE_HOLDS_UINT (value))
|
||
{
|
||
g_value_set_uint (value, l);
|
||
return (0 <= l && l <= G_MAXUINT32);
|
||
}
|
||
else if (G_VALUE_HOLDS_INT64 (value))
|
||
{
|
||
g_value_set_int64 (value, l);
|
||
return (G_MININT64 <= l && l <= G_MAXINT64);
|
||
}
|
||
else if (G_VALUE_HOLDS_UINT64 (value))
|
||
{
|
||
g_value_set_uint64 (value, l);
|
||
return (0 <= l && l <= G_MAXUINT64);
|
||
}
|
||
else if (G_VALUE_HOLDS_DOUBLE (value))
|
||
{
|
||
g_value_set_double (value, l);
|
||
return TRUE;
|
||
}
|
||
|
||
return FALSE;
|
||
}
|
||
|
||
static gboolean
|
||
g_settings_get_mapping_float (GValue *value,
|
||
GVariant *variant)
|
||
{
|
||
const GVariantType *type;
|
||
gdouble d;
|
||
gint64 l;
|
||
|
||
type = g_variant_get_type (variant);
|
||
|
||
if (g_variant_type_equal (type, G_VARIANT_TYPE_DOUBLE))
|
||
d = g_variant_get_double (variant);
|
||
else
|
||
return FALSE;
|
||
|
||
l = (gint64)d;
|
||
if (G_VALUE_HOLDS_INT (value))
|
||
{
|
||
g_value_set_int (value, l);
|
||
return (G_MININT32 <= l && l <= G_MAXINT32);
|
||
}
|
||
else if (G_VALUE_HOLDS_UINT (value))
|
||
{
|
||
g_value_set_uint (value, l);
|
||
return (0 <= l && l <= G_MAXUINT32);
|
||
}
|
||
else if (G_VALUE_HOLDS_INT64 (value))
|
||
{
|
||
g_value_set_int64 (value, l);
|
||
return (G_MININT64 <= l && l <= G_MAXINT64);
|
||
}
|
||
else if (G_VALUE_HOLDS_UINT64 (value))
|
||
{
|
||
g_value_set_uint64 (value, l);
|
||
return (0 <= l && l <= G_MAXUINT64);
|
||
}
|
||
else if (G_VALUE_HOLDS_DOUBLE (value))
|
||
{
|
||
g_value_set_double (value, d);
|
||
return TRUE;
|
||
}
|
||
|
||
return FALSE;
|
||
}
|
||
static gboolean
|
||
g_settings_get_mapping_unsigned_int (GValue *value,
|
||
GVariant *variant)
|
||
{
|
||
const GVariantType *type;
|
||
guint64 u;
|
||
|
||
type = g_variant_get_type (variant);
|
||
|
||
if (g_variant_type_equal (type, G_VARIANT_TYPE_UINT16))
|
||
u = g_variant_get_uint16 (variant);
|
||
else if (g_variant_type_equal (type, G_VARIANT_TYPE_UINT32))
|
||
u = g_variant_get_uint32 (variant);
|
||
else if (g_variant_type_equal (type, G_VARIANT_TYPE_UINT64))
|
||
u = g_variant_get_uint64 (variant);
|
||
else if (g_variant_type_equal (type, G_VARIANT_TYPE_HANDLE))
|
||
u = g_variant_get_handle (variant);
|
||
else
|
||
return FALSE;
|
||
|
||
if (G_VALUE_HOLDS_INT (value))
|
||
{
|
||
g_value_set_int (value, u);
|
||
return (u <= G_MAXINT32);
|
||
}
|
||
else if (G_VALUE_HOLDS_UINT (value))
|
||
{
|
||
g_value_set_uint (value, u);
|
||
return (u <= G_MAXUINT32);
|
||
}
|
||
else if (G_VALUE_HOLDS_INT64 (value))
|
||
{
|
||
g_value_set_int64 (value, u);
|
||
return (u <= G_MAXINT64);
|
||
}
|
||
else if (G_VALUE_HOLDS_UINT64 (value))
|
||
{
|
||
g_value_set_uint64 (value, u);
|
||
return (u <= G_MAXUINT64);
|
||
}
|
||
else if (G_VALUE_HOLDS_DOUBLE (value))
|
||
{
|
||
g_value_set_double (value, u);
|
||
return TRUE;
|
||
}
|
||
|
||
return FALSE;
|
||
}
|
||
|
||
GVariant *
|
||
g_settings_set_mapping (const GValue *value,
|
||
const GVariantType *expected_type,
|
||
gpointer user_data)
|
||
{
|
||
gchar *type_string;
|
||
|
||
if (G_VALUE_HOLDS_BOOLEAN (value))
|
||
{
|
||
if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_BOOLEAN))
|
||
return g_variant_new_boolean (g_value_get_boolean (value));
|
||
}
|
||
|
||
else if (G_VALUE_HOLDS_CHAR (value) ||
|
||
G_VALUE_HOLDS_UCHAR (value))
|
||
{
|
||
if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_BYTE))
|
||
{
|
||
if (G_VALUE_HOLDS_CHAR (value))
|
||
return g_variant_new_byte (g_value_get_schar (value));
|
||
else
|
||
return g_variant_new_byte (g_value_get_uchar (value));
|
||
}
|
||
}
|
||
|
||
else if (G_VALUE_HOLDS_INT (value) ||
|
||
G_VALUE_HOLDS_INT64 (value))
|
||
return g_settings_set_mapping_int (value, expected_type);
|
||
|
||
else if (G_VALUE_HOLDS_DOUBLE (value))
|
||
return g_settings_set_mapping_float (value, expected_type);
|
||
|
||
else if (G_VALUE_HOLDS_UINT (value) ||
|
||
G_VALUE_HOLDS_UINT64 (value))
|
||
return g_settings_set_mapping_unsigned_int (value, expected_type);
|
||
|
||
else if (G_VALUE_HOLDS_STRING (value))
|
||
{
|
||
if (g_value_get_string (value) == NULL)
|
||
return NULL;
|
||
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_STRING))
|
||
return g_variant_new_string (g_value_get_string (value));
|
||
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_BYTESTRING))
|
||
return g_variant_new_bytestring (g_value_get_string (value));
|
||
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_OBJECT_PATH))
|
||
return g_variant_new_object_path (g_value_get_string (value));
|
||
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_SIGNATURE))
|
||
return g_variant_new_signature (g_value_get_string (value));
|
||
}
|
||
|
||
else if (G_VALUE_HOLDS (value, G_TYPE_STRV))
|
||
{
|
||
if (g_value_get_boxed (value) == NULL)
|
||
return NULL;
|
||
return g_variant_new_strv ((const gchar **) g_value_get_boxed (value),
|
||
-1);
|
||
}
|
||
|
||
else if (G_VALUE_HOLDS_ENUM (value))
|
||
{
|
||
GEnumValue *enumval;
|
||
GEnumClass *eclass;
|
||
|
||
/* GParamSpecEnum holds a ref on the class so we just peek... */
|
||
eclass = g_type_class_peek (G_VALUE_TYPE (value));
|
||
enumval = g_enum_get_value (eclass, g_value_get_enum (value));
|
||
|
||
if (enumval)
|
||
return g_variant_new_string (enumval->value_nick);
|
||
else
|
||
return NULL;
|
||
}
|
||
|
||
else if (G_VALUE_HOLDS_FLAGS (value))
|
||
{
|
||
GVariantBuilder builder;
|
||
GFlagsValue *flagsval;
|
||
GFlagsClass *fclass;
|
||
guint flags;
|
||
|
||
fclass = g_type_class_peek (G_VALUE_TYPE (value));
|
||
flags = g_value_get_flags (value);
|
||
|
||
g_variant_builder_init (&builder, G_VARIANT_TYPE ("as"));
|
||
while (flags)
|
||
{
|
||
flagsval = g_flags_get_first_value (fclass, flags);
|
||
|
||
if (flagsval == NULL)
|
||
{
|
||
g_variant_builder_clear (&builder);
|
||
return NULL;
|
||
}
|
||
|
||
g_variant_builder_add (&builder, "s", flagsval->value_nick);
|
||
flags &= ~flagsval->value;
|
||
}
|
||
|
||
return g_variant_builder_end (&builder);
|
||
}
|
||
|
||
type_string = g_variant_type_dup_string (expected_type);
|
||
g_critical ("No GSettings bind handler for type \"%s\".", type_string);
|
||
g_free (type_string);
|
||
|
||
return NULL;
|
||
}
|
||
|
||
gboolean
|
||
g_settings_get_mapping (GValue *value,
|
||
GVariant *variant,
|
||
gpointer user_data)
|
||
{
|
||
if (g_variant_is_of_type (variant, G_VARIANT_TYPE_BOOLEAN))
|
||
{
|
||
if (!G_VALUE_HOLDS_BOOLEAN (value))
|
||
return FALSE;
|
||
g_value_set_boolean (value, g_variant_get_boolean (variant));
|
||
return TRUE;
|
||
}
|
||
|
||
else if (g_variant_is_of_type (variant, G_VARIANT_TYPE_BYTE))
|
||
{
|
||
if (G_VALUE_HOLDS_UCHAR (value))
|
||
g_value_set_uchar (value, g_variant_get_byte (variant));
|
||
else if (G_VALUE_HOLDS_CHAR (value))
|
||
g_value_set_schar (value, (gint8)g_variant_get_byte (variant));
|
||
else
|
||
return FALSE;
|
||
return TRUE;
|
||
}
|
||
|
||
else if (g_variant_is_of_type (variant, G_VARIANT_TYPE_INT16) ||
|
||
g_variant_is_of_type (variant, G_VARIANT_TYPE_INT32) ||
|
||
g_variant_is_of_type (variant, G_VARIANT_TYPE_INT64))
|
||
return g_settings_get_mapping_int (value, variant);
|
||
|
||
else if (g_variant_is_of_type (variant, G_VARIANT_TYPE_DOUBLE))
|
||
return g_settings_get_mapping_float (value, variant);
|
||
|
||
else if (g_variant_is_of_type (variant, G_VARIANT_TYPE_UINT16) ||
|
||
g_variant_is_of_type (variant, G_VARIANT_TYPE_UINT32) ||
|
||
g_variant_is_of_type (variant, G_VARIANT_TYPE_UINT64) ||
|
||
g_variant_is_of_type (variant, G_VARIANT_TYPE_HANDLE))
|
||
return g_settings_get_mapping_unsigned_int (value, variant);
|
||
|
||
else if (g_variant_is_of_type (variant, G_VARIANT_TYPE_STRING) ||
|
||
g_variant_is_of_type (variant, G_VARIANT_TYPE_OBJECT_PATH) ||
|
||
g_variant_is_of_type (variant, G_VARIANT_TYPE_SIGNATURE))
|
||
{
|
||
if (G_VALUE_HOLDS_STRING (value))
|
||
{
|
||
g_value_set_string (value, g_variant_get_string (variant, NULL));
|
||
return TRUE;
|
||
}
|
||
|
||
else if (G_VALUE_HOLDS_ENUM (value))
|
||
{
|
||
GEnumClass *eclass;
|
||
GEnumValue *evalue;
|
||
const gchar *nick;
|
||
|
||
/* GParamSpecEnum holds a ref on the class so we just peek... */
|
||
eclass = g_type_class_peek (G_VALUE_TYPE (value));
|
||
nick = g_variant_get_string (variant, NULL);
|
||
evalue = g_enum_get_value_by_nick (eclass, nick);
|
||
|
||
if (evalue)
|
||
{
|
||
g_value_set_enum (value, evalue->value);
|
||
return TRUE;
|
||
}
|
||
|
||
g_warning ("Unable to look up enum nick ‘%s’ via GType", nick);
|
||
return FALSE;
|
||
}
|
||
}
|
||
else if (g_variant_is_of_type (variant, G_VARIANT_TYPE ("as")))
|
||
{
|
||
if (G_VALUE_HOLDS (value, G_TYPE_STRV))
|
||
{
|
||
g_value_take_boxed (value, g_variant_dup_strv (variant, NULL));
|
||
return TRUE;
|
||
}
|
||
|
||
else if (G_VALUE_HOLDS_FLAGS (value))
|
||
{
|
||
GFlagsClass *fclass;
|
||
GFlagsValue *fvalue;
|
||
const gchar *nick;
|
||
GVariantIter iter;
|
||
guint flags = 0;
|
||
|
||
fclass = g_type_class_peek (G_VALUE_TYPE (value));
|
||
|
||
g_variant_iter_init (&iter, variant);
|
||
while (g_variant_iter_next (&iter, "&s", &nick))
|
||
{
|
||
fvalue = g_flags_get_value_by_nick (fclass, nick);
|
||
|
||
if (fvalue)
|
||
flags |= fvalue->value;
|
||
|
||
else
|
||
{
|
||
g_warning ("Unable to lookup flags nick '%s' via GType",
|
||
nick);
|
||
return FALSE;
|
||
}
|
||
}
|
||
|
||
g_value_set_flags (value, flags);
|
||
return TRUE;
|
||
}
|
||
}
|
||
else if (g_variant_is_of_type (variant, G_VARIANT_TYPE_BYTESTRING))
|
||
{
|
||
g_value_set_string (value, g_variant_get_bytestring (variant));
|
||
return TRUE;
|
||
}
|
||
|
||
g_critical ("No GSettings bind handler for type \"%s\".",
|
||
g_variant_get_type_string (variant));
|
||
|
||
return FALSE;
|
||
}
|
||
|
||
gboolean
|
||
g_settings_mapping_is_compatible (GType gvalue_type,
|
||
const GVariantType *variant_type)
|
||
{
|
||
gboolean ok = FALSE;
|
||
|
||
if (gvalue_type == G_TYPE_BOOLEAN)
|
||
ok = g_variant_type_equal (variant_type, G_VARIANT_TYPE_BOOLEAN);
|
||
else if (gvalue_type == G_TYPE_CHAR ||
|
||
gvalue_type == G_TYPE_UCHAR)
|
||
ok = g_variant_type_equal (variant_type, G_VARIANT_TYPE_BYTE);
|
||
else if (gvalue_type == G_TYPE_INT ||
|
||
gvalue_type == G_TYPE_UINT ||
|
||
gvalue_type == G_TYPE_INT64 ||
|
||
gvalue_type == G_TYPE_UINT64 ||
|
||
gvalue_type == G_TYPE_DOUBLE)
|
||
ok = (g_variant_type_equal (variant_type, G_VARIANT_TYPE_INT16) ||
|
||
g_variant_type_equal (variant_type, G_VARIANT_TYPE_UINT16) ||
|
||
g_variant_type_equal (variant_type, G_VARIANT_TYPE_INT32) ||
|
||
g_variant_type_equal (variant_type, G_VARIANT_TYPE_UINT32) ||
|
||
g_variant_type_equal (variant_type, G_VARIANT_TYPE_INT64) ||
|
||
g_variant_type_equal (variant_type, G_VARIANT_TYPE_UINT64) ||
|
||
g_variant_type_equal (variant_type, G_VARIANT_TYPE_HANDLE) ||
|
||
g_variant_type_equal (variant_type, G_VARIANT_TYPE_DOUBLE));
|
||
else if (gvalue_type == G_TYPE_STRING)
|
||
ok = (g_variant_type_equal (variant_type, G_VARIANT_TYPE_STRING) ||
|
||
g_variant_type_equal (variant_type, G_VARIANT_TYPE ("ay")) ||
|
||
g_variant_type_equal (variant_type, G_VARIANT_TYPE_OBJECT_PATH) ||
|
||
g_variant_type_equal (variant_type, G_VARIANT_TYPE_SIGNATURE));
|
||
else if (gvalue_type == G_TYPE_STRV)
|
||
ok = g_variant_type_equal (variant_type, G_VARIANT_TYPE ("as"));
|
||
else if (G_TYPE_IS_ENUM (gvalue_type))
|
||
ok = g_variant_type_equal (variant_type, G_VARIANT_TYPE_STRING);
|
||
else if (G_TYPE_IS_FLAGS (gvalue_type))
|
||
ok = g_variant_type_equal (variant_type, G_VARIANT_TYPE ("as"));
|
||
|
||
return ok;
|
||
}
|