diff -r 000000000000 -r e4d67989cc36 glib/libgobject/src/gparamspecs.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/glib/libgobject/src/gparamspecs.c Tue Feb 02 02:01:42 2010 +0200 @@ -0,0 +1,2072 @@ +/* GObject - GLib Type, Object, Parameter and Signal Library + * Copyright (C) 1997-1999, 2000-2001 Tim Janik and Red Hat, Inc. + * Portions copyright (c) 2006 Nokia Corporation. All rights reserved. + * + * 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 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, write to the + * Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307, USA. + */ + +/* + * MT safe + */ +#ifdef __SYMBIAN32__ +#include "config.h" +#else +#include "../config.h" +#endif + +#include "gparamspecs.h" + +#include "gvaluecollector.h" +#include "gvaluearray.h" +#include "gobjectalias.h" +#include + +#ifdef __SYMBIAN32__ +#include +#endif /* __SYMBIAN32__ */ + + +#define G_FLOAT_EPSILON (1e-30) +#define G_DOUBLE_EPSILON (1e-90) + +#if EMULATOR + +PLS(g_param_spec_types ,gparamspecs,GType *) +#define g_param_spec_types (*FUNCTION_NAME(g_param_spec_types ,gparamspecs)()) + +#endif /* EMULATOR */ + + +/* --- param spec functions --- */ +static void +param_char_init (GParamSpec *pspec) +{ + GParamSpecChar *cspec = G_PARAM_SPEC_CHAR (pspec); + + cspec->minimum = 0x7f; + cspec->maximum = 0x80; + cspec->default_value = 0; +} + +static void +param_char_set_default (GParamSpec *pspec, + GValue *value) +{ + value->data[0].v_int = G_PARAM_SPEC_CHAR (pspec)->default_value; +} + +static gboolean +param_char_validate (GParamSpec *pspec, + GValue *value) +{ + GParamSpecChar *cspec = G_PARAM_SPEC_CHAR (pspec); + gint oval = value->data[0].v_int; + + value->data[0].v_int = CLAMP (value->data[0].v_int, cspec->minimum, cspec->maximum); + + return value->data[0].v_int != oval; +} + +static void +param_uchar_init (GParamSpec *pspec) +{ + GParamSpecUChar *uspec = G_PARAM_SPEC_UCHAR (pspec); + + uspec->minimum = 0; + uspec->maximum = 0xff; + uspec->default_value = 0; +} + +static void +param_uchar_set_default (GParamSpec *pspec, + GValue *value) +{ + value->data[0].v_uint = G_PARAM_SPEC_UCHAR (pspec)->default_value; +} + +static gboolean +param_uchar_validate (GParamSpec *pspec, + GValue *value) +{ + GParamSpecUChar *uspec = G_PARAM_SPEC_UCHAR (pspec); + guint oval = value->data[0].v_uint; + + value->data[0].v_uint = CLAMP (value->data[0].v_uint, uspec->minimum, uspec->maximum); + + return value->data[0].v_uint != oval; +} + +static void +param_boolean_set_default (GParamSpec *pspec, + GValue *value) +{ + value->data[0].v_int = G_PARAM_SPEC_BOOLEAN (pspec)->default_value; +} + +static gboolean +param_boolean_validate (GParamSpec *pspec, + GValue *value) +{ + gint oval = value->data[0].v_int; + + value->data[0].v_int = value->data[0].v_int != FALSE; + + return value->data[0].v_int != oval; +} + +static void +param_int_init (GParamSpec *pspec) +{ + GParamSpecInt *ispec = G_PARAM_SPEC_INT (pspec); + + ispec->minimum = 0x7fffffff; + ispec->maximum = 0x80000000; + ispec->default_value = 0; +} + +static void +param_int_set_default (GParamSpec *pspec, + GValue *value) +{ + value->data[0].v_int = G_PARAM_SPEC_INT (pspec)->default_value; +} + +static gboolean +param_int_validate (GParamSpec *pspec, + GValue *value) +{ + GParamSpecInt *ispec = G_PARAM_SPEC_INT (pspec); + gint oval = value->data[0].v_int; + + value->data[0].v_int = CLAMP (value->data[0].v_int, ispec->minimum, ispec->maximum); + + return value->data[0].v_int != oval; +} + +static gint +param_int_values_cmp (GParamSpec *pspec, + const GValue *value1, + const GValue *value2) +{ + if (value1->data[0].v_int < value2->data[0].v_int) + return -1; + else + return value1->data[0].v_int > value2->data[0].v_int; +} + +static void +param_uint_init (GParamSpec *pspec) +{ + GParamSpecUInt *uspec = G_PARAM_SPEC_UINT (pspec); + + uspec->minimum = 0; + uspec->maximum = 0xffffffff; + uspec->default_value = 0; +} + +static void +param_uint_set_default (GParamSpec *pspec, + GValue *value) +{ + value->data[0].v_uint = G_PARAM_SPEC_UINT (pspec)->default_value; +} + +static gboolean +param_uint_validate (GParamSpec *pspec, + GValue *value) +{ + GParamSpecUInt *uspec = G_PARAM_SPEC_UINT (pspec); + guint oval = value->data[0].v_uint; + + value->data[0].v_uint = CLAMP (value->data[0].v_uint, uspec->minimum, uspec->maximum); + + return value->data[0].v_uint != oval; +} + +static gint +param_uint_values_cmp (GParamSpec *pspec, + const GValue *value1, + const GValue *value2) +{ + if (value1->data[0].v_uint < value2->data[0].v_uint) + return -1; + else + return value1->data[0].v_uint > value2->data[0].v_uint; +} + +static void +param_long_init (GParamSpec *pspec) +{ + GParamSpecLong *lspec = G_PARAM_SPEC_LONG (pspec); + +#if SIZEOF_LONG == 4 + lspec->minimum = 0x7fffffff; + lspec->maximum = 0x80000000; +#else /* SIZEOF_LONG != 4 (8) */ + lspec->minimum = 0x7fffffffffffffff; + lspec->maximum = 0x8000000000000000; +#endif + lspec->default_value = 0; +} + +static void +param_long_set_default (GParamSpec *pspec, + GValue *value) +{ + value->data[0].v_long = G_PARAM_SPEC_LONG (pspec)->default_value; +} + +static gboolean +param_long_validate (GParamSpec *pspec, + GValue *value) +{ + GParamSpecLong *lspec = G_PARAM_SPEC_LONG (pspec); + glong oval = value->data[0].v_long; + + value->data[0].v_long = CLAMP (value->data[0].v_long, lspec->minimum, lspec->maximum); + + return value->data[0].v_long != oval; +} + +static gint +param_long_values_cmp (GParamSpec *pspec, + const GValue *value1, + const GValue *value2) +{ + if (value1->data[0].v_long < value2->data[0].v_long) + return -1; + else + return value1->data[0].v_long > value2->data[0].v_long; +} + +static void +param_ulong_init (GParamSpec *pspec) +{ + GParamSpecULong *uspec = G_PARAM_SPEC_ULONG (pspec); + + uspec->minimum = 0; +#if SIZEOF_LONG == 4 + uspec->maximum = 0xffffffff; +#else /* SIZEOF_LONG != 4 (8) */ + uspec->maximum = 0xffffffffffffffff; +#endif + uspec->default_value = 0; +} + +static void +param_ulong_set_default (GParamSpec *pspec, + GValue *value) +{ + value->data[0].v_ulong = G_PARAM_SPEC_ULONG (pspec)->default_value; +} + +static gboolean +param_ulong_validate (GParamSpec *pspec, + GValue *value) +{ + GParamSpecULong *uspec = G_PARAM_SPEC_ULONG (pspec); + gulong oval = value->data[0].v_ulong; + + value->data[0].v_ulong = CLAMP (value->data[0].v_ulong, uspec->minimum, uspec->maximum); + + return value->data[0].v_ulong != oval; +} + +static gint +param_ulong_values_cmp (GParamSpec *pspec, + const GValue *value1, + const GValue *value2) +{ + if (value1->data[0].v_ulong < value2->data[0].v_ulong) + return -1; + else + return value1->data[0].v_ulong > value2->data[0].v_ulong; +} + +static void +param_int64_init (GParamSpec *pspec) +{ + GParamSpecInt64 *lspec = G_PARAM_SPEC_INT64 (pspec); + + lspec->minimum = G_MININT64; + lspec->maximum = G_MAXINT64; + lspec->default_value = 0; +} + +static void +param_int64_set_default (GParamSpec *pspec, + GValue *value) +{ + value->data[0].v_int64 = G_PARAM_SPEC_INT64 (pspec)->default_value; +} + +static gboolean +param_int64_validate (GParamSpec *pspec, + GValue *value) +{ + GParamSpecInt64 *lspec = G_PARAM_SPEC_INT64 (pspec); + gint64 oval = value->data[0].v_int64; + + value->data[0].v_int64 = CLAMP (value->data[0].v_int64, lspec->minimum, lspec->maximum); + + return value->data[0].v_int64 != oval; +} + +static gint +param_int64_values_cmp (GParamSpec *pspec, + const GValue *value1, + const GValue *value2) +{ + if (value1->data[0].v_int64 < value2->data[0].v_int64) + return -1; + else + return value1->data[0].v_int64 > value2->data[0].v_int64; +} + +static void +param_uint64_init (GParamSpec *pspec) +{ + GParamSpecUInt64 *uspec = G_PARAM_SPEC_UINT64 (pspec); + + uspec->minimum = 0; + uspec->maximum = G_MAXUINT64; + uspec->default_value = 0; +} + +static void +param_uint64_set_default (GParamSpec *pspec, + GValue *value) +{ + value->data[0].v_uint64 = G_PARAM_SPEC_UINT64 (pspec)->default_value; +} + +static gboolean +param_uint64_validate (GParamSpec *pspec, + GValue *value) +{ + GParamSpecUInt64 *uspec = G_PARAM_SPEC_UINT64 (pspec); + guint64 oval = value->data[0].v_uint64; + + value->data[0].v_uint64 = CLAMP (value->data[0].v_uint64, uspec->minimum, uspec->maximum); + + return value->data[0].v_uint64 != oval; +} + +static gint +param_uint64_values_cmp (GParamSpec *pspec, + const GValue *value1, + const GValue *value2) +{ + if (value1->data[0].v_uint64 < value2->data[0].v_uint64) + return -1; + else + return value1->data[0].v_uint64 > value2->data[0].v_uint64; +} + +static void +param_unichar_init (GParamSpec *pspec) +{ + GParamSpecUnichar *uspec = G_PARAM_SPEC_UNICHAR (pspec); + + uspec->default_value = 0; +} + +static void +param_unichar_set_default (GParamSpec *pspec, + GValue *value) +{ + value->data[0].v_uint = G_PARAM_SPEC_UNICHAR (pspec)->default_value; +} + +static gboolean +param_unichar_validate (GParamSpec *pspec, + GValue *value) +{ + gunichar oval = value->data[0].v_uint; + gboolean changed = FALSE; + + if (!g_unichar_validate (oval)) + { + value->data[0].v_uint = 0; + changed = TRUE; + } + + return changed; +} + +static gint +param_unichar_values_cmp (GParamSpec *pspec, + const GValue *value1, + const GValue *value2) +{ + if (value1->data[0].v_uint < value2->data[0].v_uint) + return -1; + else + return value1->data[0].v_uint > value2->data[0].v_uint; +} + +static void +param_enum_init (GParamSpec *pspec) +{ + GParamSpecEnum *espec = G_PARAM_SPEC_ENUM (pspec); + + espec->enum_class = NULL; + espec->default_value = 0; +} + +static void +param_enum_finalize (GParamSpec *pspec) +{ + GParamSpecEnum *espec = G_PARAM_SPEC_ENUM (pspec); + GParamSpecClass *parent_class = g_type_class_peek (g_type_parent (G_TYPE_PARAM_ENUM)); + + if (espec->enum_class) + { + g_type_class_unref (espec->enum_class); + espec->enum_class = NULL; + } + + parent_class->finalize (pspec); +} + +static void +param_enum_set_default (GParamSpec *pspec, + GValue *value) +{ + value->data[0].v_long = G_PARAM_SPEC_ENUM (pspec)->default_value; +} + +static gboolean +param_enum_validate (GParamSpec *pspec, + GValue *value) +{ + GParamSpecEnum *espec = G_PARAM_SPEC_ENUM (pspec); + glong oval = value->data[0].v_long; + + if (!espec->enum_class || + !g_enum_get_value (espec->enum_class, value->data[0].v_long)) + value->data[0].v_long = espec->default_value; + + return value->data[0].v_long != oval; +} + +static void +param_flags_init (GParamSpec *pspec) +{ + GParamSpecFlags *fspec = G_PARAM_SPEC_FLAGS (pspec); + + fspec->flags_class = NULL; + fspec->default_value = 0; +} + +static void +param_flags_finalize (GParamSpec *pspec) +{ + GParamSpecFlags *fspec = G_PARAM_SPEC_FLAGS (pspec); + GParamSpecClass *parent_class = g_type_class_peek (g_type_parent (G_TYPE_PARAM_FLAGS)); + + if (fspec->flags_class) + { + g_type_class_unref (fspec->flags_class); + fspec->flags_class = NULL; + } + + parent_class->finalize (pspec); +} + +static void +param_flags_set_default (GParamSpec *pspec, + GValue *value) +{ + value->data[0].v_ulong = G_PARAM_SPEC_FLAGS (pspec)->default_value; +} + +static gboolean +param_flags_validate (GParamSpec *pspec, + GValue *value) +{ + GParamSpecFlags *fspec = G_PARAM_SPEC_FLAGS (pspec); + gulong oval = value->data[0].v_ulong; + + if (fspec->flags_class) + value->data[0].v_ulong &= fspec->flags_class->mask; + else + value->data[0].v_ulong = fspec->default_value; + + return value->data[0].v_ulong != oval; +} + +static void +param_float_init (GParamSpec *pspec) +{ + GParamSpecFloat *fspec = G_PARAM_SPEC_FLOAT (pspec); + + fspec->minimum = -G_MAXFLOAT; + fspec->maximum = G_MAXFLOAT; + fspec->default_value = 0; + fspec->epsilon = G_FLOAT_EPSILON; +} + +static void +param_float_set_default (GParamSpec *pspec, + GValue *value) +{ + value->data[0].v_float = G_PARAM_SPEC_FLOAT (pspec)->default_value; +} + +static gboolean +param_float_validate (GParamSpec *pspec, + GValue *value) +{ + GParamSpecFloat *fspec = G_PARAM_SPEC_FLOAT (pspec); + gfloat oval = value->data[0].v_float; + + value->data[0].v_float = CLAMP (value->data[0].v_float, fspec->minimum, fspec->maximum); + + return value->data[0].v_float != oval; +} + +static gint +param_float_values_cmp (GParamSpec *pspec, + const GValue *value1, + const GValue *value2) +{ + gfloat epsilon = G_PARAM_SPEC_FLOAT (pspec)->epsilon; + + if (value1->data[0].v_float < value2->data[0].v_float) + return - (value2->data[0].v_float - value1->data[0].v_float > epsilon); + else + return value1->data[0].v_float - value2->data[0].v_float > epsilon; +} + +static void +param_double_init (GParamSpec *pspec) +{ + GParamSpecDouble *dspec = G_PARAM_SPEC_DOUBLE (pspec); + + dspec->minimum = -G_MAXDOUBLE; + dspec->maximum = G_MAXDOUBLE; + dspec->default_value = 0; + dspec->epsilon = G_DOUBLE_EPSILON; +} + +static void +param_double_set_default (GParamSpec *pspec, + GValue *value) +{ + value->data[0].v_double = G_PARAM_SPEC_DOUBLE (pspec)->default_value; +} + +static gboolean +param_double_validate (GParamSpec *pspec, + GValue *value) +{ + GParamSpecDouble *dspec = G_PARAM_SPEC_DOUBLE (pspec); + gdouble oval = value->data[0].v_double; + + value->data[0].v_double = CLAMP (value->data[0].v_double, dspec->minimum, dspec->maximum); + + return value->data[0].v_double != oval; +} + +static gint +param_double_values_cmp (GParamSpec *pspec, + const GValue *value1, + const GValue *value2) +{ + gdouble epsilon = G_PARAM_SPEC_DOUBLE (pspec)->epsilon; + + if (value1->data[0].v_double < value2->data[0].v_double) + return - (value2->data[0].v_double - value1->data[0].v_double > epsilon); + else + return value1->data[0].v_double - value2->data[0].v_double > epsilon; +} + +static void +param_string_init (GParamSpec *pspec) +{ + GParamSpecString *sspec = G_PARAM_SPEC_STRING (pspec); + + sspec->default_value = NULL; + sspec->cset_first = NULL; + sspec->cset_nth = NULL; + sspec->substitutor = '_'; + sspec->null_fold_if_empty = FALSE; + sspec->ensure_non_null = FALSE; +} + +static void +param_string_finalize (GParamSpec *pspec) +{ + GParamSpecString *sspec = G_PARAM_SPEC_STRING (pspec); + GParamSpecClass *parent_class = g_type_class_peek (g_type_parent (G_TYPE_PARAM_STRING)); + + g_free (sspec->default_value); + g_free (sspec->cset_first); + g_free (sspec->cset_nth); + sspec->default_value = NULL; + sspec->cset_first = NULL; + sspec->cset_nth = NULL; + + parent_class->finalize (pspec); +} + +static void +param_string_set_default (GParamSpec *pspec, + GValue *value) +{ + value->data[0].v_pointer = g_strdup (G_PARAM_SPEC_STRING (pspec)->default_value); +} + +static gboolean +param_string_validate (GParamSpec *pspec, + GValue *value) +{ + GParamSpecString *sspec = G_PARAM_SPEC_STRING (pspec); + gchar *string = value->data[0].v_pointer; + guint changed = 0; + + if (string && string[0]) + { + gchar *s; + + if (sspec->cset_first && !strchr (sspec->cset_first, string[0])) + { + string[0] = sspec->substitutor; + changed++; + } + if (sspec->cset_nth) + for (s = string + 1; *s; s++) + if (!strchr (sspec->cset_nth, *s)) + { + *s = sspec->substitutor; + changed++; + } + } + if (sspec->null_fold_if_empty && string && string[0] == 0) + { + g_free (value->data[0].v_pointer); + value->data[0].v_pointer = NULL; + changed++; + string = value->data[0].v_pointer; + } + if (sspec->ensure_non_null && !string) + { + value->data[0].v_pointer = g_strdup (""); + changed++; + string = value->data[0].v_pointer; + } + + return changed; +} + +static gint +param_string_values_cmp (GParamSpec *pspec, + const GValue *value1, + const GValue *value2) +{ + if (!value1->data[0].v_pointer) + return value2->data[0].v_pointer != NULL ? -1 : 0; + else if (!value2->data[0].v_pointer) + return value1->data[0].v_pointer != NULL; + else + return strcmp (value1->data[0].v_pointer, value2->data[0].v_pointer); +} + +static void +param_param_init (GParamSpec *pspec) +{ + /* GParamSpecParam *spec = G_PARAM_SPEC_PARAM (pspec); */ +} + +static void +param_param_set_default (GParamSpec *pspec, + GValue *value) +{ + value->data[0].v_pointer = NULL; +} + +static gboolean +param_param_validate (GParamSpec *pspec, + GValue *value) +{ + /* GParamSpecParam *spec = G_PARAM_SPEC_PARAM (pspec); */ + GParamSpec *param = value->data[0].v_pointer; + guint changed = 0; + + if (param && !g_value_type_compatible (G_PARAM_SPEC_TYPE (param), G_PARAM_SPEC_VALUE_TYPE (pspec))) + { + g_param_spec_unref (param); + value->data[0].v_pointer = NULL; + changed++; + } + + return changed; +} + +static void +param_boxed_init (GParamSpec *pspec) +{ + /* GParamSpecBoxed *bspec = G_PARAM_SPEC_BOXED (pspec); */ +} + +static void +param_boxed_set_default (GParamSpec *pspec, + GValue *value) +{ + value->data[0].v_pointer = NULL; +} + +static gboolean +param_boxed_validate (GParamSpec *pspec, + GValue *value) +{ + /* GParamSpecBoxed *bspec = G_PARAM_SPEC_BOXED (pspec); */ + guint changed = 0; + + /* can't do a whole lot here since we haven't even G_BOXED_TYPE() */ + + return changed; +} + +static gint +param_boxed_values_cmp (GParamSpec *pspec, + const GValue *value1, + const GValue *value2) +{ + guint8 *p1 = value1->data[0].v_pointer; + guint8 *p2 = value2->data[0].v_pointer; + + /* not much to compare here, try to at least provide stable lesser/greater result */ + + return p1 < p2 ? -1 : p1 > p2; +} + +static void +param_pointer_init (GParamSpec *pspec) +{ + /* GParamSpecPointer *spec = G_PARAM_SPEC_POINTER (pspec); */ +} + +static void +param_pointer_set_default (GParamSpec *pspec, + GValue *value) +{ + value->data[0].v_pointer = NULL; +} + +static gboolean +param_pointer_validate (GParamSpec *pspec, + GValue *value) +{ + /* GParamSpecPointer *spec = G_PARAM_SPEC_POINTER (pspec); */ + guint changed = 0; + + return changed; +} + +static gint +param_pointer_values_cmp (GParamSpec *pspec, + const GValue *value1, + const GValue *value2) +{ + guint8 *p1 = value1->data[0].v_pointer; + guint8 *p2 = value2->data[0].v_pointer; + + /* not much to compare here, try to at least provide stable lesser/greater result */ + + return p1 < p2 ? -1 : p1 > p2; +} + +static void +param_value_array_init (GParamSpec *pspec) +{ + GParamSpecValueArray *aspec = G_PARAM_SPEC_VALUE_ARRAY (pspec); + + aspec->element_spec = NULL; + aspec->fixed_n_elements = 0; /* disable */ +} + +static inline guint +value_array_ensure_size (GValueArray *value_array, + guint fixed_n_elements) +{ + guint changed = 0; + + if (fixed_n_elements) + { + while (value_array->n_values < fixed_n_elements) + { + g_value_array_append (value_array, NULL); + changed++; + } + while (value_array->n_values > fixed_n_elements) + { + g_value_array_remove (value_array, value_array->n_values - 1); + changed++; + } + } + return changed; +} + +static void +param_value_array_finalize (GParamSpec *pspec) +{ + GParamSpecValueArray *aspec = G_PARAM_SPEC_VALUE_ARRAY (pspec); + GParamSpecClass *parent_class = g_type_class_peek (g_type_parent (G_TYPE_PARAM_VALUE_ARRAY)); + + if (aspec->element_spec) + { + g_param_spec_unref (aspec->element_spec); + aspec->element_spec = NULL; + } + + parent_class->finalize (pspec); +} + +static void +param_value_array_set_default (GParamSpec *pspec, + GValue *value) +{ + GParamSpecValueArray *aspec = G_PARAM_SPEC_VALUE_ARRAY (pspec); + + if (!value->data[0].v_pointer && aspec->fixed_n_elements) + value->data[0].v_pointer = g_value_array_new (aspec->fixed_n_elements); + + if (value->data[0].v_pointer) + { + /* g_value_reset (value); already done */ + value_array_ensure_size (value->data[0].v_pointer, aspec->fixed_n_elements); + } +} + +static gboolean +param_value_array_validate (GParamSpec *pspec, + GValue *value) +{ + GParamSpecValueArray *aspec = G_PARAM_SPEC_VALUE_ARRAY (pspec); + GValueArray *value_array = value->data[0].v_pointer; + guint changed = 0; + + if (!value->data[0].v_pointer && aspec->fixed_n_elements) + value->data[0].v_pointer = g_value_array_new (aspec->fixed_n_elements); + + if (value->data[0].v_pointer) + { + /* ensure array size validity */ + changed += value_array_ensure_size (value_array, aspec->fixed_n_elements); + + /* ensure array values validity against a present element spec */ + if (aspec->element_spec) + { + GParamSpec *element_spec = aspec->element_spec; + guint i; + + for (i = 0; i < value_array->n_values; i++) + { + GValue *element = value_array->values + i; + + /* need to fixup value type, or ensure that the array value is initialized at all */ + if (!g_value_type_compatible (G_VALUE_TYPE (element), G_PARAM_SPEC_VALUE_TYPE (element_spec))) + { + if (G_VALUE_TYPE (element) != 0) + g_value_unset (element); + g_value_init (element, G_PARAM_SPEC_VALUE_TYPE (element_spec)); + g_param_value_set_default (element_spec, element); + changed++; + } + /* validate array value against element_spec */ + changed += g_param_value_validate (element_spec, element); + } + } + } + + return changed; +} + +static gint +param_value_array_values_cmp (GParamSpec *pspec, + const GValue *value1, + const GValue *value2) +{ + GParamSpecValueArray *aspec = G_PARAM_SPEC_VALUE_ARRAY (pspec); + GValueArray *value_array1 = value1->data[0].v_pointer; + GValueArray *value_array2 = value2->data[0].v_pointer; + + if (!value_array1 || !value_array2) + return value_array2 ? -1 : value_array1 != value_array2; + + if (value_array1->n_values != value_array2->n_values) + return value_array1->n_values < value_array2->n_values ? -1 : 1; + else if (!aspec->element_spec) + { + /* we need an element specification for comparisons, so there's not much + * to compare here, try to at least provide stable lesser/greater result + */ + return value_array1->n_values < value_array2->n_values ? -1 : value_array1->n_values > value_array2->n_values; + } + else /* value_array1->n_values == value_array2->n_values */ + { + guint i; + + for (i = 0; i < value_array1->n_values; i++) + { + GValue *element1 = value_array1->values + i; + GValue *element2 = value_array2->values + i; + gint cmp; + + /* need corresponding element types, provide stable result otherwise */ + if (G_VALUE_TYPE (element1) != G_VALUE_TYPE (element2)) + return G_VALUE_TYPE (element1) < G_VALUE_TYPE (element2) ? -1 : 1; + cmp = g_param_values_cmp (aspec->element_spec, element1, element2); + if (cmp) + return cmp; + } + return 0; + } +} + +static void +param_object_init (GParamSpec *pspec) +{ + /* GParamSpecObject *ospec = G_PARAM_SPEC_OBJECT (pspec); */ +} + +static void +param_object_set_default (GParamSpec *pspec, + GValue *value) +{ + value->data[0].v_pointer = NULL; +} + +static gboolean +param_object_validate (GParamSpec *pspec, + GValue *value) +{ + GParamSpecObject *ospec = G_PARAM_SPEC_OBJECT (pspec); + GObject *object = value->data[0].v_pointer; + guint changed = 0; + + if (object && !g_value_type_compatible (G_OBJECT_TYPE (object), G_PARAM_SPEC_VALUE_TYPE (ospec))) + { + g_object_unref (object); + value->data[0].v_pointer = NULL; + changed++; + } + + return changed; +} + +static gint +param_object_values_cmp (GParamSpec *pspec, + const GValue *value1, + const GValue *value2) +{ + guint8 *p1 = value1->data[0].v_pointer; + guint8 *p2 = value2->data[0].v_pointer; + + /* not much to compare here, try to at least provide stable lesser/greater result */ + + return p1 < p2 ? -1 : p1 > p2; +} + +static void +param_override_init (GParamSpec *pspec) +{ + /* GParamSpecOverride *ospec = G_PARAM_SPEC_OVERRIDE (pspec); */ +} + +static void +param_override_finalize (GParamSpec *pspec) +{ + GParamSpecOverride *ospec = G_PARAM_SPEC_OVERRIDE (pspec); + GParamSpecClass *parent_class = g_type_class_peek (g_type_parent (G_TYPE_PARAM_OVERRIDE)); + + if (ospec->overridden) + { + g_param_spec_unref (ospec->overridden); + ospec->overridden = NULL; + } + + parent_class->finalize (pspec); +} + +static void +param_override_set_default (GParamSpec *pspec, + GValue *value) +{ + GParamSpecOverride *ospec = G_PARAM_SPEC_OVERRIDE (pspec); + + g_param_value_set_default (ospec->overridden, value); +} + +static gboolean +param_override_validate (GParamSpec *pspec, + GValue *value) +{ + GParamSpecOverride *ospec = G_PARAM_SPEC_OVERRIDE (pspec); + + return g_param_value_validate (ospec->overridden, value); +} + +static gint +param_override_values_cmp (GParamSpec *pspec, + const GValue *value1, + const GValue *value2) +{ + GParamSpecOverride *ospec = G_PARAM_SPEC_OVERRIDE (pspec); + + return g_param_values_cmp (ospec->overridden, value1, value2); +} + +static void +param_gtype_init (GParamSpec *pspec) +{ +} + +static void +param_gtype_set_default (GParamSpec *pspec, + GValue *value) +{ + value->data[0].v_long = G_TYPE_NONE; +} + +static gboolean +param_gtype_validate (GParamSpec *pspec, + GValue *value) +{ + GParamSpecGType *tspec = G_PARAM_SPEC_GTYPE (pspec); + GType gtype = value->data[0].v_long; + guint changed = 0; + + if (tspec->is_a_type != G_TYPE_NONE && !g_type_is_a (gtype, tspec->is_a_type)) + { + value->data[0].v_long = G_TYPE_NONE; + changed++; + } + + return changed; +} + +static gint +param_gtype_values_cmp (GParamSpec *pspec, + const GValue *value1, + const GValue *value2) +{ + GType p1 = value1->data[0].v_long; + GType p2 = value2->data[0].v_long; + + /* not much to compare here, try to at least provide stable lesser/greater result */ + + return p1 < p2 ? -1 : p1 > p2; +} + +/* --- type initialization --- */ +#if !(EMULATOR) +GType *g_param_spec_types = NULL; +#endif /* EMULATOR */ + +#ifdef __SYMBIAN32__ +EXPORT_C GType ** _g_param_spec_types() +{ + return &g_param_spec_types; +} +#endif /* __SYMBIAN32__ */ + +#if EMULATOR + +PLS(pspec_info,g_param_spec_types_init ,GParamSpecTypeInfo) +const GParamSpecTypeInfo temp_pspec_info = { + sizeof (GParamSpecValueArray), /* instance_size */ + 0, /* n_preallocs */ + param_value_array_init, /* instance_init */ + 0xdeadbeef, /* value_type, assigned further down */ + param_value_array_finalize, /* finalize */ + param_value_array_set_default, /* value_set_default */ + param_value_array_validate, /* value_validate */ + param_value_array_values_cmp, /* values_cmp */ + }; +#endif /* EMULATOR */ + +void +g_param_spec_types_init (void) +{ + const guint n_types = 22; + GType type, *spec_types, *spec_types_bound; + g_param_spec_types = g_new0 (GType, n_types); + spec_types = g_param_spec_types; + spec_types_bound = g_param_spec_types + n_types; + + /* G_TYPE_PARAM_CHAR + */ + { + static const GParamSpecTypeInfo pspec_info = { + sizeof (GParamSpecChar), /* instance_size */ + 16, /* n_preallocs */ + param_char_init, /* instance_init */ + G_TYPE_CHAR, /* value_type */ + NULL, /* finalize */ + param_char_set_default, /* value_set_default */ + param_char_validate, /* value_validate */ + param_int_values_cmp, /* values_cmp */ + }; + type = g_param_type_register_static (g_intern_static_string ("GParamChar"), &pspec_info); + *spec_types++ = type; + g_assert (type == G_TYPE_PARAM_CHAR); + } + + /* G_TYPE_PARAM_UCHAR + */ + { + static const GParamSpecTypeInfo pspec_info = { + sizeof (GParamSpecUChar), /* instance_size */ + 16, /* n_preallocs */ + param_uchar_init, /* instance_init */ + G_TYPE_UCHAR, /* value_type */ + NULL, /* finalize */ + param_uchar_set_default, /* value_set_default */ + param_uchar_validate, /* value_validate */ + param_uint_values_cmp, /* values_cmp */ + }; + type = g_param_type_register_static (g_intern_static_string ("GParamUChar"), &pspec_info); + *spec_types++ = type; + g_assert (type == G_TYPE_PARAM_UCHAR); + } + + /* G_TYPE_PARAM_BOOLEAN + */ + { + static const GParamSpecTypeInfo pspec_info = { + sizeof (GParamSpecBoolean), /* instance_size */ + 16, /* n_preallocs */ + NULL, /* instance_init */ + G_TYPE_BOOLEAN, /* value_type */ + NULL, /* finalize */ + param_boolean_set_default, /* value_set_default */ + param_boolean_validate, /* value_validate */ + param_int_values_cmp, /* values_cmp */ + }; + type = g_param_type_register_static (g_intern_static_string ("GParamBoolean"), &pspec_info); + *spec_types++ = type; + g_assert (type == G_TYPE_PARAM_BOOLEAN); + } + + /* G_TYPE_PARAM_INT + */ + { + static const GParamSpecTypeInfo pspec_info = { + sizeof (GParamSpecInt), /* instance_size */ + 16, /* n_preallocs */ + param_int_init, /* instance_init */ + G_TYPE_INT, /* value_type */ + NULL, /* finalize */ + param_int_set_default, /* value_set_default */ + param_int_validate, /* value_validate */ + param_int_values_cmp, /* values_cmp */ + }; + type = g_param_type_register_static (g_intern_static_string ("GParamInt"), &pspec_info); + *spec_types++ = type; + g_assert (type == G_TYPE_PARAM_INT); + } + + /* G_TYPE_PARAM_UINT + */ + { + static const GParamSpecTypeInfo pspec_info = { + sizeof (GParamSpecUInt), /* instance_size */ + 16, /* n_preallocs */ + param_uint_init, /* instance_init */ + G_TYPE_UINT, /* value_type */ + NULL, /* finalize */ + param_uint_set_default, /* value_set_default */ + param_uint_validate, /* value_validate */ + param_uint_values_cmp, /* values_cmp */ + }; + type = g_param_type_register_static (g_intern_static_string ("GParamUInt"), &pspec_info); + *spec_types++ = type; + g_assert (type == G_TYPE_PARAM_UINT); + } + + /* G_TYPE_PARAM_LONG + */ + { + static const GParamSpecTypeInfo pspec_info = { + sizeof (GParamSpecLong), /* instance_size */ + 16, /* n_preallocs */ + param_long_init, /* instance_init */ + G_TYPE_LONG, /* value_type */ + NULL, /* finalize */ + param_long_set_default, /* value_set_default */ + param_long_validate, /* value_validate */ + param_long_values_cmp, /* values_cmp */ + }; + type = g_param_type_register_static (g_intern_static_string ("GParamLong"), &pspec_info); + *spec_types++ = type; + g_assert (type == G_TYPE_PARAM_LONG); + } + + /* G_TYPE_PARAM_ULONG + */ + { + static const GParamSpecTypeInfo pspec_info = { + sizeof (GParamSpecULong), /* instance_size */ + 16, /* n_preallocs */ + param_ulong_init, /* instance_init */ + G_TYPE_ULONG, /* value_type */ + NULL, /* finalize */ + param_ulong_set_default, /* value_set_default */ + param_ulong_validate, /* value_validate */ + param_ulong_values_cmp, /* values_cmp */ + }; + type = g_param_type_register_static (g_intern_static_string ("GParamULong"), &pspec_info); + *spec_types++ = type; + g_assert (type == G_TYPE_PARAM_ULONG); + } + + /* G_TYPE_PARAM_INT64 + */ + { + static const GParamSpecTypeInfo pspec_info = { + sizeof (GParamSpecInt64), /* instance_size */ + 16, /* n_preallocs */ + param_int64_init, /* instance_init */ + G_TYPE_INT64, /* value_type */ + NULL, /* finalize */ + param_int64_set_default, /* value_set_default */ + param_int64_validate, /* value_validate */ + param_int64_values_cmp, /* values_cmp */ + }; + type = g_param_type_register_static (g_intern_static_string ("GParamInt64"), &pspec_info); + *spec_types++ = type; + g_assert (type == G_TYPE_PARAM_INT64); + } + + /* G_TYPE_PARAM_UINT64 + */ + { + static const GParamSpecTypeInfo pspec_info = { + sizeof (GParamSpecUInt64), /* instance_size */ + 16, /* n_preallocs */ + param_uint64_init, /* instance_init */ + G_TYPE_UINT64, /* value_type */ + NULL, /* finalize */ + param_uint64_set_default, /* value_set_default */ + param_uint64_validate, /* value_validate */ + param_uint64_values_cmp, /* values_cmp */ + }; + type = g_param_type_register_static (g_intern_static_string ("GParamUInt64"), &pspec_info); + *spec_types++ = type; + g_assert (type == G_TYPE_PARAM_UINT64); + } + + /* G_TYPE_PARAM_UNICHAR + */ + { + static const GParamSpecTypeInfo pspec_info = { + sizeof (GParamSpecUnichar), /* instance_size */ + 16, /* n_preallocs */ + param_unichar_init, /* instance_init */ + G_TYPE_UINT, /* value_type */ + NULL, /* finalize */ + param_unichar_set_default, /* value_set_default */ + param_unichar_validate, /* value_validate */ + param_unichar_values_cmp, /* values_cmp */ + }; + type = g_param_type_register_static (g_intern_static_string ("GParamUnichar"), &pspec_info); + *spec_types++ = type; + g_assert (type == G_TYPE_PARAM_UNICHAR); + } + + /* G_TYPE_PARAM_ENUM + */ + { + static const GParamSpecTypeInfo pspec_info = { + sizeof (GParamSpecEnum), /* instance_size */ + 16, /* n_preallocs */ + param_enum_init, /* instance_init */ + G_TYPE_ENUM, /* value_type */ + param_enum_finalize, /* finalize */ + param_enum_set_default, /* value_set_default */ + param_enum_validate, /* value_validate */ + param_long_values_cmp, /* values_cmp */ + }; + type = g_param_type_register_static (g_intern_static_string ("GParamEnum"), &pspec_info); + *spec_types++ = type; + g_assert (type == G_TYPE_PARAM_ENUM); + } + + /* G_TYPE_PARAM_FLAGS + */ + { + static const GParamSpecTypeInfo pspec_info = { + sizeof (GParamSpecFlags), /* instance_size */ + 16, /* n_preallocs */ + param_flags_init, /* instance_init */ + G_TYPE_FLAGS, /* value_type */ + param_flags_finalize, /* finalize */ + param_flags_set_default, /* value_set_default */ + param_flags_validate, /* value_validate */ + param_ulong_values_cmp, /* values_cmp */ + }; + type = g_param_type_register_static (g_intern_static_string ("GParamFlags"), &pspec_info); + *spec_types++ = type; + g_assert (type == G_TYPE_PARAM_FLAGS); + } + + /* G_TYPE_PARAM_FLOAT + */ + { + static const GParamSpecTypeInfo pspec_info = { + sizeof (GParamSpecFloat), /* instance_size */ + 16, /* n_preallocs */ + param_float_init, /* instance_init */ + G_TYPE_FLOAT, /* value_type */ + NULL, /* finalize */ + param_float_set_default, /* value_set_default */ + param_float_validate, /* value_validate */ + param_float_values_cmp, /* values_cmp */ + }; + type = g_param_type_register_static (g_intern_static_string ("GParamFloat"), &pspec_info); + *spec_types++ = type; + g_assert (type == G_TYPE_PARAM_FLOAT); + } + + /* G_TYPE_PARAM_DOUBLE + */ + { + static const GParamSpecTypeInfo pspec_info = { + sizeof (GParamSpecDouble), /* instance_size */ + 16, /* n_preallocs */ + param_double_init, /* instance_init */ + G_TYPE_DOUBLE, /* value_type */ + NULL, /* finalize */ + param_double_set_default, /* value_set_default */ + param_double_validate, /* value_validate */ + param_double_values_cmp, /* values_cmp */ + }; + type = g_param_type_register_static (g_intern_static_string ("GParamDouble"), &pspec_info); + *spec_types++ = type; + g_assert (type == G_TYPE_PARAM_DOUBLE); + } + + /* G_TYPE_PARAM_STRING + */ + { + static const GParamSpecTypeInfo pspec_info = { + sizeof (GParamSpecString), /* instance_size */ + 16, /* n_preallocs */ + param_string_init, /* instance_init */ + G_TYPE_STRING, /* value_type */ + param_string_finalize, /* finalize */ + param_string_set_default, /* value_set_default */ + param_string_validate, /* value_validate */ + param_string_values_cmp, /* values_cmp */ + }; + type = g_param_type_register_static (g_intern_static_string ("GParamString"), &pspec_info); + *spec_types++ = type; + g_assert (type == G_TYPE_PARAM_STRING); + } + + /* G_TYPE_PARAM_PARAM + */ + { + static const GParamSpecTypeInfo pspec_info = { + sizeof (GParamSpecParam), /* instance_size */ + 16, /* n_preallocs */ + param_param_init, /* instance_init */ + G_TYPE_PARAM, /* value_type */ + NULL, /* finalize */ + param_param_set_default, /* value_set_default */ + param_param_validate, /* value_validate */ + param_pointer_values_cmp, /* values_cmp */ + }; + type = g_param_type_register_static (g_intern_static_string ("GParamParam"), &pspec_info); + *spec_types++ = type; + g_assert (type == G_TYPE_PARAM_PARAM); + } + + /* G_TYPE_PARAM_BOXED + */ + { + static const GParamSpecTypeInfo pspec_info = { + sizeof (GParamSpecBoxed), /* instance_size */ + 4, /* n_preallocs */ + param_boxed_init, /* instance_init */ + G_TYPE_BOXED, /* value_type */ + NULL, /* finalize */ + param_boxed_set_default, /* value_set_default */ + param_boxed_validate, /* value_validate */ + param_boxed_values_cmp, /* values_cmp */ + }; + type = g_param_type_register_static (g_intern_static_string ("GParamBoxed"), &pspec_info); + *spec_types++ = type; + g_assert (type == G_TYPE_PARAM_BOXED); + } + + /* G_TYPE_PARAM_POINTER + */ + { + static const GParamSpecTypeInfo pspec_info = { + sizeof (GParamSpecPointer), /* instance_size */ + 0, /* n_preallocs */ + param_pointer_init, /* instance_init */ + G_TYPE_POINTER, /* value_type */ + NULL, /* finalize */ + param_pointer_set_default, /* value_set_default */ + param_pointer_validate, /* value_validate */ + param_pointer_values_cmp, /* values_cmp */ + }; + type = g_param_type_register_static (g_intern_static_string ("GParamPointer"), &pspec_info); + *spec_types++ = type; + g_assert (type == G_TYPE_PARAM_POINTER); + } + + /* G_TYPE_PARAM_VALUE_ARRAY + */ + { + #if EMULATOR + #define pspec_info (*FUNCTION_NAME(pspec_info,g_param_spec_types_init )()) + #else + static /* const */ GParamSpecTypeInfo pspec_info = { + sizeof (GParamSpecValueArray), /* instance_size */ + 0, /* n_preallocs */ + param_value_array_init, /* instance_init */ + 0xdeadbeef, /* value_type, assigned further down */ + param_value_array_finalize, /* finalize */ + param_value_array_set_default, /* value_set_default */ + param_value_array_validate, /* value_validate */ + param_value_array_values_cmp, /* values_cmp */ + }; + #endif /*EMULATOR */ + pspec_info.value_type = G_TYPE_VALUE_ARRAY; + type = g_param_type_register_static (g_intern_static_string ("GParamValueArray"), &pspec_info); + *spec_types++ = type; + g_assert (type == G_TYPE_PARAM_VALUE_ARRAY); + #if EMULATOR + #undef pspec_info + #endif /* EMULATOR */ + } + + /* G_TYPE_PARAM_OBJECT + */ + { + static const GParamSpecTypeInfo pspec_info = { + sizeof (GParamSpecObject), /* instance_size */ + 16, /* n_preallocs */ + param_object_init, /* instance_init */ + G_TYPE_OBJECT, /* value_type */ + NULL, /* finalize */ + param_object_set_default, /* value_set_default */ + param_object_validate, /* value_validate */ + param_object_values_cmp, /* values_cmp */ + }; + type = g_param_type_register_static (g_intern_static_string ("GParamObject"), &pspec_info); + *spec_types++ = type; + g_assert (type == G_TYPE_PARAM_OBJECT); + } + + /* G_TYPE_PARAM_OVERRIDE + */ + { + static const GParamSpecTypeInfo pspec_info = { + sizeof (GParamSpecOverride), /* instance_size */ + 16, /* n_preallocs */ + param_override_init, /* instance_init */ + G_TYPE_NONE, /* value_type */ + param_override_finalize, /* finalize */ + param_override_set_default, /* value_set_default */ + param_override_validate, /* value_validate */ + param_override_values_cmp, /* values_cmp */ + }; + type = g_param_type_register_static (g_intern_static_string ("GParamOverride"), &pspec_info); + *spec_types++ = type; + g_assert (type == G_TYPE_PARAM_OVERRIDE); + } + + /* G_TYPE_PARAM_GTYPE + */ + { + #ifndef __SYMBIAN32__ + GParamSpecTypeInfo pspec_info = { + sizeof (GParamSpecGType), /* instance_size */ + 0, /* n_preallocs */ + param_gtype_init, /* instance_init */ + G_TYPE_GTYPE, /* value_type */ + NULL, /* finalize */ + param_gtype_set_default, /* value_set_default */ + param_gtype_validate, /* value_validate */ + param_gtype_values_cmp, /* values_cmp */ + }; + #else + GParamSpecTypeInfo pspec_info; + pspec_info.instance_size = sizeof (GParamSpecGType); + pspec_info.n_preallocs = 0; + pspec_info.instance_init = param_gtype_init; + pspec_info.value_type = G_TYPE_GTYPE; + pspec_info.finalize = NULL; + pspec_info.value_set_default = param_gtype_set_default; + pspec_info.value_validate = param_gtype_validate; + pspec_info.values_cmp = param_gtype_values_cmp; + #endif /* __SYMBIAN32__ */ + + type = g_param_type_register_static (g_intern_static_string ("GParamGType"), &pspec_info); + *spec_types++ = type; + g_assert (type == G_TYPE_PARAM_GTYPE); + } + + g_assert (spec_types == spec_types_bound); +} + +/* --- GParamSpec initialization --- */ + +EXPORT_C GParamSpec* +g_param_spec_char (const gchar *name, + const gchar *nick, + const gchar *blurb, + gint8 minimum, + gint8 maximum, + gint8 default_value, + GParamFlags flags) +{ + GParamSpecChar *cspec; + + g_return_val_if_fail (default_value >= minimum && default_value <= maximum, NULL); + + cspec = g_param_spec_internal (G_TYPE_PARAM_CHAR, + name, + nick, + blurb, + flags); + + cspec->minimum = minimum; + cspec->maximum = maximum; + cspec->default_value = default_value; + + return G_PARAM_SPEC (cspec); +} + +EXPORT_C GParamSpec* +g_param_spec_uchar (const gchar *name, + const gchar *nick, + const gchar *blurb, + guint8 minimum, + guint8 maximum, + guint8 default_value, + GParamFlags flags) +{ + GParamSpecUChar *uspec; + + g_return_val_if_fail (default_value >= minimum && default_value <= maximum, NULL); + + uspec = g_param_spec_internal (G_TYPE_PARAM_UCHAR, + name, + nick, + blurb, + flags); + + uspec->minimum = minimum; + uspec->maximum = maximum; + uspec->default_value = default_value; + + return G_PARAM_SPEC (uspec); +} + +EXPORT_C GParamSpec* +g_param_spec_boolean (const gchar *name, + const gchar *nick, + const gchar *blurb, + gboolean default_value, + GParamFlags flags) +{ + GParamSpecBoolean *bspec; + + g_return_val_if_fail (default_value == TRUE || default_value == FALSE, NULL); + + bspec = g_param_spec_internal (G_TYPE_PARAM_BOOLEAN, + name, + nick, + blurb, + flags); + + bspec->default_value = default_value; + + return G_PARAM_SPEC (bspec); +} + +EXPORT_C GParamSpec* +g_param_spec_int (const gchar *name, + const gchar *nick, + const gchar *blurb, + gint minimum, + gint maximum, + gint default_value, + GParamFlags flags) +{ + GParamSpecInt *ispec; + + g_return_val_if_fail (default_value >= minimum && default_value <= maximum, NULL); + + ispec = g_param_spec_internal (G_TYPE_PARAM_INT, + name, + nick, + blurb, + flags); + + ispec->minimum = minimum; + ispec->maximum = maximum; + ispec->default_value = default_value; + + return G_PARAM_SPEC (ispec); +} + +EXPORT_C GParamSpec* +g_param_spec_uint (const gchar *name, + const gchar *nick, + const gchar *blurb, + guint minimum, + guint maximum, + guint default_value, + GParamFlags flags) +{ + GParamSpecUInt *uspec; + + g_return_val_if_fail (default_value >= minimum && default_value <= maximum, NULL); + + uspec = g_param_spec_internal (G_TYPE_PARAM_UINT, + name, + nick, + blurb, + flags); + + uspec->minimum = minimum; + uspec->maximum = maximum; + uspec->default_value = default_value; + + return G_PARAM_SPEC (uspec); +} + +EXPORT_C GParamSpec* +g_param_spec_long (const gchar *name, + const gchar *nick, + const gchar *blurb, + glong minimum, + glong maximum, + glong default_value, + GParamFlags flags) +{ + GParamSpecLong *lspec; + + g_return_val_if_fail (default_value >= minimum && default_value <= maximum, NULL); + + lspec = g_param_spec_internal (G_TYPE_PARAM_LONG, + name, + nick, + blurb, + flags); + + lspec->minimum = minimum; + lspec->maximum = maximum; + lspec->default_value = default_value; + + return G_PARAM_SPEC (lspec); +} + +EXPORT_C GParamSpec* +g_param_spec_ulong (const gchar *name, + const gchar *nick, + const gchar *blurb, + gulong minimum, + gulong maximum, + gulong default_value, + GParamFlags flags) +{ + GParamSpecULong *uspec; + + g_return_val_if_fail (default_value >= minimum && default_value <= maximum, NULL); + + uspec = g_param_spec_internal (G_TYPE_PARAM_ULONG, + name, + nick, + blurb, + flags); + + uspec->minimum = minimum; + uspec->maximum = maximum; + uspec->default_value = default_value; + + return G_PARAM_SPEC (uspec); +} + +EXPORT_C GParamSpec* +g_param_spec_int64 (const gchar *name, + const gchar *nick, + const gchar *blurb, + gint64 minimum, + gint64 maximum, + gint64 default_value, + GParamFlags flags) +{ + GParamSpecInt64 *lspec; + + g_return_val_if_fail (default_value >= minimum && default_value <= maximum, NULL); + + lspec = g_param_spec_internal (G_TYPE_PARAM_INT64, + name, + nick, + blurb, + flags); + + lspec->minimum = minimum; + lspec->maximum = maximum; + lspec->default_value = default_value; + + return G_PARAM_SPEC (lspec); +} + +EXPORT_C GParamSpec* +g_param_spec_uint64 (const gchar *name, + const gchar *nick, + const gchar *blurb, + guint64 minimum, + guint64 maximum, + guint64 default_value, + GParamFlags flags) +{ + GParamSpecUInt64 *uspec; + + g_return_val_if_fail (default_value >= minimum && default_value <= maximum, NULL); + + uspec = g_param_spec_internal (G_TYPE_PARAM_UINT64, + name, + nick, + blurb, + flags); + + uspec->minimum = minimum; + uspec->maximum = maximum; + uspec->default_value = default_value; + + return G_PARAM_SPEC (uspec); +} + +EXPORT_C GParamSpec* +g_param_spec_unichar (const gchar *name, + const gchar *nick, + const gchar *blurb, + gunichar default_value, + GParamFlags flags) +{ + GParamSpecUnichar *uspec; + + uspec = g_param_spec_internal (G_TYPE_PARAM_UNICHAR, + name, + nick, + blurb, + flags); + + uspec->default_value = default_value; + + return G_PARAM_SPEC (uspec); +} + +EXPORT_C GParamSpec* +g_param_spec_enum (const gchar *name, + const gchar *nick, + const gchar *blurb, + GType enum_type, + gint default_value, + GParamFlags flags) +{ + GParamSpecEnum *espec; + GEnumClass *enum_class; + + g_return_val_if_fail (G_TYPE_IS_ENUM (enum_type), NULL); + + enum_class = g_type_class_ref (enum_type); + + g_return_val_if_fail (g_enum_get_value (enum_class, default_value) != NULL, NULL); + + espec = g_param_spec_internal (G_TYPE_PARAM_ENUM, + name, + nick, + blurb, + flags); + + espec->enum_class = enum_class; + espec->default_value = default_value; + G_PARAM_SPEC (espec)->value_type = enum_type; + + return G_PARAM_SPEC (espec); +} + +EXPORT_C GParamSpec* +g_param_spec_flags (const gchar *name, + const gchar *nick, + const gchar *blurb, + GType flags_type, + guint default_value, + GParamFlags flags) +{ + GParamSpecFlags *fspec; + GFlagsClass *flags_class; + + g_return_val_if_fail (G_TYPE_IS_FLAGS (flags_type), NULL); + + flags_class = g_type_class_ref (flags_type); + + g_return_val_if_fail ((default_value & flags_class->mask) == default_value, NULL); + + fspec = g_param_spec_internal (G_TYPE_PARAM_FLAGS, + name, + nick, + blurb, + flags); + + fspec->flags_class = flags_class; + fspec->default_value = default_value; + G_PARAM_SPEC (fspec)->value_type = flags_type; + + return G_PARAM_SPEC (fspec); +} + +EXPORT_C GParamSpec* +g_param_spec_float (const gchar *name, + const gchar *nick, + const gchar *blurb, + gfloat minimum, + gfloat maximum, + gfloat default_value, + GParamFlags flags) +{ + GParamSpecFloat *fspec; + + g_return_val_if_fail (default_value >= minimum && default_value <= maximum, NULL); + + fspec = g_param_spec_internal (G_TYPE_PARAM_FLOAT, + name, + nick, + blurb, + flags); + + fspec->minimum = minimum; + fspec->maximum = maximum; + fspec->default_value = default_value; + + return G_PARAM_SPEC (fspec); +} + +EXPORT_C GParamSpec* +g_param_spec_double (const gchar *name, + const gchar *nick, + const gchar *blurb, + gdouble minimum, + gdouble maximum, + gdouble default_value, + GParamFlags flags) +{ + GParamSpecDouble *dspec; + + g_return_val_if_fail (default_value >= minimum && default_value <= maximum, NULL); + + dspec = g_param_spec_internal (G_TYPE_PARAM_DOUBLE, + name, + nick, + blurb, + flags); + + dspec->minimum = minimum; + dspec->maximum = maximum; + dspec->default_value = default_value; + + return G_PARAM_SPEC (dspec); +} + +EXPORT_C GParamSpec* +g_param_spec_string (const gchar *name, + const gchar *nick, + const gchar *blurb, + const gchar *default_value, + GParamFlags flags) +{ + GParamSpecString *sspec = g_param_spec_internal (G_TYPE_PARAM_STRING, + name, + nick, + blurb, + flags); + g_free (sspec->default_value); + sspec->default_value = g_strdup (default_value); + + return G_PARAM_SPEC (sspec); +} + +EXPORT_C GParamSpec* +g_param_spec_param (const gchar *name, + const gchar *nick, + const gchar *blurb, + GType param_type, + GParamFlags flags) +{ + GParamSpecParam *pspec; + + g_return_val_if_fail (G_TYPE_IS_PARAM (param_type), NULL); + + pspec = g_param_spec_internal (G_TYPE_PARAM_PARAM, + name, + nick, + blurb, + flags); + G_PARAM_SPEC (pspec)->value_type = param_type; + + return G_PARAM_SPEC (pspec); +} + +EXPORT_C GParamSpec* +g_param_spec_boxed (const gchar *name, + const gchar *nick, + const gchar *blurb, + GType boxed_type, + GParamFlags flags) +{ + GParamSpecBoxed *bspec; + + g_return_val_if_fail (G_TYPE_IS_BOXED (boxed_type), NULL); + g_return_val_if_fail (G_TYPE_IS_VALUE_TYPE (boxed_type), NULL); + + bspec = g_param_spec_internal (G_TYPE_PARAM_BOXED, + name, + nick, + blurb, + flags); + G_PARAM_SPEC (bspec)->value_type = boxed_type; + + return G_PARAM_SPEC (bspec); +} + +EXPORT_C GParamSpec* +g_param_spec_pointer (const gchar *name, + const gchar *nick, + const gchar *blurb, + GParamFlags flags) +{ + GParamSpecPointer *pspec; + + pspec = g_param_spec_internal (G_TYPE_PARAM_POINTER, + name, + nick, + blurb, + flags); + return G_PARAM_SPEC (pspec); +} + +EXPORT_C GParamSpec* +g_param_spec_gtype (const gchar *name, + const gchar *nick, + const gchar *blurb, + GType is_a_type, + GParamFlags flags) +{ + GParamSpecGType *tspec; + + tspec = g_param_spec_internal (G_TYPE_PARAM_GTYPE, + name, + nick, + blurb, + flags); + + tspec->is_a_type = is_a_type; + + return G_PARAM_SPEC (tspec); +} + +EXPORT_C GParamSpec* +g_param_spec_value_array (const gchar *name, + const gchar *nick, + const gchar *blurb, + GParamSpec *element_spec, + GParamFlags flags) +{ + GParamSpecValueArray *aspec; + + if (element_spec) + g_return_val_if_fail (G_IS_PARAM_SPEC (element_spec), NULL); + + aspec = g_param_spec_internal (G_TYPE_PARAM_VALUE_ARRAY, + name, + nick, + blurb, + flags); + if (element_spec) + { + aspec->element_spec = g_param_spec_ref (element_spec); + g_param_spec_sink (element_spec); + } + + return G_PARAM_SPEC (aspec); +} + +EXPORT_C GParamSpec* +g_param_spec_object (const gchar *name, + const gchar *nick, + const gchar *blurb, + GType object_type, + GParamFlags flags) +{ + GParamSpecObject *ospec; + + g_return_val_if_fail (g_type_is_a (object_type, G_TYPE_OBJECT), NULL); + + ospec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, + name, + nick, + blurb, + flags); + G_PARAM_SPEC (ospec)->value_type = object_type; + + return G_PARAM_SPEC (ospec); +} + +EXPORT_C GParamSpec* +g_param_spec_override (const gchar *name, + GParamSpec *overridden) +{ + GParamSpec *pspec; + + g_return_val_if_fail (name != NULL, NULL); + g_return_val_if_fail (G_IS_PARAM_SPEC (overridden), NULL); + + /* Dereference further redirections for property that was passed in + */ + while (TRUE) + { + GParamSpec *indirect = g_param_spec_get_redirect_target (overridden); + if (indirect) + overridden = indirect; + else + break; + } + + pspec = g_param_spec_internal (G_TYPE_PARAM_OVERRIDE, + name, NULL, NULL, + overridden->flags); + + pspec->value_type = G_PARAM_SPEC_VALUE_TYPE (overridden); + G_PARAM_SPEC_OVERRIDE (pspec)->overridden = g_param_spec_ref (overridden); + + return pspec; +} + +#define __G_PARAMSPECS_C__ +#include "gobjectaliasdef.c"