/src/glib/gio/gsettings-mapping.c

Source (jump to first uncovered line)
/*
 * Copyright © 2010 Novell, Inc.
 *
 * SPDX-License-Identifier: LGPL-2.1-or-later
 *
 * 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 && (guint64) 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 && (guint64) 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 if (g_variant_type_equal (type, G_VARIANT_TYPE_HANDLE))
    l = g_variant_get_handle (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 && (guint64) 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 && (guint64) 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
    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)  ||
           g_variant_is_of_type (variant, G_VARIANT_TYPE_HANDLE))
    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))
    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;
}

Coverage Report

Created: 2025-06-13 06:55

Line	Count	Source (jump to first uncovered line)
1		/*
2		* Copyright © 2010 Novell, Inc.
3		*
4		* SPDX-License-Identifier: LGPL-2.1-or-later
5		*
6		* This library is free software; you can redistribute it and/or
7		* modify it under the terms of the GNU Lesser General Public
8		* License as published by the Free Software Foundation; either
9		* version 2.1 of the License, or (at your option) any later version.
10		*
11		* This library is distributed in the hope that it will be useful,
12		* but WITHOUT ANY WARRANTY; without even the implied warranty of
13		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14		* Lesser General Public License for more details.
15		*
16		* You should have received a copy of the GNU Lesser General Public
17		* License along with this library; if not, see <http://www.gnu.org/licenses/>.
18		*
19		* Author: Vincent Untz <vuntz@gnome.org>
20		*/
21
22		#include "config.h"
23
24		#include "gsettings-mapping.h"
25
26		static GVariant *
27		g_settings_set_mapping_int (const GValue *value,
28		const GVariantType *expected_type)
29	0	{
30	0	GVariant *variant = NULL;
31	0	gint64 l;
32
33	0	if (G_VALUE_HOLDS_INT (value))
34	0	l = g_value_get_int (value);
35	0	else if (G_VALUE_HOLDS_INT64 (value))
36	0	l = g_value_get_int64 (value);
37	0	else
38	0	return NULL;
39
40	0	if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_INT16))
41	0	{
42	0	if (G_MININT16 <= l && l <= G_MAXINT16)
43	0	variant = g_variant_new_int16 ((gint16) l);
44	0	}
45	0	else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_UINT16))
46	0	{
47	0	if (0 <= l && l <= G_MAXUINT16)
48	0	variant = g_variant_new_uint16 ((guint16) l);
49	0	}
50	0	else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_INT32))
51	0	{
52	0	if (G_MININT32 <= l && l <= G_MAXINT32)
53	0	variant = g_variant_new_int32 ((gint) l);
54	0	}
55	0	else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_UINT32))
56	0	{
57	0	if (0 <= l && l <= G_MAXUINT32)
58	0	variant = g_variant_new_uint32 ((guint) l);
59	0	}
60	0	else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_INT64))
61	0	{
62	0	if (G_MININT64 <= l && l <= G_MAXINT64)
63	0	variant = g_variant_new_int64 ((gint64) l);
64	0	}
65	0	else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_UINT64))
66	0	{
67	0	if (0 <= l && (guint64) l <= G_MAXUINT64)
68	0	variant = g_variant_new_uint64 ((guint64) l);
69	0	}
70	0	else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_HANDLE))
71	0	{
72	0	if (0 <= l && l <= G_MAXUINT32)
73	0	variant = g_variant_new_handle ((guint) l);
74	0	}
75	0	else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_DOUBLE))
76	0	variant = g_variant_new_double ((gdouble) l);
77
78	0	return variant;
79	0	}
80
81		static GVariant *
82		g_settings_set_mapping_float (const GValue *value,
83		const GVariantType *expected_type)
84	0	{
85	0	GVariant *variant = NULL;
86	0	gdouble d;
87	0	gint64 l;
88
89	0	if (G_VALUE_HOLDS_DOUBLE (value))
90	0	d = g_value_get_double (value);
91	0	else
92	0	return NULL;
93
94	0	l = (gint64) d;
95	0	if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_INT16))
96	0	{
97	0	if (G_MININT16 <= l && l <= G_MAXINT16)
98	0	variant = g_variant_new_int16 ((gint16) l);
99	0	}
100	0	else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_UINT16))
101	0	{
102	0	if (0 <= l && l <= G_MAXUINT16)
103	0	variant = g_variant_new_uint16 ((guint16) l);
104	0	}
105	0	else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_INT32))
106	0	{
107	0	if (G_MININT32 <= l && l <= G_MAXINT32)
108	0	variant = g_variant_new_int32 ((gint) l);
109	0	}
110	0	else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_UINT32))
111	0	{
112	0	if (0 <= l && l <= G_MAXUINT32)
113	0	variant = g_variant_new_uint32 ((guint) l);
114	0	}
115	0	else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_INT64))
116	0	{
117	0	if (G_MININT64 <= l && l <= G_MAXINT64)
118	0	variant = g_variant_new_int64 ((gint64) l);
119	0	}
120	0	else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_UINT64))
121	0	{
122	0	if (0 <= l && (guint64) l <= G_MAXUINT64)
123	0	variant = g_variant_new_uint64 ((guint64) l);
124	0	}
125	0	else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_HANDLE))
126	0	{
127	0	if (0 <= l && l <= G_MAXUINT32)
128	0	variant = g_variant_new_handle ((guint) l);
129	0	}
130	0	else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_DOUBLE))
131	0	variant = g_variant_new_double ((gdouble) d);
132
133	0	return variant;
134	0	}
135		static GVariant *
136		g_settings_set_mapping_unsigned_int (const GValue *value,
137		const GVariantType *expected_type)
138	0	{
139	0	GVariant *variant = NULL;
140	0	guint64 u;
141
142	0	if (G_VALUE_HOLDS_UINT (value))
143	0	u = g_value_get_uint (value);
144	0	else if (G_VALUE_HOLDS_UINT64 (value))
145	0	u = g_value_get_uint64 (value);
146	0	else
147	0	return NULL;
148
149	0	if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_INT16))
150	0	{
151	0	if (u <= G_MAXINT16)
152	0	variant = g_variant_new_int16 ((gint16) u);
153	0	}
154	0	else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_UINT16))
155	0	{
156	0	if (u <= G_MAXUINT16)
157	0	variant = g_variant_new_uint16 ((guint16) u);
158	0	}
159	0	else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_INT32))
160	0	{
161	0	if (u <= G_MAXINT32)
162	0	variant = g_variant_new_int32 ((gint) u);
163	0	}
164	0	else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_UINT32))
165	0	{
166	0	if (u <= G_MAXUINT32)
167	0	variant = g_variant_new_uint32 ((guint) u);
168	0	}
169	0	else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_INT64))
170	0	{
171	0	if (u <= G_MAXINT64)
172	0	variant = g_variant_new_int64 ((gint64) u);
173	0	}
174	0	else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_UINT64))
175	0	{
176	0	if (u <= G_MAXUINT64)
177	0	variant = g_variant_new_uint64 ((guint64) u);
178	0	}
179	0	else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_HANDLE))
180	0	{
181	0	if (u <= G_MAXUINT32)
182	0	variant = g_variant_new_handle ((guint) u);
183	0	}
184	0	else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_DOUBLE))
185	0	variant = g_variant_new_double ((gdouble) u);
186
187	0	return variant;
188	0	}
189
190		static gboolean
191		g_settings_get_mapping_int (GValue *value,
192		GVariant *variant)
193	0	{
194	0	const GVariantType *type;
195	0	gint64 l;
196
197	0	type = g_variant_get_type (variant);
198
199	0	if (g_variant_type_equal (type, G_VARIANT_TYPE_INT16))
200	0	l = g_variant_get_int16 (variant);
201	0	else if (g_variant_type_equal (type, G_VARIANT_TYPE_INT32))
202	0	l = g_variant_get_int32 (variant);
203	0	else if (g_variant_type_equal (type, G_VARIANT_TYPE_INT64))
204	0	l = g_variant_get_int64 (variant);
205	0	else if (g_variant_type_equal (type, G_VARIANT_TYPE_HANDLE))
206	0	l = g_variant_get_handle (variant);
207	0	else
208	0	return FALSE;
209
210	0	if (G_VALUE_HOLDS_INT (value))
211	0	{
212	0	g_value_set_int (value, l);
213	0	return (G_MININT32 <= l && l <= G_MAXINT32);
214	0	}
215	0	else if (G_VALUE_HOLDS_UINT (value))
216	0	{
217	0	g_value_set_uint (value, l);
218	0	return (0 <= l && l <= G_MAXUINT32);
219	0	}
220	0	else if (G_VALUE_HOLDS_INT64 (value))
221	0	{
222	0	g_value_set_int64 (value, l);
223	0	return (G_MININT64 <= l && l <= G_MAXINT64);
224	0	}
225	0	else if (G_VALUE_HOLDS_UINT64 (value))
226	0	{
227	0	g_value_set_uint64 (value, l);
228	0	return (0 <= l && (guint64) l <= G_MAXUINT64);
229	0	}
230	0	else if (G_VALUE_HOLDS_DOUBLE (value))
231	0	{
232	0	g_value_set_double (value, l);
233	0	return TRUE;
234	0	}
235
236	0	return FALSE;
237	0	}
238
239		static gboolean
240		g_settings_get_mapping_float (GValue *value,
241		GVariant *variant)
242	0	{
243	0	const GVariantType *type;
244	0	gdouble d;
245	0	gint64 l;
246
247	0	type = g_variant_get_type (variant);
248
249	0	if (g_variant_type_equal (type, G_VARIANT_TYPE_DOUBLE))
250	0	d = g_variant_get_double (variant);
251	0	else
252	0	return FALSE;
253
254	0	l = (gint64)d;
255	0	if (G_VALUE_HOLDS_INT (value))
256	0	{
257	0	g_value_set_int (value, l);
258	0	return (G_MININT32 <= l && l <= G_MAXINT32);
259	0	}
260	0	else if (G_VALUE_HOLDS_UINT (value))
261	0	{
262	0	g_value_set_uint (value, l);
263	0	return (0 <= l && l <= G_MAXUINT32);
264	0	}
265	0	else if (G_VALUE_HOLDS_INT64 (value))
266	0	{
267	0	g_value_set_int64 (value, l);
268	0	return (G_MININT64 <= l && l <= G_MAXINT64);
269	0	}
270	0	else if (G_VALUE_HOLDS_UINT64 (value))
271	0	{
272	0	g_value_set_uint64 (value, l);
273	0	return (0 <= l && (guint64) l <= G_MAXUINT64);
274	0	}
275	0	else if (G_VALUE_HOLDS_DOUBLE (value))
276	0	{
277	0	g_value_set_double (value, d);
278	0	return TRUE;
279	0	}
280
281	0	return FALSE;
282	0	}
283		static gboolean
284		g_settings_get_mapping_unsigned_int (GValue *value,
285		GVariant *variant)
286	0	{
287	0	const GVariantType *type;
288	0	guint64 u;
289
290	0	type = g_variant_get_type (variant);
291
292	0	if (g_variant_type_equal (type, G_VARIANT_TYPE_UINT16))
293	0	u = g_variant_get_uint16 (variant);
294	0	else if (g_variant_type_equal (type, G_VARIANT_TYPE_UINT32))
295	0	u = g_variant_get_uint32 (variant);
296	0	else if (g_variant_type_equal (type, G_VARIANT_TYPE_UINT64))
297	0	u = g_variant_get_uint64 (variant);
298	0	else
299	0	return FALSE;
300
301	0	if (G_VALUE_HOLDS_INT (value))
302	0	{
303	0	g_value_set_int (value, u);
304	0	return (u <= G_MAXINT32);
305	0	}
306	0	else if (G_VALUE_HOLDS_UINT (value))
307	0	{
308	0	g_value_set_uint (value, u);
309	0	return (u <= G_MAXUINT32);
310	0	}
311	0	else if (G_VALUE_HOLDS_INT64 (value))
312	0	{
313	0	g_value_set_int64 (value, u);
314	0	return (u <= G_MAXINT64);
315	0	}
316	0	else if (G_VALUE_HOLDS_UINT64 (value))
317	0	{
318	0	g_value_set_uint64 (value, u);
319	0	return (u <= G_MAXUINT64);
320	0	}
321	0	else if (G_VALUE_HOLDS_DOUBLE (value))
322	0	{
323	0	g_value_set_double (value, u);
324	0	return TRUE;
325	0	}
326
327	0	return FALSE;
328	0	}
329
330		GVariant *
331		g_settings_set_mapping (const GValue *value,
332		const GVariantType *expected_type,
333		gpointer user_data)
334	0	{
335	0	gchar *type_string;
336
337	0	if (G_VALUE_HOLDS_BOOLEAN (value))
338	0	{
339	0	if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_BOOLEAN))
340	0	return g_variant_new_boolean (g_value_get_boolean (value));
341	0	}
342
343	0	else if (G_VALUE_HOLDS_CHAR (value) \|\|
344	0	G_VALUE_HOLDS_UCHAR (value))
345	0	{
346	0	if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_BYTE))
347	0	{
348	0	if (G_VALUE_HOLDS_CHAR (value))
349	0	return g_variant_new_byte (g_value_get_schar (value));
350	0	else
351	0	return g_variant_new_byte (g_value_get_uchar (value));
352	0	}
353	0	}
354
355	0	else if (G_VALUE_HOLDS_INT (value) \|\|
356	0	G_VALUE_HOLDS_INT64 (value))
357	0	return g_settings_set_mapping_int (value, expected_type);
358
359	0	else if (G_VALUE_HOLDS_DOUBLE (value))
360	0	return g_settings_set_mapping_float (value, expected_type);
361
362	0	else if (G_VALUE_HOLDS_UINT (value) \|\|
363	0	G_VALUE_HOLDS_UINT64 (value))
364	0	return g_settings_set_mapping_unsigned_int (value, expected_type);
365
366	0	else if (G_VALUE_HOLDS_STRING (value))
367	0	{
368	0	if (g_value_get_string (value) == NULL)
369	0	return NULL;
370	0	else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_STRING))
371	0	return g_variant_new_string (g_value_get_string (value));
372	0	else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_BYTESTRING))
373	0	return g_variant_new_bytestring (g_value_get_string (value));
374	0	else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_OBJECT_PATH))
375	0	return g_variant_new_object_path (g_value_get_string (value));
376	0	else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_SIGNATURE))
377	0	return g_variant_new_signature (g_value_get_string (value));
378	0	}
379
380	0	else if (G_VALUE_HOLDS (value, G_TYPE_STRV))
381	0	{
382	0	if (g_value_get_boxed (value) == NULL)
383	0	return NULL;
384	0	return g_variant_new_strv ((const gchar **) g_value_get_boxed (value),
385	0	-1);
386	0	}
387
388	0	else if (G_VALUE_HOLDS_ENUM (value))
389	0	{
390	0	GEnumValue *enumval;
391	0	GEnumClass *eclass;
392
393		/* GParamSpecEnum holds a ref on the class so we just peek... */
394	0	eclass = g_type_class_peek (G_VALUE_TYPE (value));
395	0	enumval = g_enum_get_value (eclass, g_value_get_enum (value));
396
397	0	if (enumval)
398	0	return g_variant_new_string (enumval->value_nick);
399	0	else
400	0	return NULL;
401	0	}
402
403	0	else if (G_VALUE_HOLDS_FLAGS (value))
404	0	{
405	0	GVariantBuilder builder;
406	0	GFlagsValue *flagsval;
407	0	GFlagsClass *fclass;
408	0	guint flags;
409
410	0	fclass = g_type_class_peek (G_VALUE_TYPE (value));
411	0	flags = g_value_get_flags (value);
412
413	0	g_variant_builder_init (&builder, G_VARIANT_TYPE ("as"));
414	0	while (flags)
415	0	{
416	0	flagsval = g_flags_get_first_value (fclass, flags);
417
418	0	if (flagsval == NULL)
419	0	{
420	0	g_variant_builder_clear (&builder);
421	0	return NULL;
422	0	}
423
424	0	g_variant_builder_add (&builder, "s", flagsval->value_nick);
425	0	flags &= ~flagsval->value;
426	0	}
427
428	0	return g_variant_builder_end (&builder);
429	0	}
430
431	0	type_string = g_variant_type_dup_string (expected_type);
432	0	g_critical ("No GSettings bind handler for type \"%s\".", type_string);
433	0	g_free (type_string);
434
435	0	return NULL;
436	0	}
437
438		gboolean
439		g_settings_get_mapping (GValue *value,
440		GVariant *variant,
441		gpointer user_data)
442	0	{
443	0	if (g_variant_is_of_type (variant, G_VARIANT_TYPE_BOOLEAN))
444	0	{
445	0	if (!G_VALUE_HOLDS_BOOLEAN (value))
446	0	return FALSE;
447	0	g_value_set_boolean (value, g_variant_get_boolean (variant));
448	0	return TRUE;
449	0	}
450
451	0	else if (g_variant_is_of_type (variant, G_VARIANT_TYPE_BYTE))
452	0	{
453	0	if (G_VALUE_HOLDS_UCHAR (value))
454	0	g_value_set_uchar (value, g_variant_get_byte (variant));
455	0	else if (G_VALUE_HOLDS_CHAR (value))
456	0	g_value_set_schar (value, (gint8)g_variant_get_byte (variant));
457	0	else
458	0	return FALSE;
459	0	return TRUE;
460	0	}
461
462	0	else if (g_variant_is_of_type (variant, G_VARIANT_TYPE_INT16) \|\|
463	0	g_variant_is_of_type (variant, G_VARIANT_TYPE_INT32) \|\|
464	0	g_variant_is_of_type (variant, G_VARIANT_TYPE_INT64) \|\|
465	0	g_variant_is_of_type (variant, G_VARIANT_TYPE_HANDLE))
466	0	return g_settings_get_mapping_int (value, variant);
467
468	0	else if (g_variant_is_of_type (variant, G_VARIANT_TYPE_DOUBLE))
469	0	return g_settings_get_mapping_float (value, variant);
470
471	0	else if (g_variant_is_of_type (variant, G_VARIANT_TYPE_UINT16) \|\|
472	0	g_variant_is_of_type (variant, G_VARIANT_TYPE_UINT32) \|\|
473	0	g_variant_is_of_type (variant, G_VARIANT_TYPE_UINT64))
474	0	return g_settings_get_mapping_unsigned_int (value, variant);
475
476	0	else if (g_variant_is_of_type (variant, G_VARIANT_TYPE_STRING) \|\|
477	0	g_variant_is_of_type (variant, G_VARIANT_TYPE_OBJECT_PATH) \|\|
478	0	g_variant_is_of_type (variant, G_VARIANT_TYPE_SIGNATURE))
479	0	{
480	0	if (G_VALUE_HOLDS_STRING (value))
481	0	{
482	0	g_value_set_string (value, g_variant_get_string (variant, NULL));
483	0	return TRUE;
484	0	}
485
486	0	else if (G_VALUE_HOLDS_ENUM (value))
487	0	{
488	0	GEnumClass *eclass;
489	0	GEnumValue *evalue;
490	0	const gchar *nick;
491
492		/* GParamSpecEnum holds a ref on the class so we just peek... */
493	0	eclass = g_type_class_peek (G_VALUE_TYPE (value));
494	0	nick = g_variant_get_string (variant, NULL);
495	0	evalue = g_enum_get_value_by_nick (eclass, nick);
496
497	0	if (evalue)
498	0	{
499	0	g_value_set_enum (value, evalue->value);
500	0	return TRUE;
501	0	}
502
503	0	g_warning ("Unable to look up enum nick ‘%s’ via GType", nick);
504	0	return FALSE;
505	0	}
506	0	}
507	0	else if (g_variant_is_of_type (variant, G_VARIANT_TYPE ("as")))
508	0	{
509	0	if (G_VALUE_HOLDS (value, G_TYPE_STRV))
510	0	{
511	0	g_value_take_boxed (value, g_variant_dup_strv (variant, NULL));
512	0	return TRUE;
513	0	}
514
515	0	else if (G_VALUE_HOLDS_FLAGS (value))
516	0	{
517	0	GFlagsClass *fclass;
518	0	GFlagsValue *fvalue;
519	0	const gchar *nick;
520	0	GVariantIter iter;
521	0	guint flags = 0;
522
523	0	fclass = g_type_class_peek (G_VALUE_TYPE (value));
524
525	0	g_variant_iter_init (&iter, variant);
526	0	while (g_variant_iter_next (&iter, "&s", &nick))
527	0	{
528	0	fvalue = g_flags_get_value_by_nick (fclass, nick);
529
530	0	if (fvalue)
531	0	flags \|= fvalue->value;
532
533	0	else
534	0	{
535	0	g_warning ("Unable to lookup flags nick '%s' via GType",
536	0	nick);
537	0	return FALSE;
538	0	}
539	0	}
540
541	0	g_value_set_flags (value, flags);
542	0	return TRUE;
543	0	}
544	0	}
545	0	else if (g_variant_is_of_type (variant, G_VARIANT_TYPE_BYTESTRING))
546	0	{
547	0	g_value_set_string (value, g_variant_get_bytestring (variant));
548	0	return TRUE;
549	0	}
550
551	0	g_critical ("No GSettings bind handler for type \"%s\".",
552	0	g_variant_get_type_string (variant));
553
554	0	return FALSE;
555	0	}
556
557		gboolean
558		g_settings_mapping_is_compatible (GType gvalue_type,
559		const GVariantType *variant_type)
560	0	{
561	0	gboolean ok = FALSE;
562
563	0	if (gvalue_type == G_TYPE_BOOLEAN)
564	0	ok = g_variant_type_equal (variant_type, G_VARIANT_TYPE_BOOLEAN);
565	0	else if (gvalue_type == G_TYPE_CHAR \|\|
566	0	gvalue_type == G_TYPE_UCHAR)
567	0	ok = g_variant_type_equal (variant_type, G_VARIANT_TYPE_BYTE);
568	0	else if (gvalue_type == G_TYPE_INT \|\|
569	0	gvalue_type == G_TYPE_UINT \|\|
570	0	gvalue_type == G_TYPE_INT64 \|\|
571	0	gvalue_type == G_TYPE_UINT64 \|\|
572	0	gvalue_type == G_TYPE_DOUBLE)
573	0	ok = (g_variant_type_equal (variant_type, G_VARIANT_TYPE_INT16) \|\|
574	0	g_variant_type_equal (variant_type, G_VARIANT_TYPE_UINT16) \|\|
575	0	g_variant_type_equal (variant_type, G_VARIANT_TYPE_INT32) \|\|
576	0	g_variant_type_equal (variant_type, G_VARIANT_TYPE_UINT32) \|\|
577	0	g_variant_type_equal (variant_type, G_VARIANT_TYPE_INT64) \|\|
578	0	g_variant_type_equal (variant_type, G_VARIANT_TYPE_UINT64) \|\|
579	0	g_variant_type_equal (variant_type, G_VARIANT_TYPE_HANDLE) \|\|
580	0	g_variant_type_equal (variant_type, G_VARIANT_TYPE_DOUBLE));
581	0	else if (gvalue_type == G_TYPE_STRING)
582	0	ok = (g_variant_type_equal (variant_type, G_VARIANT_TYPE_STRING) \|\|
583	0	g_variant_type_equal (variant_type, G_VARIANT_TYPE ("ay")) \|\|
584	0	g_variant_type_equal (variant_type, G_VARIANT_TYPE_OBJECT_PATH) \|\|
585	0	g_variant_type_equal (variant_type, G_VARIANT_TYPE_SIGNATURE));
586	0	else if (gvalue_type == G_TYPE_STRV)
587	0	ok = g_variant_type_equal (variant_type, G_VARIANT_TYPE ("as"));
588	0	else if (G_TYPE_IS_ENUM (gvalue_type))
589	0	ok = g_variant_type_equal (variant_type, G_VARIANT_TYPE_STRING);
590	0	else if (G_TYPE_IS_FLAGS (gvalue_type))
591	0	ok = g_variant_type_equal (variant_type, G_VARIANT_TYPE ("as"));
592
593	0	return ok;
594	0	}