gparamspecs.c revision 71a6ca2542299e9bf6d081e033f05e0153a6d210 
1/* GObject - GLib Type, Object, Parameter and Signal Library
2 * Copyright (C) 1997, 1998, 1999, 2000 Tim Janik and Red Hat, 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 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
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.
18 */
19#include	"gparamspecs.h"
20
21#include	"gvaluecollector.h"
22#include	<string.h>
23#include	"../config.h"	/* for SIZEOF_LONG */
24
25#define	G_FLOAT_EPSILON		(1e-30)
26#define	G_DOUBLE_EPSILON	(1e-90)
27
28
29/* --- param spec functions --- */
30static void
31param_spec_char_init (GParamSpec *pspec)
32{
33  GParamSpecChar *cspec = G_PARAM_SPEC_CHAR (pspec);
34
35  cspec->minimum = 0x7f;
36  cspec->maximum = 0x80;
37  cspec->default_value = 0;
38}
39
40static void
41param_char_set_default (GParamSpec *pspec,
42			GValue	   *value)
43{
44  value->data[0].v_int = G_PARAM_SPEC_CHAR (pspec)->default_value;
45}
46
47static gboolean
48param_char_validate (GParamSpec *pspec,
49		     GValue     *value)
50{
51  GParamSpecChar *cspec = G_PARAM_SPEC_CHAR (pspec);
52  gint oval = value->data[0].v_int;
53
54  value->data[0].v_int = CLAMP (value->data[0].v_int, cspec->minimum, cspec->maximum);
55
56  return value->data[0].v_int != oval;
57}
58
59static void
60param_spec_uchar_init (GParamSpec *pspec)
61{
62  GParamSpecUChar *uspec = G_PARAM_SPEC_UCHAR (pspec);
63
64  uspec->minimum = 0;
65  uspec->maximum = 0xff;
66  uspec->default_value = 0;
67}
68
69static void
70param_uchar_set_default (GParamSpec *pspec,
71			 GValue	    *value)
72{
73  value->data[0].v_uint = G_PARAM_SPEC_UCHAR (pspec)->default_value;
74}
75
76static gboolean
77param_uchar_validate (GParamSpec *pspec,
78		      GValue     *value)
79{
80  GParamSpecUChar *uspec = G_PARAM_SPEC_UCHAR (pspec);
81  guint oval = value->data[0].v_uint;
82
83  value->data[0].v_uint = CLAMP (value->data[0].v_uint, uspec->minimum, uspec->maximum);
84
85  return value->data[0].v_uint != oval;
86}
87
88static void
89param_boolean_set_default (GParamSpec *pspec,
90			   GValue     *value)
91{
92  value->data[0].v_int = G_PARAM_SPEC_BOOLEAN (pspec)->default_value;
93}
94
95static gboolean
96param_boolean_validate (GParamSpec *pspec,
97			GValue     *value)
98{
99  gint oval = value->data[0].v_int;
100
101  value->data[0].v_int = value->data[0].v_int != FALSE;
102
103  return value->data[0].v_int != oval;
104}
105
106static void
107param_spec_int_init (GParamSpec *pspec)
108{
109  GParamSpecInt *ispec = G_PARAM_SPEC_INT (pspec);
110
111  ispec->minimum = 0x7fffffff;
112  ispec->maximum = 0x80000000;
113  ispec->default_value = 0;
114}
115
116static void
117param_int_set_default (GParamSpec *pspec,
118		       GValue     *value)
119{
120  value->data[0].v_int = G_PARAM_SPEC_INT (pspec)->default_value;
121}
122
123static gboolean
124param_int_validate (GParamSpec *pspec,
125		    GValue     *value)
126{
127  GParamSpecInt *ispec = G_PARAM_SPEC_INT (pspec);
128  gint oval = value->data[0].v_int;
129
130  value->data[0].v_int = CLAMP (value->data[0].v_int, ispec->minimum, ispec->maximum);
131
132  return value->data[0].v_int != oval;
133}
134
135static gint
136param_int_values_cmp (GParamSpec   *pspec,
137		      const GValue *value1,
138		      const GValue *value2)
139{
140  if (value1->data[0].v_int < value2->data[0].v_int)
141    return -1;
142  else
143    return value1->data[0].v_int > value2->data[0].v_int;
144}
145
146static void
147param_spec_uint_init (GParamSpec *pspec)
148{
149  GParamSpecUInt *uspec = G_PARAM_SPEC_UINT (pspec);
150
151  uspec->minimum = 0;
152  uspec->maximum = 0xffffffff;
153  uspec->default_value = 0;
154}
155
156static void
157param_uint_set_default (GParamSpec *pspec,
158			GValue     *value)
159{
160  value->data[0].v_uint = G_PARAM_SPEC_UINT (pspec)->default_value;
161}
162
163static gboolean
164param_uint_validate (GParamSpec *pspec,
165		     GValue     *value)
166{
167  GParamSpecUInt *uspec = G_PARAM_SPEC_UINT (pspec);
168  guint oval = value->data[0].v_uint;
169
170  value->data[0].v_uint = CLAMP (value->data[0].v_uint, uspec->minimum, uspec->maximum);
171
172  return value->data[0].v_uint != oval;
173}
174
175static gint
176param_uint_values_cmp (GParamSpec   *pspec,
177		       const GValue *value1,
178		       const GValue *value2)
179{
180  if (value1->data[0].v_uint < value2->data[0].v_uint)
181    return -1;
182  else
183    return value1->data[0].v_uint > value2->data[0].v_uint;
184}
185
186static void
187param_spec_long_init (GParamSpec *pspec)
188{
189  GParamSpecLong *lspec = G_PARAM_SPEC_LONG (pspec);
190
191#if SIZEOF_LONG == 4
192  lspec->minimum = 0x7fffffff;
193  lspec->maximum = 0x80000000;
194#else /* SIZEOF_LONG != 4 (8) */
195  lspec->minimum = 0x7fffffffffffffff;
196  lspec->maximum = 0x8000000000000000;
197#endif
198  lspec->default_value = 0;
199}
200
201static void
202param_long_set_default (GParamSpec *pspec,
203			GValue     *value)
204{
205  value->data[0].v_long = G_PARAM_SPEC_LONG (pspec)->default_value;
206}
207
208static gboolean
209param_long_validate (GParamSpec *pspec,
210		     GValue     *value)
211{
212  GParamSpecLong *lspec = G_PARAM_SPEC_LONG (pspec);
213  glong oval = value->data[0].v_long;
214
215  value->data[0].v_long = CLAMP (value->data[0].v_long, lspec->minimum, lspec->maximum);
216
217  return value->data[0].v_long != oval;
218}
219
220static gint
221param_long_values_cmp (GParamSpec   *pspec,
222		       const GValue *value1,
223		       const GValue *value2)
224{
225  if (value1->data[0].v_long < value2->data[0].v_long)
226    return -1;
227  else
228    return value1->data[0].v_long > value2->data[0].v_long;
229}
230
231static void
232param_spec_ulong_init (GParamSpec *pspec)
233{
234  GParamSpecULong *uspec = G_PARAM_SPEC_ULONG (pspec);
235
236  uspec->minimum = 0;
237#if SIZEOF_LONG == 4
238  uspec->maximum = 0xffffffff;
239#else /* SIZEOF_LONG != 4 (8) */
240  uspec->maximum = 0xffffffffffffffff;
241#endif
242  uspec->default_value = 0;
243}
244
245static void
246param_ulong_set_default (GParamSpec *pspec,
247			 GValue     *value)
248{
249  value->data[0].v_ulong = G_PARAM_SPEC_ULONG (pspec)->default_value;
250}
251
252static gboolean
253param_ulong_validate (GParamSpec *pspec,
254		      GValue     *value)
255{
256  GParamSpecULong *uspec = G_PARAM_SPEC_ULONG (pspec);
257  gulong oval = value->data[0].v_ulong;
258
259  value->data[0].v_ulong = CLAMP (value->data[0].v_ulong, uspec->minimum, uspec->maximum);
260
261  return value->data[0].v_ulong != oval;
262}
263
264static gint
265param_ulong_values_cmp (GParamSpec   *pspec,
266			const GValue *value1,
267			const GValue *value2)
268{
269  if (value1->data[0].v_ulong < value2->data[0].v_ulong)
270    return -1;
271  else
272    return value1->data[0].v_ulong > value2->data[0].v_ulong;
273}
274
275static void
276param_spec_enum_init (GParamSpec *pspec)
277{
278  GParamSpecEnum *espec = G_PARAM_SPEC_ENUM (pspec);
279
280  espec->enum_class = NULL;
281  espec->default_value = 0;
282}
283
284static void
285param_spec_enum_finalize (GParamSpec *pspec)
286{
287  GParamSpecEnum *espec = G_PARAM_SPEC_ENUM (pspec);
288  GParamSpecClass *parent_class = g_type_class_peek (g_type_parent (G_TYPE_PARAM_ENUM));
289
290  if (espec->enum_class)
291    {
292      g_type_class_unref (espec->enum_class);
293      espec->enum_class = NULL;
294    }
295
296  parent_class->finalize (pspec);
297}
298
299static void
300param_enum_set_default (GParamSpec *pspec,
301			GValue     *value)
302{
303  value->data[0].v_long = G_PARAM_SPEC_ENUM (pspec)->default_value;
304}
305
306static gboolean
307param_enum_validate (GParamSpec *pspec,
308		     GValue     *value)
309{
310  GParamSpecEnum *espec = G_PARAM_SPEC_ENUM (pspec);
311  glong oval = value->data[0].v_long;
312
313  if (!espec->enum_class ||
314      !g_enum_get_value (espec->enum_class, value->data[0].v_long))
315    value->data[0].v_long = espec->default_value;
316
317  return value->data[0].v_long != oval;
318}
319
320static void
321param_spec_flags_init (GParamSpec *pspec)
322{
323  GParamSpecFlags *fspec = G_PARAM_SPEC_FLAGS (pspec);
324
325  fspec->flags_class = NULL;
326  fspec->default_value = 0;
327}
328
329static void
330param_spec_flags_finalize (GParamSpec *pspec)
331{
332  GParamSpecFlags *fspec = G_PARAM_SPEC_FLAGS (pspec);
333  GParamSpecClass *parent_class = g_type_class_peek (g_type_parent (G_TYPE_PARAM_FLAGS));
334
335  if (fspec->flags_class)
336    {
337      g_type_class_unref (fspec->flags_class);
338      fspec->flags_class = NULL;
339    }
340
341  parent_class->finalize (pspec);
342}
343
344static void
345param_flags_set_default (GParamSpec *pspec,
346			 GValue     *value)
347{
348  value->data[0].v_ulong = G_PARAM_SPEC_FLAGS (pspec)->default_value;
349}
350
351static gboolean
352param_flags_validate (GParamSpec *pspec,
353		      GValue     *value)
354{
355  GParamSpecFlags *fspec = G_PARAM_SPEC_FLAGS (pspec);
356  gulong oval = value->data[0].v_ulong;
357
358  if (fspec->flags_class)
359    value->data[0].v_ulong &= fspec->flags_class->mask;
360  else
361    value->data[0].v_ulong = fspec->default_value;
362
363  return value->data[0].v_ulong != oval;
364}
365
366static void
367param_spec_float_init (GParamSpec *pspec)
368{
369  GParamSpecFloat *fspec = G_PARAM_SPEC_FLOAT (pspec);
370
371  fspec->minimum = G_MINFLOAT;
372  fspec->maximum = G_MAXFLOAT;
373  fspec->default_value = 0;
374  fspec->epsilon = G_FLOAT_EPSILON;
375}
376
377static void
378param_float_set_default (GParamSpec *pspec,
379			 GValue     *value)
380{
381  value->data[0].v_float = G_PARAM_SPEC_FLOAT (pspec)->default_value;
382}
383
384static gboolean
385param_float_validate (GParamSpec *pspec,
386		      GValue     *value)
387{
388  GParamSpecFloat *fspec = G_PARAM_SPEC_FLOAT (pspec);
389  gfloat oval = value->data[0].v_float;
390
391  value->data[0].v_float = CLAMP (value->data[0].v_float, fspec->minimum, fspec->maximum);
392
393  return value->data[0].v_float != oval;
394}
395
396static gint
397param_float_values_cmp (GParamSpec   *pspec,
398			const GValue *value1,
399			const GValue *value2)
400{
401  gfloat epsilon = G_PARAM_SPEC_FLOAT (pspec)->epsilon;
402
403  if (value1->data[0].v_float < value2->data[0].v_float)
404    return - (value2->data[0].v_float - value1->data[0].v_float > epsilon);
405  else
406    return value1->data[0].v_float - value2->data[0].v_float > epsilon;
407}
408
409static void
410param_spec_double_init (GParamSpec *pspec)
411{
412  GParamSpecDouble *dspec = G_PARAM_SPEC_DOUBLE (pspec);
413
414  dspec->minimum = G_MINDOUBLE;
415  dspec->maximum = G_MAXDOUBLE;
416  dspec->default_value = 0;
417  dspec->epsilon = G_DOUBLE_EPSILON;
418}
419
420static void
421param_double_set_default (GParamSpec *pspec,
422			  GValue     *value)
423{
424  value->data[0].v_double = G_PARAM_SPEC_DOUBLE (pspec)->default_value;
425}
426
427static gboolean
428param_double_validate (GParamSpec *pspec,
429		       GValue     *value)
430{
431  GParamSpecDouble *dspec = G_PARAM_SPEC_DOUBLE (pspec);
432  gdouble oval = value->data[0].v_double;
433
434  value->data[0].v_double = CLAMP (value->data[0].v_double, dspec->minimum, dspec->maximum);
435
436  return value->data[0].v_double != oval;
437}
438
439static gint
440param_double_values_cmp (GParamSpec   *pspec,
441			 const GValue *value1,
442			 const GValue *value2)
443{
444  gdouble epsilon = G_PARAM_SPEC_DOUBLE (pspec)->epsilon;
445
446  if (value1->data[0].v_double < value2->data[0].v_double)
447    return - (value2->data[0].v_double - value1->data[0].v_double > epsilon);
448  else
449    return value1->data[0].v_double - value2->data[0].v_double > epsilon;
450}
451
452static void
453param_spec_string_init (GParamSpec *pspec)
454{
455  GParamSpecString *sspec = G_PARAM_SPEC_STRING (pspec);
456
457  sspec->default_value = NULL;
458  sspec->cset_first = NULL;
459  sspec->cset_nth = NULL;
460  sspec->substitutor = '_';
461  sspec->null_fold_if_empty = FALSE;
462  sspec->ensure_non_null = FALSE;
463}
464
465static void
466param_spec_string_finalize (GParamSpec *pspec)
467{
468  GParamSpecString *sspec = G_PARAM_SPEC_STRING (pspec);
469  GParamSpecClass *parent_class = g_type_class_peek (g_type_parent (G_TYPE_PARAM_STRING));
470
471  g_free (sspec->default_value);
472  g_free (sspec->cset_first);
473  g_free (sspec->cset_nth);
474  sspec->default_value = NULL;
475  sspec->cset_first = NULL;
476  sspec->cset_nth = NULL;
477
478  parent_class->finalize (pspec);
479}
480
481static void
482param_string_set_default (GParamSpec *pspec,
483			  GValue     *value)
484{
485  value->data[0].v_pointer = g_strdup (G_PARAM_SPEC_STRING (pspec)->default_value);
486}
487
488static gboolean
489param_string_validate (GParamSpec *pspec,
490		       GValue     *value)
491{
492  GParamSpecString *sspec = G_PARAM_SPEC_STRING (pspec);
493  gchar *string = value->data[0].v_pointer;
494  guint changed = 0;
495
496  if (string && string[0])
497    {
498      gchar *s;
499
500      if (sspec->cset_first && !strchr (sspec->cset_first, string[0]))
501	{
502	  string[0] = sspec->substitutor;
503	  changed++;
504	}
505      if (sspec->cset_nth)
506	for (s = string + 1; *s; s++)
507	  if (!strchr (sspec->cset_nth, *s))
508	    {
509	      *s = sspec->substitutor;
510	      changed++;
511	    }
512    }
513  if (sspec->null_fold_if_empty && string && string[0] == 0)
514    {
515      g_free (value->data[0].v_pointer);
516      value->data[0].v_pointer = NULL;
517      changed++;
518      string = value->data[0].v_pointer;
519    }
520  if (sspec->ensure_non_null && !string)
521    {
522      value->data[0].v_pointer = g_strdup ("");
523      changed++;
524      string = value->data[0].v_pointer;
525    }
526
527  return changed;
528}
529
530static gint
531param_string_values_cmp (GParamSpec   *pspec,
532			 const GValue *value1,
533			 const GValue *value2)
534{
535  if (!value1->data[0].v_pointer)
536    return value2->data[0].v_pointer != NULL ? -1 : 0;
537  else if (!value2->data[0].v_pointer)
538    return value1->data[0].v_pointer != NULL;
539  else
540    return strcmp (value1->data[0].v_pointer, value2->data[0].v_pointer);
541}
542
543static void
544param_spec_param_init (GParamSpec *pspec)
545{
546  /* GParamSpecParam *spec = G_PARAM_SPEC_PARAM (pspec); */
547}
548
549static void
550param_param_set_default (GParamSpec *pspec,
551			 GValue     *value)
552{
553  value->data[0].v_pointer = NULL;
554}
555
556static gboolean
557param_param_validate (GParamSpec *pspec,
558		      GValue     *value)
559{
560  /* GParamSpecParam *spec = G_PARAM_SPEC_PARAM (pspec); */
561  GParamSpec *param = value->data[0].v_pointer;
562  guint changed = 0;
563
564  if (param && !g_type_is_a (G_PARAM_SPEC_TYPE (param), G_PARAM_SPEC_VALUE_TYPE (pspec)))
565    {
566      g_param_spec_unref (param);
567      value->data[0].v_pointer = NULL;
568      changed++;
569    }
570
571  return changed;
572}
573
574static void
575param_spec_pointer_init (GParamSpec *pspec)
576{
577  /* GParamSpecPointer *spec = G_PARAM_SPEC_POINTER (pspec); */
578}
579
580static void
581param_pointer_set_default (GParamSpec *pspec,
582			   GValue     *value)
583{
584  value->data[0].v_pointer = NULL;
585}
586
587static gboolean
588param_pointer_validate (GParamSpec *pspec,
589			GValue     *value)
590{
591  /* GParamSpecPointer *spec = G_PARAM_SPEC_POINTER (pspec); */
592  guint changed = 0;
593
594  return changed;
595}
596
597static gint
598param_pointer_values_cmp (GParamSpec   *pspec,
599			  const GValue *value1,
600			  const GValue *value2)
601{
602  return value1->data[0].v_pointer != value2->data[0].v_pointer;
603}
604
605static void
606param_spec_ccallback_init (GParamSpec *pspec)
607{
608  /* GParamSpecCCallback *spec = G_PARAM_SPEC_CCALLBACK (pspec); */
609}
610
611static void
612param_ccallback_set_default (GParamSpec *pspec,
613			     GValue     *value)
614{
615  value->data[0].v_pointer = NULL;
616  value->data[1].v_pointer = NULL;
617}
618
619static gboolean
620param_ccallback_validate (GParamSpec *pspec,
621			  GValue     *value)
622{
623  /* GParamSpecCCallback *spec = G_PARAM_SPEC_CCALLBACK (pspec); */
624  guint changed = 0;
625
626  return changed;
627}
628
629static gint
630param_ccallback_values_cmp (GParamSpec   *pspec,
631			    const GValue *value1,
632			    const GValue *value2)
633{
634  return (value1->data[0].v_pointer != value2->data[0].v_pointer ||
635	  value1->data[1].v_pointer != value2->data[1].v_pointer);
636}
637
638static void
639param_spec_boxed_init (GParamSpec *pspec)
640{
641  /* GParamSpecBoxed *bspec = G_PARAM_SPEC_BOXED (pspec); */
642}
643
644static void
645param_boxed_set_default (GParamSpec *pspec,
646			 GValue     *value)
647{
648  value->data[0].v_pointer = NULL;
649}
650
651static gboolean
652param_boxed_validate (GParamSpec *pspec,
653		      GValue     *value)
654{
655  /* GParamSpecBoxed *bspec = G_PARAM_SPEC_BOXED (pspec); */
656  guint changed = 0;
657
658  /* can't do a whole lot here since we haven't even G_BOXED_TYPE() */
659
660  return changed;
661}
662
663static gint
664param_boxed_values_cmp (GParamSpec    *pspec,
665			 const GValue *value1,
666			 const GValue *value2)
667{
668  return value1->data[0].v_pointer != value2->data[0].v_pointer;
669}
670
671static void
672param_spec_object_init (GParamSpec *pspec)
673{
674  /* GParamSpecObject *ospec = G_PARAM_SPEC_OBJECT (pspec); */
675}
676
677static void
678param_object_set_default (GParamSpec *pspec,
679			  GValue     *value)
680{
681  value->data[0].v_pointer = NULL;
682}
683
684static gboolean
685param_object_validate (GParamSpec *pspec,
686		       GValue     *value)
687{
688  GParamSpecObject *ospec = G_PARAM_SPEC_OBJECT (pspec);
689  GObject *object = value->data[0].v_pointer;
690  guint changed = 0;
691
692  if (object && !g_type_is_a (G_OBJECT_TYPE (object), G_PARAM_SPEC_VALUE_TYPE (ospec)))
693    {
694      g_object_unref (object);
695      value->data[0].v_pointer = NULL;
696      changed++;
697    }
698
699  return changed;
700}
701
702static gint
703param_object_values_cmp (GParamSpec   *pspec,
704			 const GValue *value1,
705			 const GValue *value2)
706{
707  return value1->data[0].v_pointer != value2->data[0].v_pointer;
708}
709
710static void
711value_exch_memcpy (GValue *value1,
712		   GValue *value2)
713{
714  GValue tmp_value;
715  memcpy (&tmp_value.data, &value1->data, sizeof (value1->data));
716  memcpy (&value1->data, &value2->data, sizeof (value1->data));
717  memcpy (&value2->data, &tmp_value.data, sizeof (value2->data));
718}
719
720static void
721value_exch_long_int (GValue *value1,
722		     GValue *value2)
723{
724  glong tmp = value1->data[0].v_long;
725  value1->data[0].v_long = value2->data[0].v_int;
726  value2->data[0].v_int = tmp;
727}
728
729static void
730value_exch_long_uint (GValue *value1,
731		      GValue *value2)
732{
733  glong tmp = value1->data[0].v_long;
734  value1->data[0].v_long = value2->data[0].v_uint;
735  value2->data[0].v_uint = tmp;
736}
737
738static void
739value_exch_ulong_int (GValue *value1,
740		      GValue *value2)
741{
742  gulong tmp = value1->data[0].v_ulong;
743  value1->data[0].v_ulong = value2->data[0].v_int;
744  value2->data[0].v_int = tmp;
745}
746
747static void
748value_exch_ulong_uint (GValue *value1,
749		       GValue *value2)
750{
751  gulong tmp = value1->data[0].v_ulong;
752  value1->data[0].v_ulong = value2->data[0].v_uint;
753  value2->data[0].v_uint = tmp;
754}
755
756static void
757value_exch_float_int (GValue *value1,
758		      GValue *value2)
759{
760  gfloat tmp = value1->data[0].v_float;
761  value1->data[0].v_float = value2->data[0].v_int;
762  value2->data[0].v_int = 0.5 + tmp;
763}
764
765static void
766value_exch_float_uint (GValue *value1,
767		       GValue *value2)
768{
769  gfloat tmp = value1->data[0].v_float;
770  value1->data[0].v_float = value2->data[0].v_uint;
771  value2->data[0].v_uint = 0.5 + tmp;
772}
773
774static void
775value_exch_float_long (GValue *value1,
776		       GValue *value2)
777{
778  gfloat tmp = value1->data[0].v_float;
779  value1->data[0].v_float = value2->data[0].v_long;
780  value2->data[0].v_long = 0.5 + tmp;
781}
782
783static void
784value_exch_float_ulong (GValue *value1,
785			GValue *value2)
786{
787  gfloat tmp = value1->data[0].v_float;
788  value1->data[0].v_float = value2->data[0].v_ulong;
789  value2->data[0].v_ulong = 0.5 + tmp;
790}
791
792static void
793value_exch_double_int (GValue *value1,
794		       GValue *value2)
795{
796  gdouble tmp = value1->data[0].v_double;
797  value1->data[0].v_double = value2->data[0].v_int;
798  value2->data[0].v_int = 0.5 + tmp;
799}
800
801static void
802value_exch_double_uint (GValue *value1,
803			GValue *value2)
804{
805  gdouble tmp = value1->data[0].v_double;
806  value1->data[0].v_double = value2->data[0].v_uint;
807  value2->data[0].v_uint = 0.5 + tmp;
808}
809
810static void
811value_exch_double_long (GValue *value1,
812			GValue *value2)
813{
814  gdouble tmp = value1->data[0].v_double;
815  value1->data[0].v_double = value2->data[0].v_long;
816  value2->data[0].v_long = 0.5 + tmp;
817}
818
819static void
820value_exch_double_ulong (GValue *value1,
821			 GValue *value2)
822{
823  gdouble tmp = value1->data[0].v_double;
824  value1->data[0].v_double = value2->data[0].v_ulong;
825  value2->data[0].v_ulong = 0.5 + tmp;
826}
827
828static void
829value_exch_double_float (GValue *value1,
830			 GValue *value2)
831{
832  gdouble tmp = value1->data[0].v_double;
833  value1->data[0].v_double = value2->data[0].v_float;
834  value2->data[0].v_float = tmp;
835}
836
837
838/* --- type initialization --- */
839void
840g_param_spec_types_init (void)	/* sync with gtype.c */
841{
842  GType type;
843
844  /* G_TYPE_PARAM_CHAR
845   */
846  {
847    static const GParamSpecTypeInfo pspec_info = {
848      sizeof (GParamSpecChar),	/* instance_size */
849      16,			/* n_preallocs */
850      param_spec_char_init,	/* instance_init */
851      G_TYPE_CHAR,		/* value_type */
852      NULL,			/* finalize */
853      param_char_set_default,	/* value_set_default */
854      param_char_validate,	/* value_validate */
855      param_int_values_cmp,	/* values_cmp */
856    };
857    type = g_param_type_register_static ("GParamChar", &pspec_info);
858    g_assert (type == G_TYPE_PARAM_CHAR);
859  }
860
861  /* G_TYPE_PARAM_UCHAR
862   */
863  {
864    static const GParamSpecTypeInfo pspec_info = {
865      sizeof (GParamSpecUChar), /* instance_size */
866      16,                       /* n_preallocs */
867      param_spec_uchar_init,    /* instance_init */
868      G_TYPE_UCHAR,		/* value_type */
869      NULL,			/* finalize */
870      param_uchar_set_default,	/* value_set_default */
871      param_uchar_validate,	/* value_validate */
872      param_uint_values_cmp,	/* values_cmp */
873    };
874    type = g_param_type_register_static ("GParamUChar", &pspec_info);
875    g_assert (type == G_TYPE_PARAM_UCHAR);
876  }
877
878  /* G_TYPE_PARAM_BOOLEAN
879   */
880  {
881    static const GParamSpecTypeInfo pspec_info = {
882      sizeof (GParamSpecBoolean), /* instance_size */
883      16,                         /* n_preallocs */
884      NULL,			  /* instance_init */
885      G_TYPE_BOOLEAN,             /* value_type */
886      NULL,                       /* finalize */
887      param_boolean_set_default,  /* value_set_default */
888      param_boolean_validate,     /* value_validate */
889      param_int_values_cmp,       /* values_cmp */
890    };
891    type = g_param_type_register_static ("GParamBoolean", &pspec_info);
892    g_assert (type == G_TYPE_PARAM_BOOLEAN);
893  }
894
895  /* G_TYPE_PARAM_INT
896   */
897  {
898    static const GParamSpecTypeInfo pspec_info = {
899      sizeof (GParamSpecInt),   /* instance_size */
900      16,                       /* n_preallocs */
901      param_spec_int_init,      /* instance_init */
902      G_TYPE_INT,		/* value_type */
903      NULL,			/* finalize */
904      param_int_set_default,	/* value_set_default */
905      param_int_validate,	/* value_validate */
906      param_int_values_cmp,	/* values_cmp */
907    };
908    type = g_param_type_register_static ("GParamInt", &pspec_info);
909    g_assert (type == G_TYPE_PARAM_INT);
910  }
911
912  /* G_TYPE_PARAM_UINT
913   */
914  {
915    static const GParamSpecTypeInfo pspec_info = {
916      sizeof (GParamSpecUInt),  /* instance_size */
917      16,                       /* n_preallocs */
918      param_spec_uint_init,     /* instance_init */
919      G_TYPE_UINT,		/* value_type */
920      NULL,			/* finalize */
921      param_uint_set_default,	/* value_set_default */
922      param_uint_validate,	/* value_validate */
923      param_uint_values_cmp,	/* values_cmp */
924    };
925    type = g_param_type_register_static ("GParamUInt", &pspec_info);
926    g_assert (type == G_TYPE_PARAM_UINT);
927  }
928
929  /* G_TYPE_PARAM_LONG
930   */
931  {
932    static const GParamSpecTypeInfo pspec_info = {
933      sizeof (GParamSpecLong),  /* instance_size */
934      16,                       /* n_preallocs */
935      param_spec_long_init,     /* instance_init */
936      G_TYPE_LONG,		/* value_type */
937      NULL,			/* finalize */
938      param_long_set_default,	/* value_set_default */
939      param_long_validate,	/* value_validate */
940      param_long_values_cmp,	/* values_cmp */
941    };
942    type = g_param_type_register_static ("GParamLong", &pspec_info);
943    g_assert (type == G_TYPE_PARAM_LONG);
944  }
945
946  /* G_TYPE_PARAM_ULONG
947   */
948  {
949    static const GParamSpecTypeInfo pspec_info = {
950      sizeof (GParamSpecULong), /* instance_size */
951      16,                       /* n_preallocs */
952      param_spec_ulong_init,    /* instance_init */
953      G_TYPE_ULONG,		/* value_type */
954      NULL,			/* finalize */
955      param_ulong_set_default,	/* value_set_default */
956      param_ulong_validate,	/* value_validate */
957      param_ulong_values_cmp,	/* values_cmp */
958    };
959    type = g_param_type_register_static ("GParamULong", &pspec_info);
960    g_assert (type == G_TYPE_PARAM_ULONG);
961  }
962
963  /* G_TYPE_PARAM_ENUM
964   */
965  {
966    static const GParamSpecTypeInfo pspec_info = {
967      sizeof (GParamSpecEnum),  /* instance_size */
968      16,                       /* n_preallocs */
969      param_spec_enum_init,     /* instance_init */
970      G_TYPE_ENUM,		/* value_type */
971      param_spec_enum_finalize,	/* finalize */
972      param_enum_set_default,	/* value_set_default */
973      param_enum_validate,	/* value_validate */
974      param_long_values_cmp,	/* values_cmp */
975    };
976    type = g_param_type_register_static ("GParamEnum", &pspec_info);
977    g_assert (type == G_TYPE_PARAM_ENUM);
978  }
979
980  /* G_TYPE_PARAM_FLAGS
981   */
982  {
983    static const GParamSpecTypeInfo pspec_info = {
984      sizeof (GParamSpecFlags), /* instance_size */
985      16,                       /* n_preallocs */
986      param_spec_flags_init,    /* instance_init */
987      G_TYPE_FLAGS,		/* value_type */
988      param_spec_flags_finalize,/* finalize */
989      param_flags_set_default,	/* value_set_default */
990      param_flags_validate,	/* value_validate */
991      param_ulong_values_cmp,	/* values_cmp */
992    };
993    type = g_param_type_register_static ("GParamFlags", &pspec_info);
994    g_assert (type == G_TYPE_PARAM_FLAGS);
995  }
996
997  /* G_TYPE_PARAM_FLOAT
998   */
999  {
1000    static const GParamSpecTypeInfo pspec_info = {
1001      sizeof (GParamSpecFloat), /* instance_size */
1002      16,                       /* n_preallocs */
1003      param_spec_float_init,    /* instance_init */
1004      G_TYPE_FLOAT,		/* value_type */
1005      NULL,			/* finalize */
1006      param_float_set_default,	/* value_set_default */
1007      param_float_validate,	/* value_validate */
1008      param_float_values_cmp,	/* values_cmp */
1009    };
1010    type = g_param_type_register_static ("GParamFloat", &pspec_info);
1011    g_assert (type == G_TYPE_PARAM_FLOAT);
1012  }
1013
1014  /* G_TYPE_PARAM_DOUBLE
1015   */
1016  {
1017    static const GParamSpecTypeInfo pspec_info = {
1018      sizeof (GParamSpecDouble), /* instance_size */
1019      16,                        /* n_preallocs */
1020      param_spec_double_init,    /* instance_init */
1021      G_TYPE_DOUBLE,		 /* value_type */
1022      NULL,			 /* finalize */
1023      param_double_set_default,	 /* value_set_default */
1024      param_double_validate,	 /* value_validate */
1025      param_double_values_cmp,	 /* values_cmp */
1026    };
1027    type = g_param_type_register_static ("GParamDouble", &pspec_info);
1028    g_assert (type == G_TYPE_PARAM_DOUBLE);
1029  }
1030
1031  /* G_TYPE_PARAM_STRING
1032   */
1033  {
1034    static const GParamSpecTypeInfo pspec_info = {
1035      sizeof (GParamSpecString),  /* instance_size */
1036      16,			  /* n_preallocs */
1037      param_spec_string_init,	  /* instance_init */
1038      G_TYPE_STRING,		  /* value_type */
1039      param_spec_string_finalize, /* finalize */
1040      param_string_set_default,	  /* value_set_default */
1041      param_string_validate,	  /* value_validate */
1042      param_string_values_cmp,	  /* values_cmp */
1043    };
1044    type = g_param_type_register_static ("GParamString", &pspec_info);
1045    g_assert (type == G_TYPE_PARAM_STRING);
1046  }
1047
1048  /* G_TYPE_PARAM_PARAM
1049   */
1050  {
1051    static const GParamSpecTypeInfo pspec_info = {
1052      sizeof (GParamSpecParam),  /* instance_size */
1053      16,                        /* n_preallocs */
1054      param_spec_param_init,     /* instance_init */
1055      G_TYPE_PARAM,		 /* value_type */
1056      NULL,			 /* finalize */
1057      param_param_set_default,	 /* value_set_default */
1058      param_param_validate,	 /* value_validate */
1059      param_pointer_values_cmp,	 /* values_cmp */
1060    };
1061    type = g_param_type_register_static ("GParamParam", &pspec_info);
1062    g_assert (type == G_TYPE_PARAM_PARAM);
1063  }
1064
1065  /* G_TYPE_PARAM_POINTER
1066   */
1067  {
1068    static const GParamSpecTypeInfo pspec_info = {
1069      sizeof (GParamSpecPointer),  /* instance_size */
1070      0,                           /* n_preallocs */
1071      param_spec_pointer_init,     /* instance_init */
1072      G_TYPE_POINTER,  		   /* value_type */
1073      NULL,			   /* finalize */
1074      param_pointer_set_default,   /* value_set_default */
1075      param_pointer_validate,	   /* value_validate */
1076      param_pointer_values_cmp,	   /* values_cmp */
1077    };
1078    type = g_param_type_register_static ("GParamPointer", &pspec_info);
1079    g_assert (type == G_TYPE_PARAM_POINTER);
1080  }
1081
1082  /* G_TYPE_PARAM_CCALLBACK
1083   */
1084  {
1085    static const GParamSpecTypeInfo pspec_info = {
1086      sizeof (GParamSpecCCallback), /* instance_size */
1087      0,                            /* n_preallocs */
1088      param_spec_ccallback_init,    /* instance_init */
1089      G_TYPE_CCALLBACK,		    /* value_type */
1090      NULL,			    /* finalize */
1091      param_ccallback_set_default,  /* value_set_default */
1092      param_ccallback_validate,	    /* value_validate */
1093      param_ccallback_values_cmp,   /* values_cmp */
1094    };
1095    type = g_param_type_register_static ("GParamCCallback", &pspec_info);
1096    g_assert (type == G_TYPE_PARAM_CCALLBACK);
1097  }
1098
1099  /* G_TYPE_PARAM_BOXED
1100   */
1101  {
1102    static const GParamSpecTypeInfo pspec_info = {
1103      sizeof (GParamSpecBoxed),  /* instance_size */
1104      4,                         /* n_preallocs */
1105      param_spec_boxed_init,     /* instance_init */
1106      G_TYPE_BOXED,		 /* value_type */
1107      NULL,			 /* finalize */
1108      param_boxed_set_default,	 /* value_set_default */
1109      param_boxed_validate,	 /* value_validate */
1110      param_boxed_values_cmp,	 /* values_cmp */
1111    };
1112    type = g_param_type_register_static ("GParamBoxed", &pspec_info);
1113    g_assert (type == G_TYPE_PARAM_BOXED);
1114  }
1115
1116  /* G_TYPE_PARAM_OBJECT
1117   */
1118  {
1119    static const GParamSpecTypeInfo pspec_info = {
1120      sizeof (GParamSpecObject), /* instance_size */
1121      16,                        /* n_preallocs */
1122      param_spec_object_init,    /* instance_init */
1123      G_TYPE_OBJECT,		 /* value_type */
1124      NULL,			 /* finalize */
1125      param_object_set_default,	 /* value_set_default */
1126      param_object_validate,	 /* value_validate */
1127      param_object_values_cmp,	 /* values_cmp */
1128    };
1129    type = g_param_type_register_static ("GParamObject", &pspec_info);
1130    g_assert (type == G_TYPE_PARAM_OBJECT);
1131  }
1132
1133  g_value_register_exchange_func (G_TYPE_CHAR,    G_TYPE_UCHAR,   value_exch_memcpy);
1134  g_value_register_exchange_func (G_TYPE_CHAR,    G_TYPE_BOOLEAN, value_exch_memcpy);
1135  g_value_register_exchange_func (G_TYPE_CHAR,    G_TYPE_INT,     value_exch_memcpy);
1136  g_value_register_exchange_func (G_TYPE_CHAR,    G_TYPE_UINT,    value_exch_memcpy);
1137  g_value_register_exchange_func (G_TYPE_CHAR,    G_TYPE_ENUM,    value_exch_memcpy);
1138  g_value_register_exchange_func (G_TYPE_CHAR,    G_TYPE_FLAGS,   value_exch_memcpy);
1139  g_value_register_exchange_func (G_TYPE_UCHAR,   G_TYPE_BOOLEAN, value_exch_memcpy);
1140  g_value_register_exchange_func (G_TYPE_UCHAR,   G_TYPE_INT,     value_exch_memcpy);
1141  g_value_register_exchange_func (G_TYPE_UCHAR,   G_TYPE_UINT,    value_exch_memcpy);
1142  g_value_register_exchange_func (G_TYPE_UCHAR,   G_TYPE_ENUM,    value_exch_memcpy);
1143  g_value_register_exchange_func (G_TYPE_UCHAR,   G_TYPE_FLAGS,   value_exch_memcpy);
1144  g_value_register_exchange_func (G_TYPE_BOOLEAN, G_TYPE_INT,     value_exch_memcpy);
1145  g_value_register_exchange_func (G_TYPE_BOOLEAN, G_TYPE_UINT,    value_exch_memcpy);
1146  g_value_register_exchange_func (G_TYPE_BOOLEAN, G_TYPE_ENUM,    value_exch_memcpy);
1147  g_value_register_exchange_func (G_TYPE_BOOLEAN, G_TYPE_FLAGS,   value_exch_memcpy);
1148  g_value_register_exchange_func (G_TYPE_INT,     G_TYPE_UINT,    value_exch_memcpy);
1149  g_value_register_exchange_func (G_TYPE_INT,     G_TYPE_ENUM,    value_exch_memcpy);
1150  g_value_register_exchange_func (G_TYPE_INT,     G_TYPE_FLAGS,   value_exch_memcpy);
1151  g_value_register_exchange_func (G_TYPE_UINT,    G_TYPE_ENUM,    value_exch_memcpy);
1152  g_value_register_exchange_func (G_TYPE_UINT,    G_TYPE_FLAGS,   value_exch_memcpy);
1153  g_value_register_exchange_func (G_TYPE_LONG,    G_TYPE_CHAR,    value_exch_long_int);
1154  g_value_register_exchange_func (G_TYPE_LONG,    G_TYPE_UCHAR,   value_exch_long_uint);
1155  g_value_register_exchange_func (G_TYPE_LONG,    G_TYPE_BOOLEAN, value_exch_long_int);
1156  g_value_register_exchange_func (G_TYPE_LONG,    G_TYPE_INT,     value_exch_long_int);
1157  g_value_register_exchange_func (G_TYPE_LONG,    G_TYPE_UINT,    value_exch_long_uint);
1158  g_value_register_exchange_func (G_TYPE_LONG,    G_TYPE_ULONG,   value_exch_memcpy);
1159  g_value_register_exchange_func (G_TYPE_LONG,    G_TYPE_ENUM,    value_exch_long_int);
1160  g_value_register_exchange_func (G_TYPE_LONG,    G_TYPE_FLAGS,   value_exch_long_uint);
1161  g_value_register_exchange_func (G_TYPE_ULONG,   G_TYPE_CHAR,    value_exch_ulong_int);
1162  g_value_register_exchange_func (G_TYPE_ULONG,   G_TYPE_UCHAR,   value_exch_ulong_uint);
1163  g_value_register_exchange_func (G_TYPE_ULONG,   G_TYPE_BOOLEAN, value_exch_ulong_int);
1164  g_value_register_exchange_func (G_TYPE_ULONG,   G_TYPE_INT,     value_exch_ulong_int);
1165  g_value_register_exchange_func (G_TYPE_ULONG,   G_TYPE_UINT,    value_exch_ulong_uint);
1166  g_value_register_exchange_func (G_TYPE_ULONG,   G_TYPE_ENUM,    value_exch_ulong_int);
1167  g_value_register_exchange_func (G_TYPE_ULONG,   G_TYPE_FLAGS,   value_exch_ulong_uint);
1168  g_value_register_exchange_func (G_TYPE_ENUM,    G_TYPE_FLAGS,   value_exch_memcpy);
1169  g_value_register_exchange_func (G_TYPE_FLOAT,   G_TYPE_CHAR,    value_exch_float_int);
1170  g_value_register_exchange_func (G_TYPE_FLOAT,   G_TYPE_UCHAR,   value_exch_float_uint);
1171  g_value_register_exchange_func (G_TYPE_FLOAT,   G_TYPE_BOOLEAN, value_exch_float_int);
1172  g_value_register_exchange_func (G_TYPE_FLOAT,   G_TYPE_INT,     value_exch_float_int);
1173  g_value_register_exchange_func (G_TYPE_FLOAT,   G_TYPE_UINT,    value_exch_float_uint);
1174  g_value_register_exchange_func (G_TYPE_FLOAT,   G_TYPE_LONG,    value_exch_float_long);
1175  g_value_register_exchange_func (G_TYPE_FLOAT,   G_TYPE_ULONG,   value_exch_float_ulong);
1176  g_value_register_exchange_func (G_TYPE_FLOAT,   G_TYPE_ENUM,    value_exch_float_int);
1177  g_value_register_exchange_func (G_TYPE_FLOAT,   G_TYPE_FLAGS,   value_exch_float_uint);
1178  g_value_register_exchange_func (G_TYPE_DOUBLE,  G_TYPE_CHAR,    value_exch_double_int);
1179  g_value_register_exchange_func (G_TYPE_DOUBLE,  G_TYPE_UCHAR,   value_exch_double_uint);
1180  g_value_register_exchange_func (G_TYPE_DOUBLE,  G_TYPE_BOOLEAN, value_exch_double_int);
1181  g_value_register_exchange_func (G_TYPE_DOUBLE,  G_TYPE_INT,     value_exch_double_int);
1182  g_value_register_exchange_func (G_TYPE_DOUBLE,  G_TYPE_UINT,    value_exch_double_uint);
1183  g_value_register_exchange_func (G_TYPE_DOUBLE,  G_TYPE_LONG,    value_exch_double_long);
1184  g_value_register_exchange_func (G_TYPE_DOUBLE,  G_TYPE_ULONG,   value_exch_double_ulong);
1185  g_value_register_exchange_func (G_TYPE_DOUBLE,  G_TYPE_ENUM,    value_exch_double_int);
1186  g_value_register_exchange_func (G_TYPE_DOUBLE,  G_TYPE_FLAGS,   value_exch_double_uint);
1187  g_value_register_exchange_func (G_TYPE_DOUBLE,  G_TYPE_FLOAT,   value_exch_double_float);
1188}
1189
1190
1191/* --- GParamSpec initialization --- */
1192GParamSpec*
1193g_param_spec_char (const gchar *name,
1194		   const gchar *nick,
1195		   const gchar *blurb,
1196		   gint8	minimum,
1197		   gint8	maximum,
1198		   gint8	default_value,
1199		   GParamFlags	flags)
1200{
1201  GParamSpecChar *cspec = g_param_spec_internal (G_TYPE_PARAM_CHAR,
1202						 name,
1203						 nick,
1204						 blurb,
1205						 flags);
1206
1207  cspec->minimum = minimum;
1208  cspec->maximum = maximum;
1209  cspec->default_value = default_value;
1210
1211  return G_PARAM_SPEC (cspec);
1212}
1213
1214GParamSpec*
1215g_param_spec_uchar (const gchar *name,
1216		    const gchar *nick,
1217		    const gchar *blurb,
1218		    guint8	 minimum,
1219		    guint8	 maximum,
1220		    guint8	 default_value,
1221		    GParamFlags	 flags)
1222{
1223  GParamSpecUChar *uspec = g_param_spec_internal (G_TYPE_PARAM_UCHAR,
1224						  name,
1225						  nick,
1226						  blurb,
1227						  flags);
1228
1229  uspec->minimum = minimum;
1230  uspec->maximum = maximum;
1231  uspec->default_value = default_value;
1232
1233  return G_PARAM_SPEC (uspec);
1234}
1235
1236GParamSpec*
1237g_param_spec_boolean (const gchar *name,
1238		      const gchar *nick,
1239		      const gchar *blurb,
1240		      gboolean	   default_value,
1241		      GParamFlags  flags)
1242{
1243  GParamSpecBoolean *bspec = g_param_spec_internal (G_TYPE_PARAM_BOOLEAN,
1244						    name,
1245						    nick,
1246						    blurb,
1247						    flags);
1248
1249  bspec->default_value = default_value;
1250
1251  return G_PARAM_SPEC (bspec);
1252}
1253
1254GParamSpec*
1255g_param_spec_int (const gchar *name,
1256		  const gchar *nick,
1257		  const gchar *blurb,
1258		  gint	       minimum,
1259		  gint	       maximum,
1260		  gint	       default_value,
1261		  GParamFlags  flags)
1262{
1263  GParamSpecInt *ispec = g_param_spec_internal (G_TYPE_PARAM_INT,
1264						name,
1265						nick,
1266						blurb,
1267						flags);
1268
1269  ispec->minimum = minimum;
1270  ispec->maximum = maximum;
1271  ispec->default_value = default_value;
1272
1273  return G_PARAM_SPEC (ispec);
1274}
1275
1276GParamSpec*
1277g_param_spec_uint (const gchar *name,
1278		   const gchar *nick,
1279		   const gchar *blurb,
1280		   guint	minimum,
1281		   guint	maximum,
1282		   guint	default_value,
1283		   GParamFlags	flags)
1284{
1285  GParamSpecUInt *uspec = g_param_spec_internal (G_TYPE_PARAM_UINT,
1286						 name,
1287						 nick,
1288						 blurb,
1289						 flags);
1290
1291  uspec->minimum = minimum;
1292  uspec->maximum = maximum;
1293  uspec->default_value = default_value;
1294
1295  return G_PARAM_SPEC (uspec);
1296}
1297
1298GParamSpec*
1299g_param_spec_long (const gchar *name,
1300		   const gchar *nick,
1301		   const gchar *blurb,
1302		   glong	minimum,
1303		   glong	maximum,
1304		   glong	default_value,
1305		   GParamFlags	flags)
1306{
1307  GParamSpecLong *lspec = g_param_spec_internal (G_TYPE_PARAM_LONG,
1308						 name,
1309						 nick,
1310						 blurb,
1311						 flags);
1312
1313  lspec->minimum = minimum;
1314  lspec->maximum = maximum;
1315  lspec->default_value = default_value;
1316
1317  return G_PARAM_SPEC (lspec);
1318}
1319
1320GParamSpec*
1321g_param_spec_ulong (const gchar *name,
1322		    const gchar *nick,
1323		    const gchar *blurb,
1324		    gulong	 minimum,
1325		    gulong	 maximum,
1326		    gulong	 default_value,
1327		    GParamFlags	 flags)
1328{
1329  GParamSpecULong *uspec = g_param_spec_internal (G_TYPE_PARAM_ULONG,
1330						  name,
1331						  nick,
1332						  blurb,
1333						  flags);
1334
1335  uspec->minimum = minimum;
1336  uspec->maximum = maximum;
1337  uspec->default_value = default_value;
1338
1339  return G_PARAM_SPEC (uspec);
1340}
1341
1342GParamSpec*
1343g_param_spec_enum (const gchar *name,
1344		   const gchar *nick,
1345		   const gchar *blurb,
1346		   GType	enum_type,
1347		   gint		default_value,
1348		   GParamFlags	flags)
1349{
1350  GParamSpecEnum *espec;
1351
1352  g_return_val_if_fail (G_TYPE_IS_ENUM (enum_type), NULL);
1353
1354  espec = g_param_spec_internal (G_TYPE_PARAM_ENUM,
1355				 name,
1356				 nick,
1357				 blurb,
1358				 flags);
1359
1360  espec->enum_class = g_type_class_ref (enum_type);
1361  espec->default_value = default_value;
1362
1363  return G_PARAM_SPEC (espec);
1364}
1365
1366GParamSpec*
1367g_param_spec_flags (const gchar *name,
1368		    const gchar *nick,
1369		    const gchar *blurb,
1370		    GType	 flags_type,
1371		    guint	 default_value,
1372		    GParamFlags	 flags)
1373{
1374  GParamSpecFlags *fspec;
1375
1376  g_return_val_if_fail (G_TYPE_IS_FLAGS (flags_type), NULL);
1377
1378  fspec = g_param_spec_internal (G_TYPE_PARAM_FLAGS,
1379				 name,
1380				 nick,
1381				 blurb,
1382				 flags);
1383
1384  fspec->flags_class = g_type_class_ref (flags_type);
1385  fspec->default_value = default_value;
1386
1387  return G_PARAM_SPEC (fspec);
1388}
1389
1390GParamSpec*
1391g_param_spec_float (const gchar *name,
1392		    const gchar *nick,
1393		    const gchar *blurb,
1394		    gfloat	 minimum,
1395		    gfloat	 maximum,
1396		    gfloat	 default_value,
1397		    GParamFlags	 flags)
1398{
1399  GParamSpecFloat *fspec = g_param_spec_internal (G_TYPE_PARAM_FLOAT,
1400						  name,
1401						  nick,
1402						  blurb,
1403						  flags);
1404
1405  fspec->minimum = minimum;
1406  fspec->maximum = maximum;
1407  fspec->default_value = default_value;
1408
1409  return G_PARAM_SPEC (fspec);
1410}
1411
1412GParamSpec*
1413g_param_spec_double (const gchar *name,
1414		     const gchar *nick,
1415		     const gchar *blurb,
1416		     gdouble	  minimum,
1417		     gdouble	  maximum,
1418		     gdouble	  default_value,
1419		     GParamFlags  flags)
1420{
1421  GParamSpecDouble *dspec = g_param_spec_internal (G_TYPE_PARAM_DOUBLE,
1422						   name,
1423						   nick,
1424						   blurb,
1425						   flags);
1426
1427  dspec->minimum = minimum;
1428  dspec->maximum = maximum;
1429  dspec->default_value = default_value;
1430
1431  return G_PARAM_SPEC (dspec);
1432}
1433
1434GParamSpec*
1435g_param_spec_string (const gchar *name,
1436		     const gchar *nick,
1437		     const gchar *blurb,
1438		     const gchar *default_value,
1439		     GParamFlags  flags)
1440{
1441  GParamSpecString *sspec = g_param_spec_internal (G_TYPE_PARAM_STRING,
1442						   name,
1443						   nick,
1444						   blurb,
1445						   flags);
1446  g_free (sspec->default_value);
1447  sspec->default_value = g_strdup (default_value);
1448
1449  return G_PARAM_SPEC (sspec);
1450}
1451
1452GParamSpec*
1453g_param_spec_string_c (const gchar *name,
1454		       const gchar *nick,
1455		       const gchar *blurb,
1456		       const gchar *default_value,
1457		       GParamFlags  flags)
1458{
1459  GParamSpecString *sspec = g_param_spec_internal (G_TYPE_PARAM_STRING,
1460						   name,
1461						   nick,
1462						   blurb,
1463						   flags);
1464  g_free (sspec->default_value);
1465  sspec->default_value = g_strdup (default_value);
1466  g_free (sspec->cset_first);
1467  sspec->cset_first = g_strdup (G_CSET_a_2_z "_" G_CSET_A_2_Z);
1468  g_free (sspec->cset_nth);
1469  sspec->cset_nth = g_strdup (G_CSET_a_2_z
1470			      "_0123456789"
1471			      /* G_CSET_LATINS G_CSET_LATINC */
1472			      G_CSET_A_2_Z);
1473
1474  return G_PARAM_SPEC (sspec);
1475}
1476
1477GParamSpec*
1478g_param_spec_param (const gchar *name,
1479		    const gchar *nick,
1480		    const gchar *blurb,
1481		    GType	 param_type,
1482		    GParamFlags  flags)
1483{
1484  GParamSpecParam *pspec;
1485
1486  g_return_val_if_fail (G_TYPE_IS_PARAM (param_type), NULL);
1487
1488  pspec = g_param_spec_internal (G_TYPE_PARAM_PARAM,
1489				 name,
1490				 nick,
1491				 blurb,
1492				 flags);
1493  G_PARAM_SPEC (pspec)->value_type = param_type;
1494
1495  return G_PARAM_SPEC (pspec);
1496}
1497
1498GParamSpec*
1499g_param_spec_pointer (const gchar *name,
1500		      const gchar *nick,
1501		      const gchar *blurb,
1502		      GParamFlags  flags)
1503{
1504  GParamSpecPointer *pspec;
1505
1506  pspec = g_param_spec_internal (G_TYPE_PARAM_POINTER,
1507				 name,
1508				 nick,
1509				 blurb,
1510				 flags);
1511  return G_PARAM_SPEC (pspec);
1512}
1513
1514GParamSpec*
1515g_param_spec_ccallback (const gchar *name,
1516			const gchar *nick,
1517			const gchar *blurb,
1518			GParamFlags  flags)
1519{
1520  GParamSpecCCallback *cspec;
1521
1522  cspec = g_param_spec_internal (G_TYPE_PARAM_CCALLBACK,
1523				 name,
1524				 nick,
1525				 blurb,
1526				 flags);
1527  return G_PARAM_SPEC (cspec);
1528}
1529
1530GParamSpec*
1531g_param_spec_boxed (const gchar *name,
1532		    const gchar *nick,
1533		    const gchar *blurb,
1534		    GType	 boxed_type,
1535		    GParamFlags  flags)
1536{
1537  GParamSpecBoxed *bspec;
1538
1539  g_return_val_if_fail (G_TYPE_IS_BOXED (boxed_type), NULL);
1540  g_return_val_if_fail (G_TYPE_IS_DERIVED (boxed_type), NULL);
1541
1542  bspec = g_param_spec_internal (G_TYPE_PARAM_BOXED,
1543				 name,
1544				 nick,
1545				 blurb,
1546				 flags);
1547  G_PARAM_SPEC (bspec)->value_type = boxed_type;
1548
1549  return G_PARAM_SPEC (bspec);
1550}
1551
1552GParamSpec*
1553g_param_spec_object (const gchar *name,
1554		     const gchar *nick,
1555		     const gchar *blurb,
1556		     GType	  object_type,
1557		     GParamFlags  flags)
1558{
1559  GParamSpecObject *ospec;
1560
1561  g_return_val_if_fail (G_TYPE_IS_OBJECT (object_type), NULL);
1562
1563  ospec = g_param_spec_internal (G_TYPE_PARAM_OBJECT,
1564				 name,
1565				 nick,
1566				 blurb,
1567				 flags);
1568  G_PARAM_SPEC (ospec)->value_type = object_type;
1569
1570  return G_PARAM_SPEC (ospec);
1571}
1572