| /* |
| * 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 of the licence, 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 lookup enum nick '%s' via GType\n", 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\n", |
| 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; |
| } |
