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

Source (jump to first uncovered line)
/*
 * 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 && (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
    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 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;
}

Coverage Report

Created: 2025-07-01 07:09

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