1 /* GObject - GLib Type, Object, Parameter and Signal Library
2 * Copyright (C) 1997-1999, 2000-2001 Tim Janik and Red Hat, Inc.
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 of the License, or (at your option) any later version.
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.
14 * You should have received a copy of the GNU Lesser General
15 * Public License along with this library; if not, write to the
16 * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
17 * Boston, MA 02111-1307, USA.
24 #include "gparamspecs.h"
26 #include "gvaluecollector.h"
27 #include "gvaluearray.h"
29 #include "../config.h" /* for SIZEOF_LONG */
31 #define G_FLOAT_EPSILON (1e-30)
32 #define G_DOUBLE_EPSILON (1e-90)
35 /* --- param spec functions --- */
37 param_char_init (GParamSpec *pspec)
39 GParamSpecChar *cspec = G_PARAM_SPEC_CHAR (pspec);
41 cspec->minimum = 0x7f;
42 cspec->maximum = 0x80;
43 cspec->default_value = 0;
47 param_char_set_default (GParamSpec *pspec,
50 value->data[0].v_int = G_PARAM_SPEC_CHAR (pspec)->default_value;
54 param_char_validate (GParamSpec *pspec,
57 GParamSpecChar *cspec = G_PARAM_SPEC_CHAR (pspec);
58 gint oval = value->data[0].v_int;
60 value->data[0].v_int = CLAMP (value->data[0].v_int, cspec->minimum, cspec->maximum);
62 return value->data[0].v_int != oval;
66 param_uchar_init (GParamSpec *pspec)
68 GParamSpecUChar *uspec = G_PARAM_SPEC_UCHAR (pspec);
71 uspec->maximum = 0xff;
72 uspec->default_value = 0;
76 param_uchar_set_default (GParamSpec *pspec,
79 value->data[0].v_uint = G_PARAM_SPEC_UCHAR (pspec)->default_value;
83 param_uchar_validate (GParamSpec *pspec,
86 GParamSpecUChar *uspec = G_PARAM_SPEC_UCHAR (pspec);
87 guint oval = value->data[0].v_uint;
89 value->data[0].v_uint = CLAMP (value->data[0].v_uint, uspec->minimum, uspec->maximum);
91 return value->data[0].v_uint != oval;
95 param_boolean_set_default (GParamSpec *pspec,
98 value->data[0].v_int = G_PARAM_SPEC_BOOLEAN (pspec)->default_value;
102 param_boolean_validate (GParamSpec *pspec,
105 gint oval = value->data[0].v_int;
107 value->data[0].v_int = value->data[0].v_int != FALSE;
109 return value->data[0].v_int != oval;
113 param_int_init (GParamSpec *pspec)
115 GParamSpecInt *ispec = G_PARAM_SPEC_INT (pspec);
117 ispec->minimum = 0x7fffffff;
118 ispec->maximum = 0x80000000;
119 ispec->default_value = 0;
123 param_int_set_default (GParamSpec *pspec,
126 value->data[0].v_int = G_PARAM_SPEC_INT (pspec)->default_value;
130 param_int_validate (GParamSpec *pspec,
133 GParamSpecInt *ispec = G_PARAM_SPEC_INT (pspec);
134 gint oval = value->data[0].v_int;
136 value->data[0].v_int = CLAMP (value->data[0].v_int, ispec->minimum, ispec->maximum);
138 return value->data[0].v_int != oval;
142 param_int_values_cmp (GParamSpec *pspec,
143 const GValue *value1,
144 const GValue *value2)
146 if (value1->data[0].v_int < value2->data[0].v_int)
149 return value1->data[0].v_int > value2->data[0].v_int;
153 param_uint_init (GParamSpec *pspec)
155 GParamSpecUInt *uspec = G_PARAM_SPEC_UINT (pspec);
158 uspec->maximum = 0xffffffff;
159 uspec->default_value = 0;
163 param_uint_set_default (GParamSpec *pspec,
166 value->data[0].v_uint = G_PARAM_SPEC_UINT (pspec)->default_value;
170 param_uint_validate (GParamSpec *pspec,
173 GParamSpecUInt *uspec = G_PARAM_SPEC_UINT (pspec);
174 guint oval = value->data[0].v_uint;
176 value->data[0].v_uint = CLAMP (value->data[0].v_uint, uspec->minimum, uspec->maximum);
178 return value->data[0].v_uint != oval;
182 param_uint_values_cmp (GParamSpec *pspec,
183 const GValue *value1,
184 const GValue *value2)
186 if (value1->data[0].v_uint < value2->data[0].v_uint)
189 return value1->data[0].v_uint > value2->data[0].v_uint;
193 param_long_init (GParamSpec *pspec)
195 GParamSpecLong *lspec = G_PARAM_SPEC_LONG (pspec);
198 lspec->minimum = 0x7fffffff;
199 lspec->maximum = 0x80000000;
200 #else /* SIZEOF_LONG != 4 (8) */
201 lspec->minimum = 0x7fffffffffffffff;
202 lspec->maximum = 0x8000000000000000;
204 lspec->default_value = 0;
208 param_long_set_default (GParamSpec *pspec,
211 value->data[0].v_long = G_PARAM_SPEC_LONG (pspec)->default_value;
215 param_long_validate (GParamSpec *pspec,
218 GParamSpecLong *lspec = G_PARAM_SPEC_LONG (pspec);
219 glong oval = value->data[0].v_long;
221 value->data[0].v_long = CLAMP (value->data[0].v_long, lspec->minimum, lspec->maximum);
223 return value->data[0].v_long != oval;
227 param_long_values_cmp (GParamSpec *pspec,
228 const GValue *value1,
229 const GValue *value2)
231 if (value1->data[0].v_long < value2->data[0].v_long)
234 return value1->data[0].v_long > value2->data[0].v_long;
238 param_ulong_init (GParamSpec *pspec)
240 GParamSpecULong *uspec = G_PARAM_SPEC_ULONG (pspec);
244 uspec->maximum = 0xffffffff;
245 #else /* SIZEOF_LONG != 4 (8) */
246 uspec->maximum = 0xffffffffffffffff;
248 uspec->default_value = 0;
252 param_ulong_set_default (GParamSpec *pspec,
255 value->data[0].v_ulong = G_PARAM_SPEC_ULONG (pspec)->default_value;
259 param_ulong_validate (GParamSpec *pspec,
262 GParamSpecULong *uspec = G_PARAM_SPEC_ULONG (pspec);
263 gulong oval = value->data[0].v_ulong;
265 value->data[0].v_ulong = CLAMP (value->data[0].v_ulong, uspec->minimum, uspec->maximum);
267 return value->data[0].v_ulong != oval;
271 param_ulong_values_cmp (GParamSpec *pspec,
272 const GValue *value1,
273 const GValue *value2)
275 if (value1->data[0].v_ulong < value2->data[0].v_ulong)
278 return value1->data[0].v_ulong > value2->data[0].v_ulong;
282 param_enum_init (GParamSpec *pspec)
284 GParamSpecEnum *espec = G_PARAM_SPEC_ENUM (pspec);
286 espec->enum_class = NULL;
287 espec->default_value = 0;
291 param_enum_finalize (GParamSpec *pspec)
293 GParamSpecEnum *espec = G_PARAM_SPEC_ENUM (pspec);
294 GParamSpecClass *parent_class = g_type_class_peek (g_type_parent (G_TYPE_PARAM_ENUM));
296 if (espec->enum_class)
298 g_type_class_unref (espec->enum_class);
299 espec->enum_class = NULL;
302 parent_class->finalize (pspec);
306 param_enum_set_default (GParamSpec *pspec,
309 value->data[0].v_long = G_PARAM_SPEC_ENUM (pspec)->default_value;
313 param_enum_validate (GParamSpec *pspec,
316 GParamSpecEnum *espec = G_PARAM_SPEC_ENUM (pspec);
317 glong oval = value->data[0].v_long;
319 if (!espec->enum_class ||
320 !g_enum_get_value (espec->enum_class, value->data[0].v_long))
321 value->data[0].v_long = espec->default_value;
323 return value->data[0].v_long != oval;
327 param_flags_init (GParamSpec *pspec)
329 GParamSpecFlags *fspec = G_PARAM_SPEC_FLAGS (pspec);
331 fspec->flags_class = NULL;
332 fspec->default_value = 0;
336 param_flags_finalize (GParamSpec *pspec)
338 GParamSpecFlags *fspec = G_PARAM_SPEC_FLAGS (pspec);
339 GParamSpecClass *parent_class = g_type_class_peek (g_type_parent (G_TYPE_PARAM_FLAGS));
341 if (fspec->flags_class)
343 g_type_class_unref (fspec->flags_class);
344 fspec->flags_class = NULL;
347 parent_class->finalize (pspec);
351 param_flags_set_default (GParamSpec *pspec,
354 value->data[0].v_ulong = G_PARAM_SPEC_FLAGS (pspec)->default_value;
358 param_flags_validate (GParamSpec *pspec,
361 GParamSpecFlags *fspec = G_PARAM_SPEC_FLAGS (pspec);
362 gulong oval = value->data[0].v_ulong;
364 if (fspec->flags_class)
365 value->data[0].v_ulong &= fspec->flags_class->mask;
367 value->data[0].v_ulong = fspec->default_value;
369 return value->data[0].v_ulong != oval;
373 param_float_init (GParamSpec *pspec)
375 GParamSpecFloat *fspec = G_PARAM_SPEC_FLOAT (pspec);
377 fspec->minimum = G_MINFLOAT;
378 fspec->maximum = G_MAXFLOAT;
379 fspec->default_value = 0;
380 fspec->epsilon = G_FLOAT_EPSILON;
384 param_float_set_default (GParamSpec *pspec,
387 value->data[0].v_float = G_PARAM_SPEC_FLOAT (pspec)->default_value;
391 param_float_validate (GParamSpec *pspec,
394 GParamSpecFloat *fspec = G_PARAM_SPEC_FLOAT (pspec);
395 gfloat oval = value->data[0].v_float;
397 value->data[0].v_float = CLAMP (value->data[0].v_float, fspec->minimum, fspec->maximum);
399 return value->data[0].v_float != oval;
403 param_float_values_cmp (GParamSpec *pspec,
404 const GValue *value1,
405 const GValue *value2)
407 gfloat epsilon = G_PARAM_SPEC_FLOAT (pspec)->epsilon;
409 if (value1->data[0].v_float < value2->data[0].v_float)
410 return - (value2->data[0].v_float - value1->data[0].v_float > epsilon);
412 return value1->data[0].v_float - value2->data[0].v_float > epsilon;
416 param_double_init (GParamSpec *pspec)
418 GParamSpecDouble *dspec = G_PARAM_SPEC_DOUBLE (pspec);
420 dspec->minimum = G_MINDOUBLE;
421 dspec->maximum = G_MAXDOUBLE;
422 dspec->default_value = 0;
423 dspec->epsilon = G_DOUBLE_EPSILON;
427 param_double_set_default (GParamSpec *pspec,
430 value->data[0].v_double = G_PARAM_SPEC_DOUBLE (pspec)->default_value;
434 param_double_validate (GParamSpec *pspec,
437 GParamSpecDouble *dspec = G_PARAM_SPEC_DOUBLE (pspec);
438 gdouble oval = value->data[0].v_double;
440 value->data[0].v_double = CLAMP (value->data[0].v_double, dspec->minimum, dspec->maximum);
442 return value->data[0].v_double != oval;
446 param_double_values_cmp (GParamSpec *pspec,
447 const GValue *value1,
448 const GValue *value2)
450 gdouble epsilon = G_PARAM_SPEC_DOUBLE (pspec)->epsilon;
452 if (value1->data[0].v_double < value2->data[0].v_double)
453 return - (value2->data[0].v_double - value1->data[0].v_double > epsilon);
455 return value1->data[0].v_double - value2->data[0].v_double > epsilon;
459 param_string_init (GParamSpec *pspec)
461 GParamSpecString *sspec = G_PARAM_SPEC_STRING (pspec);
463 sspec->default_value = NULL;
464 sspec->cset_first = NULL;
465 sspec->cset_nth = NULL;
466 sspec->substitutor = '_';
467 sspec->null_fold_if_empty = FALSE;
468 sspec->ensure_non_null = FALSE;
472 param_string_finalize (GParamSpec *pspec)
474 GParamSpecString *sspec = G_PARAM_SPEC_STRING (pspec);
475 GParamSpecClass *parent_class = g_type_class_peek (g_type_parent (G_TYPE_PARAM_STRING));
477 g_free (sspec->default_value);
478 g_free (sspec->cset_first);
479 g_free (sspec->cset_nth);
480 sspec->default_value = NULL;
481 sspec->cset_first = NULL;
482 sspec->cset_nth = NULL;
484 parent_class->finalize (pspec);
488 param_string_set_default (GParamSpec *pspec,
491 value->data[0].v_pointer = g_strdup (G_PARAM_SPEC_STRING (pspec)->default_value);
495 param_string_validate (GParamSpec *pspec,
498 GParamSpecString *sspec = G_PARAM_SPEC_STRING (pspec);
499 gchar *string = value->data[0].v_pointer;
502 if (string && string[0])
506 if (sspec->cset_first && !strchr (sspec->cset_first, string[0]))
508 string[0] = sspec->substitutor;
512 for (s = string + 1; *s; s++)
513 if (!strchr (sspec->cset_nth, *s))
515 *s = sspec->substitutor;
519 if (sspec->null_fold_if_empty && string && string[0] == 0)
521 g_free (value->data[0].v_pointer);
522 value->data[0].v_pointer = NULL;
524 string = value->data[0].v_pointer;
526 if (sspec->ensure_non_null && !string)
528 value->data[0].v_pointer = g_strdup ("");
530 string = value->data[0].v_pointer;
537 param_string_values_cmp (GParamSpec *pspec,
538 const GValue *value1,
539 const GValue *value2)
541 if (!value1->data[0].v_pointer)
542 return value2->data[0].v_pointer != NULL ? -1 : 0;
543 else if (!value2->data[0].v_pointer)
544 return value1->data[0].v_pointer != NULL;
546 return strcmp (value1->data[0].v_pointer, value2->data[0].v_pointer);
550 param_param_init (GParamSpec *pspec)
552 /* GParamSpecParam *spec = G_PARAM_SPEC_PARAM (pspec); */
556 param_param_set_default (GParamSpec *pspec,
559 value->data[0].v_pointer = NULL;
563 param_param_validate (GParamSpec *pspec,
566 /* GParamSpecParam *spec = G_PARAM_SPEC_PARAM (pspec); */
567 GParamSpec *param = value->data[0].v_pointer;
570 if (param && !g_value_type_compatible (G_PARAM_SPEC_TYPE (param), G_PARAM_SPEC_VALUE_TYPE (pspec)))
572 g_param_spec_unref (param);
573 value->data[0].v_pointer = NULL;
581 param_boxed_init (GParamSpec *pspec)
583 /* GParamSpecBoxed *bspec = G_PARAM_SPEC_BOXED (pspec); */
587 param_boxed_set_default (GParamSpec *pspec,
590 value->data[0].v_pointer = NULL;
594 param_boxed_validate (GParamSpec *pspec,
597 /* GParamSpecBoxed *bspec = G_PARAM_SPEC_BOXED (pspec); */
600 /* can't do a whole lot here since we haven't even G_BOXED_TYPE() */
606 param_boxed_values_cmp (GParamSpec *pspec,
607 const GValue *value1,
608 const GValue *value2)
610 guint8 *p1 = value1->data[0].v_pointer;
611 guint8 *p2 = value2->data[0].v_pointer;
613 /* not much to compare here, try to at least provide stable lesser/greater result */
615 return p1 < p2 ? -1 : p1 > p2;
619 param_pointer_init (GParamSpec *pspec)
621 /* GParamSpecPointer *spec = G_PARAM_SPEC_POINTER (pspec); */
625 param_pointer_set_default (GParamSpec *pspec,
628 value->data[0].v_pointer = NULL;
632 param_pointer_validate (GParamSpec *pspec,
635 /* GParamSpecPointer *spec = G_PARAM_SPEC_POINTER (pspec); */
642 param_pointer_values_cmp (GParamSpec *pspec,
643 const GValue *value1,
644 const GValue *value2)
646 guint8 *p1 = value1->data[0].v_pointer;
647 guint8 *p2 = value2->data[0].v_pointer;
649 /* not much to compare here, try to at least provide stable lesser/greater result */
651 return p1 < p2 ? -1 : p1 > p2;
655 param_closure_init (GParamSpec *pspec)
657 /* GParamSpecClosure *cspec = G_PARAM_SPEC_CLOSURE (pspec); */
661 param_closure_set_default (GParamSpec *pspec,
664 value->data[0].v_pointer = NULL;
668 param_closure_validate (GParamSpec *pspec,
671 /* GParamSpecClosure *cspec = G_PARAM_SPEC_CLOSURE (pspec); */
672 /* GClosure *closure = value->data[0].v_pointer; */
675 /* we don't actually have necessary means to ensure closure validity */
681 param_closure_values_cmp (GParamSpec *pspec,
682 const GValue *value1,
683 const GValue *value2)
685 guint8 *p1 = value1->data[0].v_pointer;
686 guint8 *p2 = value2->data[0].v_pointer;
688 /* not much to compare here, try to at least provide stable lesser/greater result */
690 return p1 < p2 ? -1 : p1 > p2;
694 param_value_array_init (GParamSpec *pspec)
696 GParamSpecValueArray *aspec = G_PARAM_SPEC_VALUE_ARRAY (pspec);
698 aspec->element_spec = NULL;
699 aspec->fixed_n_elements = 0; /* disable */
703 value_array_ensure_size (GValueArray *value_array,
704 guint fixed_n_elements)
708 if (fixed_n_elements)
710 while (value_array->n_values < fixed_n_elements)
712 g_value_array_append (value_array, NULL);
715 while (value_array->n_values > fixed_n_elements)
717 g_value_array_remove (value_array, value_array->n_values - 1);
725 param_value_array_finalize (GParamSpec *pspec)
727 GParamSpecValueArray *aspec = G_PARAM_SPEC_VALUE_ARRAY (pspec);
728 GParamSpecClass *parent_class = g_type_class_peek (g_type_parent (G_TYPE_PARAM_VALUE_ARRAY));
730 if (aspec->element_spec)
732 g_param_spec_unref (aspec->element_spec);
733 aspec->element_spec = NULL;
736 parent_class->finalize (pspec);
740 param_value_array_set_default (GParamSpec *pspec,
743 GParamSpecValueArray *aspec = G_PARAM_SPEC_VALUE_ARRAY (pspec);
745 g_return_if_fail (value->data[0].v_pointer != NULL); /* paranoid */
747 /* g_value_reset (value); already done */
748 value_array_ensure_size (value->data[0].v_pointer, aspec->fixed_n_elements);
752 param_value_array_validate (GParamSpec *pspec,
755 GParamSpecValueArray *aspec = G_PARAM_SPEC_VALUE_ARRAY (pspec);
756 GValueArray *value_array = value->data[0].v_pointer;
759 g_return_val_if_fail (value->data[0].v_pointer != NULL, FALSE); /* paranoid */
761 /* ensure array size validity */
762 changed += value_array_ensure_size (value_array, aspec->fixed_n_elements);
764 /* ensure array values validity against a present element spec */
765 if (aspec->element_spec)
767 GParamSpec *element_spec = aspec->element_spec;
770 for (i = 0; i < value_array->n_values; i++)
772 GValue *element = value_array->values + i;
774 /* need to fixup value type, or ensure that the array value is initialized at all */
775 if (!g_value_type_compatible (G_VALUE_TYPE (element), G_PARAM_SPEC_VALUE_TYPE (element_spec)))
777 if (G_VALUE_TYPE (element) != 0)
778 g_value_unset (element);
779 g_value_init (element, G_PARAM_SPEC_VALUE_TYPE (element_spec));
780 g_param_value_set_default (element_spec, element);
783 /* validate array value against element_spec */
784 changed += g_param_value_validate (element_spec, element);
792 param_value_array_values_cmp (GParamSpec *pspec,
793 const GValue *value1,
794 const GValue *value2)
796 GParamSpecValueArray *aspec = G_PARAM_SPEC_VALUE_ARRAY (pspec);
797 GValueArray *value_array1 = value1->data[0].v_pointer;
798 GValueArray *value_array2 = value2->data[0].v_pointer;
800 g_return_val_if_fail (value1->data[0].v_pointer != NULL, -1); /* paranoid */
801 g_return_val_if_fail (value2->data[0].v_pointer != NULL, 1); /* paranoid */
803 if (value_array1->n_values != value_array2->n_values)
804 return value_array1->n_values < value_array2->n_values ? -1 : 1;
805 else if (!aspec->element_spec)
807 /* we need an element specification for comparisons, so there's not much
808 * to compare here, try to at least provide stable lesser/greater result
810 return value_array1->n_values < value_array2->n_values ? -1 : value_array1->n_values > value_array2->n_values;
812 else /* value_array1->n_values == value_array2->n_values */
816 for (i = 0; i < value_array1->n_values; i++)
818 GValue *element1 = value_array1->values + i;
819 GValue *element2 = value_array2->values + i;
822 /* need corresponding element types, provide stable result otherwise */
823 if (G_VALUE_TYPE (element1) != G_VALUE_TYPE (element2))
824 return G_VALUE_TYPE (element1) < G_VALUE_TYPE (element2) ? -1 : 1;
825 cmp = g_param_values_cmp (aspec->element_spec, element1, element2);
834 param_object_init (GParamSpec *pspec)
836 /* GParamSpecObject *ospec = G_PARAM_SPEC_OBJECT (pspec); */
840 param_object_set_default (GParamSpec *pspec,
843 value->data[0].v_pointer = NULL;
847 param_object_validate (GParamSpec *pspec,
850 GParamSpecObject *ospec = G_PARAM_SPEC_OBJECT (pspec);
851 GObject *object = value->data[0].v_pointer;
854 if (object && !g_value_type_compatible (G_OBJECT_TYPE (object), G_PARAM_SPEC_VALUE_TYPE (ospec)))
856 g_object_unref (object);
857 value->data[0].v_pointer = NULL;
865 param_object_values_cmp (GParamSpec *pspec,
866 const GValue *value1,
867 const GValue *value2)
869 guint8 *p1 = value1->data[0].v_pointer;
870 guint8 *p2 = value2->data[0].v_pointer;
872 /* not much to compare here, try to at least provide stable lesser/greater result */
874 return p1 < p2 ? -1 : p1 > p2;
878 /* --- type initialization --- */
880 g_param_spec_types_init (void) /* sync with gtype.c */
887 static const GParamSpecTypeInfo pspec_info = {
888 sizeof (GParamSpecChar), /* instance_size */
889 16, /* n_preallocs */
890 param_char_init, /* instance_init */
891 G_TYPE_CHAR, /* value_type */
893 param_char_set_default, /* value_set_default */
894 param_char_validate, /* value_validate */
895 param_int_values_cmp, /* values_cmp */
897 type = g_param_type_register_static ("GParamChar", &pspec_info);
898 g_assert (type == G_TYPE_PARAM_CHAR);
901 /* G_TYPE_PARAM_UCHAR
904 static const GParamSpecTypeInfo pspec_info = {
905 sizeof (GParamSpecUChar), /* instance_size */
906 16, /* n_preallocs */
907 param_uchar_init, /* instance_init */
908 G_TYPE_UCHAR, /* value_type */
910 param_uchar_set_default, /* value_set_default */
911 param_uchar_validate, /* value_validate */
912 param_uint_values_cmp, /* values_cmp */
914 type = g_param_type_register_static ("GParamUChar", &pspec_info);
915 g_assert (type == G_TYPE_PARAM_UCHAR);
918 /* G_TYPE_PARAM_BOOLEAN
921 static const GParamSpecTypeInfo pspec_info = {
922 sizeof (GParamSpecBoolean), /* instance_size */
923 16, /* n_preallocs */
924 NULL, /* instance_init */
925 G_TYPE_BOOLEAN, /* value_type */
927 param_boolean_set_default, /* value_set_default */
928 param_boolean_validate, /* value_validate */
929 param_int_values_cmp, /* values_cmp */
931 type = g_param_type_register_static ("GParamBoolean", &pspec_info);
932 g_assert (type == G_TYPE_PARAM_BOOLEAN);
938 static const GParamSpecTypeInfo pspec_info = {
939 sizeof (GParamSpecInt), /* instance_size */
940 16, /* n_preallocs */
941 param_int_init, /* instance_init */
942 G_TYPE_INT, /* value_type */
944 param_int_set_default, /* value_set_default */
945 param_int_validate, /* value_validate */
946 param_int_values_cmp, /* values_cmp */
948 type = g_param_type_register_static ("GParamInt", &pspec_info);
949 g_assert (type == G_TYPE_PARAM_INT);
955 static const GParamSpecTypeInfo pspec_info = {
956 sizeof (GParamSpecUInt), /* instance_size */
957 16, /* n_preallocs */
958 param_uint_init, /* instance_init */
959 G_TYPE_UINT, /* value_type */
961 param_uint_set_default, /* value_set_default */
962 param_uint_validate, /* value_validate */
963 param_uint_values_cmp, /* values_cmp */
965 type = g_param_type_register_static ("GParamUInt", &pspec_info);
966 g_assert (type == G_TYPE_PARAM_UINT);
972 static const GParamSpecTypeInfo pspec_info = {
973 sizeof (GParamSpecLong), /* instance_size */
974 16, /* n_preallocs */
975 param_long_init, /* instance_init */
976 G_TYPE_LONG, /* value_type */
978 param_long_set_default, /* value_set_default */
979 param_long_validate, /* value_validate */
980 param_long_values_cmp, /* values_cmp */
982 type = g_param_type_register_static ("GParamLong", &pspec_info);
983 g_assert (type == G_TYPE_PARAM_LONG);
986 /* G_TYPE_PARAM_ULONG
989 static const GParamSpecTypeInfo pspec_info = {
990 sizeof (GParamSpecULong), /* instance_size */
991 16, /* n_preallocs */
992 param_ulong_init, /* instance_init */
993 G_TYPE_ULONG, /* value_type */
995 param_ulong_set_default, /* value_set_default */
996 param_ulong_validate, /* value_validate */
997 param_ulong_values_cmp, /* values_cmp */
999 type = g_param_type_register_static ("GParamULong", &pspec_info);
1000 g_assert (type == G_TYPE_PARAM_ULONG);
1003 /* G_TYPE_PARAM_ENUM
1006 static const GParamSpecTypeInfo pspec_info = {
1007 sizeof (GParamSpecEnum), /* instance_size */
1008 16, /* n_preallocs */
1009 param_enum_init, /* instance_init */
1010 G_TYPE_ENUM, /* value_type */
1011 param_enum_finalize, /* finalize */
1012 param_enum_set_default, /* value_set_default */
1013 param_enum_validate, /* value_validate */
1014 param_long_values_cmp, /* values_cmp */
1016 type = g_param_type_register_static ("GParamEnum", &pspec_info);
1017 g_assert (type == G_TYPE_PARAM_ENUM);
1020 /* G_TYPE_PARAM_FLAGS
1023 static const GParamSpecTypeInfo pspec_info = {
1024 sizeof (GParamSpecFlags), /* instance_size */
1025 16, /* n_preallocs */
1026 param_flags_init, /* instance_init */
1027 G_TYPE_FLAGS, /* value_type */
1028 param_flags_finalize, /* finalize */
1029 param_flags_set_default, /* value_set_default */
1030 param_flags_validate, /* value_validate */
1031 param_ulong_values_cmp, /* values_cmp */
1033 type = g_param_type_register_static ("GParamFlags", &pspec_info);
1034 g_assert (type == G_TYPE_PARAM_FLAGS);
1037 /* G_TYPE_PARAM_FLOAT
1040 static const GParamSpecTypeInfo pspec_info = {
1041 sizeof (GParamSpecFloat), /* instance_size */
1042 16, /* n_preallocs */
1043 param_float_init, /* instance_init */
1044 G_TYPE_FLOAT, /* value_type */
1045 NULL, /* finalize */
1046 param_float_set_default, /* value_set_default */
1047 param_float_validate, /* value_validate */
1048 param_float_values_cmp, /* values_cmp */
1050 type = g_param_type_register_static ("GParamFloat", &pspec_info);
1051 g_assert (type == G_TYPE_PARAM_FLOAT);
1054 /* G_TYPE_PARAM_DOUBLE
1057 static const GParamSpecTypeInfo pspec_info = {
1058 sizeof (GParamSpecDouble), /* instance_size */
1059 16, /* n_preallocs */
1060 param_double_init, /* instance_init */
1061 G_TYPE_DOUBLE, /* value_type */
1062 NULL, /* finalize */
1063 param_double_set_default, /* value_set_default */
1064 param_double_validate, /* value_validate */
1065 param_double_values_cmp, /* values_cmp */
1067 type = g_param_type_register_static ("GParamDouble", &pspec_info);
1068 g_assert (type == G_TYPE_PARAM_DOUBLE);
1071 /* G_TYPE_PARAM_STRING
1074 static const GParamSpecTypeInfo pspec_info = {
1075 sizeof (GParamSpecString), /* instance_size */
1076 16, /* n_preallocs */
1077 param_string_init, /* instance_init */
1078 G_TYPE_STRING, /* value_type */
1079 param_string_finalize, /* finalize */
1080 param_string_set_default, /* value_set_default */
1081 param_string_validate, /* value_validate */
1082 param_string_values_cmp, /* values_cmp */
1084 type = g_param_type_register_static ("GParamString", &pspec_info);
1085 g_assert (type == G_TYPE_PARAM_STRING);
1088 /* G_TYPE_PARAM_PARAM
1091 static const GParamSpecTypeInfo pspec_info = {
1092 sizeof (GParamSpecParam), /* instance_size */
1093 16, /* n_preallocs */
1094 param_param_init, /* instance_init */
1095 G_TYPE_PARAM, /* value_type */
1096 NULL, /* finalize */
1097 param_param_set_default, /* value_set_default */
1098 param_param_validate, /* value_validate */
1099 param_pointer_values_cmp, /* values_cmp */
1101 type = g_param_type_register_static ("GParamParam", &pspec_info);
1102 g_assert (type == G_TYPE_PARAM_PARAM);
1105 /* G_TYPE_PARAM_BOXED
1108 static const GParamSpecTypeInfo pspec_info = {
1109 sizeof (GParamSpecBoxed), /* instance_size */
1110 4, /* n_preallocs */
1111 param_boxed_init, /* instance_init */
1112 G_TYPE_BOXED, /* value_type */
1113 NULL, /* finalize */
1114 param_boxed_set_default, /* value_set_default */
1115 param_boxed_validate, /* value_validate */
1116 param_boxed_values_cmp, /* values_cmp */
1118 type = g_param_type_register_static ("GParamBoxed", &pspec_info);
1119 g_assert (type == G_TYPE_PARAM_BOXED);
1122 /* G_TYPE_PARAM_POINTER
1125 static const GParamSpecTypeInfo pspec_info = {
1126 sizeof (GParamSpecPointer), /* instance_size */
1127 0, /* n_preallocs */
1128 param_pointer_init, /* instance_init */
1129 G_TYPE_POINTER, /* value_type */
1130 NULL, /* finalize */
1131 param_pointer_set_default, /* value_set_default */
1132 param_pointer_validate, /* value_validate */
1133 param_pointer_values_cmp, /* values_cmp */
1135 type = g_param_type_register_static ("GParamPointer", &pspec_info);
1136 g_assert (type == G_TYPE_PARAM_POINTER);
1139 /* G_TYPE_PARAM_VALUE_ARRAY
1142 static const GParamSpecTypeInfo pspec_info = {
1143 sizeof (GParamSpecValueArray), /* instance_size */
1144 0, /* n_preallocs */
1145 param_value_array_init, /* instance_init */
1146 G_TYPE_VALUE_ARRAY, /* value_type */
1147 param_value_array_finalize, /* finalize */
1148 param_value_array_set_default, /* value_set_default */
1149 param_value_array_validate, /* value_validate */
1150 param_value_array_values_cmp, /* values_cmp */
1152 type = g_param_type_register_static ("GParamValueArray", &pspec_info);
1153 g_assert (type == G_TYPE_PARAM_VALUE_ARRAY);
1156 /* G_TYPE_PARAM_CLOSURE
1159 static const GParamSpecTypeInfo pspec_info = {
1160 sizeof (GParamSpecClosure), /* instance_size */
1161 0, /* n_preallocs */
1162 param_closure_init, /* instance_init */
1163 G_TYPE_CLOSURE, /* value_type */
1164 NULL, /* finalize */
1165 param_closure_set_default, /* value_set_default */
1166 param_closure_validate, /* value_validate */
1167 param_closure_values_cmp, /* values_cmp */
1169 type = g_param_type_register_static ("GParamClosure", &pspec_info);
1170 g_assert (type == G_TYPE_PARAM_CLOSURE);
1173 /* G_TYPE_PARAM_OBJECT
1176 static const GParamSpecTypeInfo pspec_info = {
1177 sizeof (GParamSpecObject), /* instance_size */
1178 16, /* n_preallocs */
1179 param_object_init, /* instance_init */
1180 G_TYPE_OBJECT, /* value_type */
1181 NULL, /* finalize */
1182 param_object_set_default, /* value_set_default */
1183 param_object_validate, /* value_validate */
1184 param_object_values_cmp, /* values_cmp */
1186 type = g_param_type_register_static ("GParamObject", &pspec_info);
1187 g_assert (type == G_TYPE_PARAM_OBJECT);
1192 /* --- GParamSpec initialization --- */
1194 g_param_spec_char (const gchar *name,
1199 gint8 default_value,
1202 GParamSpecChar *cspec = g_param_spec_internal (G_TYPE_PARAM_CHAR,
1208 cspec->minimum = minimum;
1209 cspec->maximum = maximum;
1210 cspec->default_value = default_value;
1212 return G_PARAM_SPEC (cspec);
1216 g_param_spec_uchar (const gchar *name,
1221 guint8 default_value,
1224 GParamSpecUChar *uspec = g_param_spec_internal (G_TYPE_PARAM_UCHAR,
1230 uspec->minimum = minimum;
1231 uspec->maximum = maximum;
1232 uspec->default_value = default_value;
1234 return G_PARAM_SPEC (uspec);
1238 g_param_spec_boolean (const gchar *name,
1241 gboolean default_value,
1244 GParamSpecBoolean *bspec = g_param_spec_internal (G_TYPE_PARAM_BOOLEAN,
1250 bspec->default_value = default_value;
1252 return G_PARAM_SPEC (bspec);
1256 g_param_spec_int (const gchar *name,
1264 GParamSpecInt *ispec = g_param_spec_internal (G_TYPE_PARAM_INT,
1270 ispec->minimum = minimum;
1271 ispec->maximum = maximum;
1272 ispec->default_value = default_value;
1274 return G_PARAM_SPEC (ispec);
1278 g_param_spec_uint (const gchar *name,
1283 guint default_value,
1286 GParamSpecUInt *uspec = g_param_spec_internal (G_TYPE_PARAM_UINT,
1292 uspec->minimum = minimum;
1293 uspec->maximum = maximum;
1294 uspec->default_value = default_value;
1296 return G_PARAM_SPEC (uspec);
1300 g_param_spec_long (const gchar *name,
1305 glong default_value,
1308 GParamSpecLong *lspec = g_param_spec_internal (G_TYPE_PARAM_LONG,
1314 lspec->minimum = minimum;
1315 lspec->maximum = maximum;
1316 lspec->default_value = default_value;
1318 return G_PARAM_SPEC (lspec);
1322 g_param_spec_ulong (const gchar *name,
1327 gulong default_value,
1330 GParamSpecULong *uspec = g_param_spec_internal (G_TYPE_PARAM_ULONG,
1336 uspec->minimum = minimum;
1337 uspec->maximum = maximum;
1338 uspec->default_value = default_value;
1340 return G_PARAM_SPEC (uspec);
1344 g_param_spec_enum (const gchar *name,
1351 GParamSpecEnum *espec;
1353 g_return_val_if_fail (G_TYPE_IS_ENUM (enum_type), NULL);
1355 espec = g_param_spec_internal (G_TYPE_PARAM_ENUM,
1361 espec->enum_class = g_type_class_ref (enum_type);
1362 espec->default_value = default_value;
1363 G_PARAM_SPEC (espec)->value_type = enum_type;
1365 return G_PARAM_SPEC (espec);
1369 g_param_spec_flags (const gchar *name,
1373 guint default_value,
1376 GParamSpecFlags *fspec;
1378 g_return_val_if_fail (G_TYPE_IS_FLAGS (flags_type), NULL);
1380 fspec = g_param_spec_internal (G_TYPE_PARAM_FLAGS,
1386 fspec->flags_class = g_type_class_ref (flags_type);
1387 fspec->default_value = default_value;
1388 G_PARAM_SPEC (fspec)->value_type = flags_type;
1390 return G_PARAM_SPEC (fspec);
1394 g_param_spec_float (const gchar *name,
1399 gfloat default_value,
1402 GParamSpecFloat *fspec = g_param_spec_internal (G_TYPE_PARAM_FLOAT,
1408 fspec->minimum = minimum;
1409 fspec->maximum = maximum;
1410 fspec->default_value = default_value;
1412 return G_PARAM_SPEC (fspec);
1416 g_param_spec_double (const gchar *name,
1421 gdouble default_value,
1424 GParamSpecDouble *dspec = g_param_spec_internal (G_TYPE_PARAM_DOUBLE,
1430 dspec->minimum = minimum;
1431 dspec->maximum = maximum;
1432 dspec->default_value = default_value;
1434 return G_PARAM_SPEC (dspec);
1438 g_param_spec_string (const gchar *name,
1441 const gchar *default_value,
1444 GParamSpecString *sspec = g_param_spec_internal (G_TYPE_PARAM_STRING,
1449 g_free (sspec->default_value);
1450 sspec->default_value = g_strdup (default_value);
1452 return G_PARAM_SPEC (sspec);
1456 g_param_spec_stringc (const gchar *name,
1459 const gchar *default_value,
1462 GParamSpecString *sspec = g_param_spec_internal (G_TYPE_PARAM_STRING,
1467 g_free (sspec->default_value);
1468 sspec->default_value = g_strdup (default_value);
1469 g_free (sspec->cset_first);
1470 sspec->cset_first = g_strdup (G_CSET_a_2_z "_" G_CSET_A_2_Z);
1471 g_free (sspec->cset_nth);
1472 sspec->cset_nth = g_strdup (G_CSET_a_2_z
1474 /* G_CSET_LATINS G_CSET_LATINC */
1477 return G_PARAM_SPEC (sspec);
1481 g_param_spec_param (const gchar *name,
1487 GParamSpecParam *pspec;
1489 g_return_val_if_fail (G_TYPE_IS_PARAM (param_type), NULL);
1491 pspec = g_param_spec_internal (G_TYPE_PARAM_PARAM,
1496 G_PARAM_SPEC (pspec)->value_type = param_type;
1498 return G_PARAM_SPEC (pspec);
1502 g_param_spec_boxed (const gchar *name,
1508 GParamSpecBoxed *bspec;
1510 g_return_val_if_fail (G_TYPE_IS_BOXED (boxed_type), NULL);
1511 g_return_val_if_fail (G_TYPE_IS_DERIVED (boxed_type), NULL);
1513 bspec = g_param_spec_internal (G_TYPE_PARAM_BOXED,
1518 G_PARAM_SPEC (bspec)->value_type = boxed_type;
1520 return G_PARAM_SPEC (bspec);
1524 g_param_spec_pointer (const gchar *name,
1529 GParamSpecPointer *pspec;
1531 pspec = g_param_spec_internal (G_TYPE_PARAM_POINTER,
1536 return G_PARAM_SPEC (pspec);
1540 g_param_spec_value_array (const gchar *name,
1543 GParamSpec *element_spec,
1546 GParamSpecValueArray *aspec;
1549 g_return_val_if_fail (G_IS_PARAM_SPEC (element_spec), NULL);
1551 aspec = g_param_spec_internal (G_TYPE_PARAM_VALUE_ARRAY,
1558 aspec->element_spec = g_param_spec_ref (element_spec);
1559 g_param_spec_sink (element_spec);
1562 return G_PARAM_SPEC (aspec);
1566 g_param_spec_closure (const gchar *name,
1571 GParamSpecClosure *cspec;
1573 cspec = g_param_spec_internal (G_TYPE_PARAM_CLOSURE,
1578 return G_PARAM_SPEC (cspec);
1582 g_param_spec_object (const gchar *name,
1588 GParamSpecObject *ospec;
1590 g_return_val_if_fail (G_TYPE_IS_OBJECT (object_type), NULL);
1592 ospec = g_param_spec_internal (G_TYPE_PARAM_OBJECT,
1597 G_PARAM_SPEC (ospec)->value_type = object_type;
1599 return G_PARAM_SPEC (ospec);