?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
gconvert: add note to avoid transliteration
[glib.git] / gobject / gparamspecs.c
blobc48ae0c4b5d1ae98a27cda8bc4fdb7c115630254
1 /* GObject - GLib Type, Object, Parameter and Signal Library
2 * Copyright (C) 1997-1999, 2000-2001 Tim Janik and Red Hat, Inc.
3 * Copyright (C) 2010 Christian Persch
4 *
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2 of the License, or (at your option) any later version.
9 *
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
14 *
15 * You should have received a copy of the GNU Lesser General
16 * Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
17 */
18
19 /*
20 * MT safe
21 */
22
23 #include "config.h"
24
25 #include <string.h>
26
27 #define GLIB_DISABLE_DEPRECATION_WARNINGS
28
29 #include "gparamspecs.h"
30 #include "gtype-private.h"
31 #include "gvaluecollector.h"
32
33 #include "gvaluearray.h"
34
35
36 /**
37 * SECTION:param_value_types
38 * @short_description: Standard Parameter and Value Types
39 * @see_also: #GParamSpec, #GValue, g_object_class_install_property().
40 * @title: Parameters and Values
41 *
42 * #GValue provides an abstract container structure which can be
43 * copied, transformed and compared while holding a value of any
44 * (derived) type, which is registered as a #GType with a
45 * #GTypeValueTable in its #GTypeInfo structure. Parameter
46 * specifications for most value types can be created as #GParamSpec
47 * derived instances, to implement e.g. #GObject properties which
48 * operate on #GValue containers.
49 *
50 * Parameter names need to start with a letter (a-z or A-Z). Subsequent
51 * characters can be letters, numbers or a '-'.
52 * All other characters are replaced by a '-' during construction.
53 */
54
55
56 #define G_FLOAT_EPSILON (1e-30)
57 #define G_DOUBLE_EPSILON (1e-90)
58
59
60 /* --- param spec functions --- */
61 static void
62 param_char_init (GParamSpec *pspec)
63 {
64 GParamSpecChar *cspec = G_PARAM_SPEC_CHAR (pspec);
65
66 cspec->minimum = 0x7f;
67 cspec->maximum = 0x80;
68 cspec->default_value = 0;
69 }
70
71 static void
72 param_char_set_default (GParamSpec *pspec,
73 GValue *value)
74 {
75 value->data[0].v_int = G_PARAM_SPEC_CHAR (pspec)->default_value;
76 }
77
78 static gboolean
79 param_char_validate (GParamSpec *pspec,
80 GValue *value)
81 {
82 GParamSpecChar *cspec = G_PARAM_SPEC_CHAR (pspec);
83 gint oval = value->data[0].v_int;
84
85 value->data[0].v_int = CLAMP (value->data[0].v_int, cspec->minimum, cspec->maximum);
86
87 return value->data[0].v_int != oval;
88 }
89
90 static void
91 param_uchar_init (GParamSpec *pspec)
92 {
93 GParamSpecUChar *uspec = G_PARAM_SPEC_UCHAR (pspec);
94
95 uspec->minimum = 0;
96 uspec->maximum = 0xff;
97 uspec->default_value = 0;
98 }
99
100 static void
101 param_uchar_set_default (GParamSpec *pspec,
102 GValue *value)
103 {
104 value->data[0].v_uint = G_PARAM_SPEC_UCHAR (pspec)->default_value;
105 }
106
107 static gboolean
108 param_uchar_validate (GParamSpec *pspec,
109 GValue *value)
110 {
111 GParamSpecUChar *uspec = G_PARAM_SPEC_UCHAR (pspec);
112 guint oval = value->data[0].v_uint;
113
114 value->data[0].v_uint = CLAMP (value->data[0].v_uint, uspec->minimum, uspec->maximum);
115
116 return value->data[0].v_uint != oval;
117 }
118
119 static void
120 param_boolean_set_default (GParamSpec *pspec,
121 GValue *value)
122 {
123 value->data[0].v_int = G_PARAM_SPEC_BOOLEAN (pspec)->default_value;
124 }
125
126 static gboolean
127 param_boolean_validate (GParamSpec *pspec,
128 GValue *value)
129 {
130 gint oval = value->data[0].v_int;
131
132 value->data[0].v_int = value->data[0].v_int != FALSE;
133
134 return value->data[0].v_int != oval;
135 }
136
137 static void
138 param_int_init (GParamSpec *pspec)
139 {
140 GParamSpecInt *ispec = G_PARAM_SPEC_INT (pspec);
141
142 ispec->minimum = 0x7fffffff;
143 ispec->maximum = 0x80000000;
144 ispec->default_value = 0;
145 }
146
147 static void
148 param_int_set_default (GParamSpec *pspec,
149 GValue *value)
150 {
151 value->data[0].v_int = G_PARAM_SPEC_INT (pspec)->default_value;
152 }
153
154 static gboolean
155 param_int_validate (GParamSpec *pspec,
156 GValue *value)
157 {
158 GParamSpecInt *ispec = G_PARAM_SPEC_INT (pspec);
159 gint oval = value->data[0].v_int;
160
161 value->data[0].v_int = CLAMP (value->data[0].v_int, ispec->minimum, ispec->maximum);
162
163 return value->data[0].v_int != oval;
164 }
165
166 static gint
167 param_int_values_cmp (GParamSpec *pspec,
168 const GValue *value1,
169 const GValue *value2)
170 {
171 if (value1->data[0].v_int < value2->data[0].v_int)
172 return -1;
173 else
174 return value1->data[0].v_int > value2->data[0].v_int;
175 }
176
177 static void
178 param_uint_init (GParamSpec *pspec)
179 {
180 GParamSpecUInt *uspec = G_PARAM_SPEC_UINT (pspec);
181
182 uspec->minimum = 0;
183 uspec->maximum = 0xffffffff;
184 uspec->default_value = 0;
185 }
186
187 static void
188 param_uint_set_default (GParamSpec *pspec,
189 GValue *value)
190 {
191 value->data[0].v_uint = G_PARAM_SPEC_UINT (pspec)->default_value;
192 }
193
194 static gboolean
195 param_uint_validate (GParamSpec *pspec,
196 GValue *value)
197 {
198 GParamSpecUInt *uspec = G_PARAM_SPEC_UINT (pspec);
199 guint oval = value->data[0].v_uint;
200
201 value->data[0].v_uint = CLAMP (value->data[0].v_uint, uspec->minimum, uspec->maximum);
202
203 return value->data[0].v_uint != oval;
204 }
205
206 static gint
207 param_uint_values_cmp (GParamSpec *pspec,
208 const GValue *value1,
209 const GValue *value2)
210 {
211 if (value1->data[0].v_uint < value2->data[0].v_uint)
212 return -1;
213 else
214 return value1->data[0].v_uint > value2->data[0].v_uint;
215 }
216
217 static void
218 param_long_init (GParamSpec *pspec)
219 {
220 GParamSpecLong *lspec = G_PARAM_SPEC_LONG (pspec);
221
222 #if SIZEOF_LONG == 4
223 lspec->minimum = 0x7fffffff;
224 lspec->maximum = 0x80000000;
225 #else /* SIZEOF_LONG != 4 (8) */
226 lspec->minimum = 0x7fffffffffffffff;
227 lspec->maximum = 0x8000000000000000;
228 #endif
229 lspec->default_value = 0;
230 }
231
232 static void
233 param_long_set_default (GParamSpec *pspec,
234 GValue *value)
235 {
236 value->data[0].v_long = G_PARAM_SPEC_LONG (pspec)->default_value;
237 }
238
239 static gboolean
240 param_long_validate (GParamSpec *pspec,
241 GValue *value)
242 {
243 GParamSpecLong *lspec = G_PARAM_SPEC_LONG (pspec);
244 glong oval = value->data[0].v_long;
245
246 value->data[0].v_long = CLAMP (value->data[0].v_long, lspec->minimum, lspec->maximum);
247
248 return value->data[0].v_long != oval;
249 }
250
251 static gint
252 param_long_values_cmp (GParamSpec *pspec,
253 const GValue *value1,
254 const GValue *value2)
255 {
256 if (value1->data[0].v_long < value2->data[0].v_long)
257 return -1;
258 else
259 return value1->data[0].v_long > value2->data[0].v_long;
260 }
261
262 static void
263 param_ulong_init (GParamSpec *pspec)
264 {
265 GParamSpecULong *uspec = G_PARAM_SPEC_ULONG (pspec);
266
267 uspec->minimum = 0;
268 #if SIZEOF_LONG == 4
269 uspec->maximum = 0xffffffff;
270 #else /* SIZEOF_LONG != 4 (8) */
271 uspec->maximum = 0xffffffffffffffff;
272 #endif
273 uspec->default_value = 0;
274 }
275
276 static void
277 param_ulong_set_default (GParamSpec *pspec,
278 GValue *value)
279 {
280 value->data[0].v_ulong = G_PARAM_SPEC_ULONG (pspec)->default_value;
281 }
282
283 static gboolean
284 param_ulong_validate (GParamSpec *pspec,
285 GValue *value)
286 {
287 GParamSpecULong *uspec = G_PARAM_SPEC_ULONG (pspec);
288 gulong oval = value->data[0].v_ulong;
289
290 value->data[0].v_ulong = CLAMP (value->data[0].v_ulong, uspec->minimum, uspec->maximum);
291
292 return value->data[0].v_ulong != oval;
293 }
294
295 static gint
296 param_ulong_values_cmp (GParamSpec *pspec,
297 const GValue *value1,
298 const GValue *value2)
299 {
300 if (value1->data[0].v_ulong < value2->data[0].v_ulong)
301 return -1;
302 else
303 return value1->data[0].v_ulong > value2->data[0].v_ulong;
304 }
305
306 static void
307 param_int64_init (GParamSpec *pspec)
308 {
309 GParamSpecInt64 *lspec = G_PARAM_SPEC_INT64 (pspec);
310
311 lspec->minimum = G_MININT64;
312 lspec->maximum = G_MAXINT64;
313 lspec->default_value = 0;
314 }
315
316 static void
317 param_int64_set_default (GParamSpec *pspec,
318 GValue *value)
319 {
320 value->data[0].v_int64 = G_PARAM_SPEC_INT64 (pspec)->default_value;
321 }
322
323 static gboolean
324 param_int64_validate (GParamSpec *pspec,
325 GValue *value)
326 {
327 GParamSpecInt64 *lspec = G_PARAM_SPEC_INT64 (pspec);
328 gint64 oval = value->data[0].v_int64;
329
330 value->data[0].v_int64 = CLAMP (value->data[0].v_int64, lspec->minimum, lspec->maximum);
331
332 return value->data[0].v_int64 != oval;
333 }
334
335 static gint
336 param_int64_values_cmp (GParamSpec *pspec,
337 const GValue *value1,
338 const GValue *value2)
339 {
340 if (value1->data[0].v_int64 < value2->data[0].v_int64)
341 return -1;
342 else
343 return value1->data[0].v_int64 > value2->data[0].v_int64;
344 }
345
346 static void
347 param_uint64_init (GParamSpec *pspec)
348 {
349 GParamSpecUInt64 *uspec = G_PARAM_SPEC_UINT64 (pspec);
350
351 uspec->minimum = 0;
352 uspec->maximum = G_MAXUINT64;
353 uspec->default_value = 0;
354 }
355
356 static void
357 param_uint64_set_default (GParamSpec *pspec,
358 GValue *value)
359 {
360 value->data[0].v_uint64 = G_PARAM_SPEC_UINT64 (pspec)->default_value;
361 }
362
363 static gboolean
364 param_uint64_validate (GParamSpec *pspec,
365 GValue *value)
366 {
367 GParamSpecUInt64 *uspec = G_PARAM_SPEC_UINT64 (pspec);
368 guint64 oval = value->data[0].v_uint64;
369
370 value->data[0].v_uint64 = CLAMP (value->data[0].v_uint64, uspec->minimum, uspec->maximum);
371
372 return value->data[0].v_uint64 != oval;
373 }
374
375 static gint
376 param_uint64_values_cmp (GParamSpec *pspec,
377 const GValue *value1,
378 const GValue *value2)
379 {
380 if (value1->data[0].v_uint64 < value2->data[0].v_uint64)
381 return -1;
382 else
383 return value1->data[0].v_uint64 > value2->data[0].v_uint64;
384 }
385
386 static void
387 param_unichar_init (GParamSpec *pspec)
388 {
389 GParamSpecUnichar *uspec = G_PARAM_SPEC_UNICHAR (pspec);
390
391 uspec->default_value = 0;
392 }
393
394 static void
395 param_unichar_set_default (GParamSpec *pspec,
396 GValue *value)
397 {
398 value->data[0].v_uint = G_PARAM_SPEC_UNICHAR (pspec)->default_value;
399 }
400
401 static gboolean
402 param_unichar_validate (GParamSpec *pspec,
403 GValue *value)
404 {
405 gunichar oval = value->data[0].v_uint;
406 gboolean changed = FALSE;
407
408 if (!g_unichar_validate (oval))
409 {
410 value->data[0].v_uint = 0;
411 changed = TRUE;
412 }
413
414 return changed;
415 }
416
417 static gint
418 param_unichar_values_cmp (GParamSpec *pspec,
419 const GValue *value1,
420 const GValue *value2)
421 {
422 if (value1->data[0].v_uint < value2->data[0].v_uint)
423 return -1;
424 else
425 return value1->data[0].v_uint > value2->data[0].v_uint;
426 }
427
428 static void
429 param_enum_init (GParamSpec *pspec)
430 {
431 GParamSpecEnum *espec = G_PARAM_SPEC_ENUM (pspec);
432
433 espec->enum_class = NULL;
434 espec->default_value = 0;
435 }
436
437 static void
438 param_enum_finalize (GParamSpec *pspec)
439 {
440 GParamSpecEnum *espec = G_PARAM_SPEC_ENUM (pspec);
441 GParamSpecClass *parent_class = g_type_class_peek (g_type_parent (G_TYPE_PARAM_ENUM));
442
443 if (espec->enum_class)
444 {
445 g_type_class_unref (espec->enum_class);
446 espec->enum_class = NULL;
447 }
448
449 parent_class->finalize (pspec);
450 }
451
452 static void
453 param_enum_set_default (GParamSpec *pspec,
454 GValue *value)
455 {
456 value->data[0].v_long = G_PARAM_SPEC_ENUM (pspec)->default_value;
457 }
458
459 static gboolean
460 param_enum_validate (GParamSpec *pspec,
461 GValue *value)
462 {
463 GParamSpecEnum *espec = G_PARAM_SPEC_ENUM (pspec);
464 glong oval = value->data[0].v_long;
465
466 if (!espec->enum_class ||
467 !g_enum_get_value (espec->enum_class, value->data[0].v_long))
468 value->data[0].v_long = espec->default_value;
469
470 return value->data[0].v_long != oval;
471 }
472
473 static void
474 param_flags_init (GParamSpec *pspec)
475 {
476 GParamSpecFlags *fspec = G_PARAM_SPEC_FLAGS (pspec);
477
478 fspec->flags_class = NULL;
479 fspec->default_value = 0;
480 }
481
482 static void
483 param_flags_finalize (GParamSpec *pspec)
484 {
485 GParamSpecFlags *fspec = G_PARAM_SPEC_FLAGS (pspec);
486 GParamSpecClass *parent_class = g_type_class_peek (g_type_parent (G_TYPE_PARAM_FLAGS));
487
488 if (fspec->flags_class)
489 {
490 g_type_class_unref (fspec->flags_class);
491 fspec->flags_class = NULL;
492 }
493
494 parent_class->finalize (pspec);
495 }
496
497 static void
498 param_flags_set_default (GParamSpec *pspec,
499 GValue *value)
500 {
501 value->data[0].v_ulong = G_PARAM_SPEC_FLAGS (pspec)->default_value;
502 }
503
504 static gboolean
505 param_flags_validate (GParamSpec *pspec,
506 GValue *value)
507 {
508 GParamSpecFlags *fspec = G_PARAM_SPEC_FLAGS (pspec);
509 gulong oval = value->data[0].v_ulong;
510
511 if (fspec->flags_class)
512 value->data[0].v_ulong &= fspec->flags_class->mask;
513 else
514 value->data[0].v_ulong = fspec->default_value;
515
516 return value->data[0].v_ulong != oval;
517 }
518
519 static void
520 param_float_init (GParamSpec *pspec)
521 {
522 GParamSpecFloat *fspec = G_PARAM_SPEC_FLOAT (pspec);
523
524 fspec->minimum = -G_MAXFLOAT;
525 fspec->maximum = G_MAXFLOAT;
526 fspec->default_value = 0;
527 fspec->epsilon = G_FLOAT_EPSILON;
528 }
529
530 static void
531 param_float_set_default (GParamSpec *pspec,
532 GValue *value)
533 {
534 value->data[0].v_float = G_PARAM_SPEC_FLOAT (pspec)->default_value;
535 }
536
537 static gboolean
538 param_float_validate (GParamSpec *pspec,
539 GValue *value)
540 {
541 GParamSpecFloat *fspec = G_PARAM_SPEC_FLOAT (pspec);
542 gfloat oval = value->data[0].v_float;
543
544 value->data[0].v_float = CLAMP (value->data[0].v_float, fspec->minimum, fspec->maximum);
545
546 return value->data[0].v_float != oval;
547 }
548
549 static gint
550 param_float_values_cmp (GParamSpec *pspec,
551 const GValue *value1,
552 const GValue *value2)
553 {
554 gfloat epsilon = G_PARAM_SPEC_FLOAT (pspec)->epsilon;
555
556 if (value1->data[0].v_float < value2->data[0].v_float)
557 return - (value2->data[0].v_float - value1->data[0].v_float > epsilon);
558 else
559 return value1->data[0].v_float - value2->data[0].v_float > epsilon;
560 }
561
562 static void
563 param_double_init (GParamSpec *pspec)
564 {
565 GParamSpecDouble *dspec = G_PARAM_SPEC_DOUBLE (pspec);
566
567 dspec->minimum = -G_MAXDOUBLE;
568 dspec->maximum = G_MAXDOUBLE;
569 dspec->default_value = 0;
570 dspec->epsilon = G_DOUBLE_EPSILON;
571 }
572
573 static void
574 param_double_set_default (GParamSpec *pspec,
575 GValue *value)
576 {
577 value->data[0].v_double = G_PARAM_SPEC_DOUBLE (pspec)->default_value;
578 }
579
580 static gboolean
581 param_double_validate (GParamSpec *pspec,
582 GValue *value)
583 {
584 GParamSpecDouble *dspec = G_PARAM_SPEC_DOUBLE (pspec);
585 gdouble oval = value->data[0].v_double;
586
587 value->data[0].v_double = CLAMP (value->data[0].v_double, dspec->minimum, dspec->maximum);
588
589 return value->data[0].v_double != oval;
590 }
591
592 static gint
593 param_double_values_cmp (GParamSpec *pspec,
594 const GValue *value1,
595 const GValue *value2)
596 {
597 gdouble epsilon = G_PARAM_SPEC_DOUBLE (pspec)->epsilon;
598
599 if (value1->data[0].v_double < value2->data[0].v_double)
600 return - (value2->data[0].v_double - value1->data[0].v_double > epsilon);
601 else
602 return value1->data[0].v_double - value2->data[0].v_double > epsilon;
603 }
604
605 static void
606 param_string_init (GParamSpec *pspec)
607 {
608 GParamSpecString *sspec = G_PARAM_SPEC_STRING (pspec);
609
610 sspec->default_value = NULL;
611 sspec->cset_first = NULL;
612 sspec->cset_nth = NULL;
613 sspec->substitutor = '_';
614 sspec->null_fold_if_empty = FALSE;
615 sspec->ensure_non_null = FALSE;
616 }
617
618 static void
619 param_string_finalize (GParamSpec *pspec)
620 {
621 GParamSpecString *sspec = G_PARAM_SPEC_STRING (pspec);
622 GParamSpecClass *parent_class = g_type_class_peek (g_type_parent (G_TYPE_PARAM_STRING));
623
624 g_free (sspec->default_value);
625 g_free (sspec->cset_first);
626 g_free (sspec->cset_nth);
627 sspec->default_value = NULL;
628 sspec->cset_first = NULL;
629 sspec->cset_nth = NULL;
630
631 parent_class->finalize (pspec);
632 }
633
634 static void
635 param_string_set_default (GParamSpec *pspec,
636 GValue *value)
637 {
638 value->data[0].v_pointer = g_strdup (G_PARAM_SPEC_STRING (pspec)->default_value);
639 }
640
641 static gboolean
642 param_string_validate (GParamSpec *pspec,
643 GValue *value)
644 {
645 GParamSpecString *sspec = G_PARAM_SPEC_STRING (pspec);
646 gchar *string = value->data[0].v_pointer;
647 guint changed = 0;
648
649 if (string && string[0])
650 {
651 gchar *s;
652
653 if (sspec->cset_first && !strchr (sspec->cset_first, string[0]))
654 {
655 if (value->data[1].v_uint & G_VALUE_NOCOPY_CONTENTS)
656 {
657 value->data[0].v_pointer = g_strdup (string);
658 string = value->data[0].v_pointer;
659 value->data[1].v_uint &= ~G_VALUE_NOCOPY_CONTENTS;
660 }
661 string[0] = sspec->substitutor;
662 changed++;
663 }
664 if (sspec->cset_nth)
665 for (s = string + 1; *s; s++)
666 if (!strchr (sspec->cset_nth, *s))
667 {
668 if (value->data[1].v_uint & G_VALUE_NOCOPY_CONTENTS)
669 {
670 value->data[0].v_pointer = g_strdup (string);
671 s = (gchar*) value->data[0].v_pointer + (s - string);
672 string = value->data[0].v_pointer;
673 value->data[1].v_uint &= ~G_VALUE_NOCOPY_CONTENTS;
674 }
675 *s = sspec->substitutor;
676 changed++;
677 }
678 }
679 if (sspec->null_fold_if_empty && string && string[0] == 0)
680 {
681 if (!(value->data[1].v_uint & G_VALUE_NOCOPY_CONTENTS))
682 g_free (value->data[0].v_pointer);
683 else
684 value->data[1].v_uint &= ~G_VALUE_NOCOPY_CONTENTS;
685 value->data[0].v_pointer = NULL;
686 changed++;
687 string = value->data[0].v_pointer;
688 }
689 if (sspec->ensure_non_null && !string)
690 {
691 value->data[1].v_uint &= ~G_VALUE_NOCOPY_CONTENTS;
692 value->data[0].v_pointer = g_strdup ("");
693 changed++;
694 string = value->data[0].v_pointer;
695 }
696
697 return changed;
698 }
699
700 static gint
701 param_string_values_cmp (GParamSpec *pspec,
702 const GValue *value1,
703 const GValue *value2)
704 {
705 if (!value1->data[0].v_pointer)
706 return value2->data[0].v_pointer != NULL ? -1 : 0;
707 else if (!value2->data[0].v_pointer)
708 return value1->data[0].v_pointer != NULL;
709 else
710 return strcmp (value1->data[0].v_pointer, value2->data[0].v_pointer);
711 }
712
713 static void
714 param_param_init (GParamSpec *pspec)
715 {
716 /* GParamSpecParam *spec = G_PARAM_SPEC_PARAM (pspec); */
717 }
718
719 static void
720 param_param_set_default (GParamSpec *pspec,
721 GValue *value)
722 {
723 value->data[0].v_pointer = NULL;
724 }
725
726 static gboolean
727 param_param_validate (GParamSpec *pspec,
728 GValue *value)
729 {
730 /* GParamSpecParam *spec = G_PARAM_SPEC_PARAM (pspec); */
731 GParamSpec *param = value->data[0].v_pointer;
732 guint changed = 0;
733
734 if (param && !g_value_type_compatible (G_PARAM_SPEC_TYPE (param), G_PARAM_SPEC_VALUE_TYPE (pspec)))
735 {
736 g_param_spec_unref (param);
737 value->data[0].v_pointer = NULL;
738 changed++;
739 }
740
741 return changed;
742 }
743
744 static void
745 param_boxed_init (GParamSpec *pspec)
746 {
747 /* GParamSpecBoxed *bspec = G_PARAM_SPEC_BOXED (pspec); */
748 }
749
750 static void
751 param_boxed_set_default (GParamSpec *pspec,
752 GValue *value)
753 {
754 value->data[0].v_pointer = NULL;
755 }
756
757 static gboolean
758 param_boxed_validate (GParamSpec *pspec,
759 GValue *value)
760 {
761 /* GParamSpecBoxed *bspec = G_PARAM_SPEC_BOXED (pspec); */
762 guint changed = 0;
763
764 /* can't do a whole lot here since we haven't even G_BOXED_TYPE() */
765
766 return changed;
767 }
768
769 static gint
770 param_boxed_values_cmp (GParamSpec *pspec,
771 const GValue *value1,
772 const GValue *value2)
773 {
774 guint8 *p1 = value1->data[0].v_pointer;
775 guint8 *p2 = value2->data[0].v_pointer;
776
777 /* not much to compare here, try to at least provide stable lesser/greater result */
778
779 return p1 < p2 ? -1 : p1 > p2;
780 }
781
782 static void
783 param_pointer_init (GParamSpec *pspec)
784 {
785 /* GParamSpecPointer *spec = G_PARAM_SPEC_POINTER (pspec); */
786 }
787
788 static void
789 param_pointer_set_default (GParamSpec *pspec,
790 GValue *value)
791 {
792 value->data[0].v_pointer = NULL;
793 }
794
795 static gboolean
796 param_pointer_validate (GParamSpec *pspec,
797 GValue *value)
798 {
799 /* GParamSpecPointer *spec = G_PARAM_SPEC_POINTER (pspec); */
800 guint changed = 0;
801
802 return changed;
803 }
804
805 static gint
806 param_pointer_values_cmp (GParamSpec *pspec,
807 const GValue *value1,
808 const GValue *value2)
809 {
810 guint8 *p1 = value1->data[0].v_pointer;
811 guint8 *p2 = value2->data[0].v_pointer;
812
813 /* not much to compare here, try to at least provide stable lesser/greater result */
814
815 return p1 < p2 ? -1 : p1 > p2;
816 }
817
818 static void
819 param_value_array_init (GParamSpec *pspec)
820 {
821 GParamSpecValueArray *aspec = G_PARAM_SPEC_VALUE_ARRAY (pspec);
822
823 aspec->element_spec = NULL;
824 aspec->fixed_n_elements = 0; /* disable */
825 }
826
827 static inline guint
828 value_array_ensure_size (GValueArray *value_array,
829 guint fixed_n_elements)
830 {
831 guint changed = 0;
832
833 if (fixed_n_elements)
834 {
835 while (value_array->n_values < fixed_n_elements)
836 {
837 g_value_array_append (value_array, NULL);
838 changed++;
839 }
840 while (value_array->n_values > fixed_n_elements)
841 {
842 g_value_array_remove (value_array, value_array->n_values - 1);
843 changed++;
844 }
845 }
846 return changed;
847 }
848
849 static void
850 param_value_array_finalize (GParamSpec *pspec)
851 {
852 GParamSpecValueArray *aspec = G_PARAM_SPEC_VALUE_ARRAY (pspec);
853 GParamSpecClass *parent_class = g_type_class_peek (g_type_parent (G_TYPE_PARAM_VALUE_ARRAY));
854
855 if (aspec->element_spec)
856 {
857 g_param_spec_unref (aspec->element_spec);
858 aspec->element_spec = NULL;
859 }
860
861 parent_class->finalize (pspec);
862 }
863
864 static void
865 param_value_array_set_default (GParamSpec *pspec,
866 GValue *value)
867 {
868 GParamSpecValueArray *aspec = G_PARAM_SPEC_VALUE_ARRAY (pspec);
869
870 if (!value->data[0].v_pointer && aspec->fixed_n_elements)
871 value->data[0].v_pointer = g_value_array_new (aspec->fixed_n_elements);
872
873 if (value->data[0].v_pointer)
874 {
875 /* g_value_reset (value); already done */
876 value_array_ensure_size (value->data[0].v_pointer, aspec->fixed_n_elements);
877 }
878 }
879
880 static gboolean
881 param_value_array_validate (GParamSpec *pspec,
882 GValue *value)
883 {
884 GParamSpecValueArray *aspec = G_PARAM_SPEC_VALUE_ARRAY (pspec);
885 GValueArray *value_array = value->data[0].v_pointer;
886 guint changed = 0;
887
888 if (!value->data[0].v_pointer && aspec->fixed_n_elements)
889 value->data[0].v_pointer = g_value_array_new (aspec->fixed_n_elements);
890
891 if (value->data[0].v_pointer)
892 {
893 /* ensure array size validity */
894 changed += value_array_ensure_size (value_array, aspec->fixed_n_elements);
895
896 /* ensure array values validity against a present element spec */
897 if (aspec->element_spec)
898 {
899 GParamSpec *element_spec = aspec->element_spec;
900 guint i;
901
902 for (i = 0; i < value_array->n_values; i++)
903 {
904 GValue *element = value_array->values + i;
905
906 /* need to fixup value type, or ensure that the array value is initialized at all */
907 if (!g_value_type_compatible (G_VALUE_TYPE (element), G_PARAM_SPEC_VALUE_TYPE (element_spec)))
908 {
909 if (G_VALUE_TYPE (element) != 0)
910 g_value_unset (element);
911 g_value_init (element, G_PARAM_SPEC_VALUE_TYPE (element_spec));
912 g_param_value_set_default (element_spec, element);
913 changed++;
914 }
915 /* validate array value against element_spec */
916 changed += g_param_value_validate (element_spec, element);
917 }
918 }
919 }
920
921 return changed;
922 }
923
924 static gint
925 param_value_array_values_cmp (GParamSpec *pspec,
926 const GValue *value1,
927 const GValue *value2)
928 {
929 GParamSpecValueArray *aspec = G_PARAM_SPEC_VALUE_ARRAY (pspec);
930 GValueArray *value_array1 = value1->data[0].v_pointer;
931 GValueArray *value_array2 = value2->data[0].v_pointer;
932
933 if (!value_array1 || !value_array2)
934 return value_array2 ? -1 : value_array1 != value_array2;
935
936 if (value_array1->n_values != value_array2->n_values)
937 return value_array1->n_values < value_array2->n_values ? -1 : 1;
938 else if (!aspec->element_spec)
939 {
940 /* we need an element specification for comparisons, so there's not much
941 * to compare here, try to at least provide stable lesser/greater result
942 */
943 return value_array1->n_values < value_array2->n_values ? -1 : value_array1->n_values > value_array2->n_values;
944 }
945 else /* value_array1->n_values == value_array2->n_values */
946 {
947 guint i;
948
949 for (i = 0; i < value_array1->n_values; i++)
950 {
951 GValue *element1 = value_array1->values + i;
952 GValue *element2 = value_array2->values + i;
953 gint cmp;
954
955 /* need corresponding element types, provide stable result otherwise */
956 if (G_VALUE_TYPE (element1) != G_VALUE_TYPE (element2))
957 return G_VALUE_TYPE (element1) < G_VALUE_TYPE (element2) ? -1 : 1;
958 cmp = g_param_values_cmp (aspec->element_spec, element1, element2);
959 if (cmp)
960 return cmp;
961 }
962 return 0;
963 }
964 }
965
966 static void
967 param_object_init (GParamSpec *pspec)
968 {
969 /* GParamSpecObject *ospec = G_PARAM_SPEC_OBJECT (pspec); */
970 }
971
972 static void
973 param_object_set_default (GParamSpec *pspec,
974 GValue *value)
975 {
976 value->data[0].v_pointer = NULL;
977 }
978
979 static gboolean
980 param_object_validate (GParamSpec *pspec,
981 GValue *value)
982 {
983 GParamSpecObject *ospec = G_PARAM_SPEC_OBJECT (pspec);
984 GObject *object = value->data[0].v_pointer;
985 guint changed = 0;
986
987 if (object && !g_value_type_compatible (G_OBJECT_TYPE (object), G_PARAM_SPEC_VALUE_TYPE (ospec)))
988 {
989 g_object_unref (object);
990 value->data[0].v_pointer = NULL;
991 changed++;
992 }
993
994 return changed;
995 }
996
997 static gint
998 param_object_values_cmp (GParamSpec *pspec,
999 const GValue *value1,
1000 const GValue *value2)
1001 {
1002 guint8 *p1 = value1->data[0].v_pointer;
1003 guint8 *p2 = value2->data[0].v_pointer;
1004
1005 /* not much to compare here, try to at least provide stable lesser/greater result */
1006
1007 return p1 < p2 ? -1 : p1 > p2;
1008 }
1009
1010 static void
1011 param_override_init (GParamSpec *pspec)
1012 {
1013 /* GParamSpecOverride *ospec = G_PARAM_SPEC_OVERRIDE (pspec); */
1014 }
1015
1016 static void
1017 param_override_finalize (GParamSpec *pspec)
1018 {
1019 GParamSpecOverride *ospec = G_PARAM_SPEC_OVERRIDE (pspec);
1020 GParamSpecClass *parent_class = g_type_class_peek (g_type_parent (G_TYPE_PARAM_OVERRIDE));
1021
1022 if (ospec->overridden)
1023 {
1024 g_param_spec_unref (ospec->overridden);
1025 ospec->overridden = NULL;
1026 }
1027
1028 parent_class->finalize (pspec);
1029 }
1030
1031 static void
1032 param_override_set_default (GParamSpec *pspec,
1033 GValue *value)
1034 {
1035 GParamSpecOverride *ospec = G_PARAM_SPEC_OVERRIDE (pspec);
1036
1037 g_param_value_set_default (ospec->overridden, value);
1038 }
1039
1040 static gboolean
1041 param_override_validate (GParamSpec *pspec,
1042 GValue *value)
1043 {
1044 GParamSpecOverride *ospec = G_PARAM_SPEC_OVERRIDE (pspec);
1045
1046 return g_param_value_validate (ospec->overridden, value);
1047 }
1048
1049 static gint
1050 param_override_values_cmp (GParamSpec *pspec,
1051 const GValue *value1,
1052 const GValue *value2)
1053 {
1054 GParamSpecOverride *ospec = G_PARAM_SPEC_OVERRIDE (pspec);
1055
1056 return g_param_values_cmp (ospec->overridden, value1, value2);
1057 }
1058
1059 static void
1060 param_gtype_init (GParamSpec *pspec)
1061 {
1062 }
1063
1064 static void
1065 param_gtype_set_default (GParamSpec *pspec,
1066 GValue *value)
1067 {
1068 GParamSpecGType *tspec = G_PARAM_SPEC_GTYPE (pspec);
1069
1070 value->data[0].v_long = tspec->is_a_type;
1071 }
1072
1073 static gboolean
1074 param_gtype_validate (GParamSpec *pspec,
1075 GValue *value)
1076 {
1077 GParamSpecGType *tspec = G_PARAM_SPEC_GTYPE (pspec);
1078 GType gtype = value->data[0].v_long;
1079 guint changed = 0;
1080
1081 if (tspec->is_a_type != G_TYPE_NONE && !g_type_is_a (gtype, tspec->is_a_type))
1082 {
1083 value->data[0].v_long = tspec->is_a_type;
1084 changed++;
1085 }
1086
1087 return changed;
1088 }
1089
1090 static gint
1091 param_gtype_values_cmp (GParamSpec *pspec,
1092 const GValue *value1,
1093 const GValue *value2)
1094 {
1095 GType p1 = value1->data[0].v_long;
1096 GType p2 = value2->data[0].v_long;
1097
1098 /* not much to compare here, try to at least provide stable lesser/greater result */
1099
1100 return p1 < p2 ? -1 : p1 > p2;
1101 }
1102
1103 static void
1104 param_variant_init (GParamSpec *pspec)
1105 {
1106 GParamSpecVariant *vspec = G_PARAM_SPEC_VARIANT (pspec);
1107
1108 vspec->type = NULL;
1109 vspec->default_value = NULL;
1110 }
1111
1112 static void
1113 param_variant_finalize (GParamSpec *pspec)
1114 {
1115 GParamSpecVariant *vspec = G_PARAM_SPEC_VARIANT (pspec);
1116 GParamSpecClass *parent_class = g_type_class_peek (g_type_parent (G_TYPE_PARAM_VARIANT));
1117
1118 if (vspec->default_value)
1119 g_variant_unref (vspec->default_value);
1120 g_variant_type_free (vspec->type);
1121
1122 parent_class->finalize (pspec);
1123 }
1124
1125 static void
1126 param_variant_set_default (GParamSpec *pspec,
1127 GValue *value)
1128 {
1129 value->data[0].v_pointer = G_PARAM_SPEC_VARIANT (pspec)->default_value;
1130 value->data[1].v_uint |= G_VALUE_NOCOPY_CONTENTS;
1131 }
1132
1133 static gboolean
1134 param_variant_validate (GParamSpec *pspec,
1135 GValue *value)
1136 {
1137 GParamSpecVariant *vspec = G_PARAM_SPEC_VARIANT (pspec);
1138 GVariant *variant = value->data[0].v_pointer;
1139
1140 if ((variant == NULL && vspec->default_value != NULL) ||
1141 (variant != NULL && !g_variant_is_of_type (variant, vspec->type)))
1142 {
1143 g_param_value_set_default (pspec, value);
1144 return TRUE;
1145 }
1146
1147 return FALSE;
1148 }
1149
1150 static gint
1151 param_variant_values_cmp (GParamSpec *pspec,
1152 const GValue *value1,
1153 const GValue *value2)
1154 {
1155 GVariant *v1 = value1->data[0].v_pointer;
1156 GVariant *v2 = value2->data[0].v_pointer;
1157
1158 return v1 < v2 ? -1 : v2 > v1;
1159 }
1160
1161 /* --- type initialization --- */
1162 GType *g_param_spec_types = NULL;
1163
1164 void
1165 _g_param_spec_types_init (void)
1166 {
1167 const guint n_types = 23;
1168 GType type, *spec_types, *spec_types_bound;
1169
1170 g_param_spec_types = g_new0 (GType, n_types);
1171 spec_types = g_param_spec_types;
1172 spec_types_bound = g_param_spec_types + n_types;
1173
1174 /* G_TYPE_PARAM_CHAR
1175 */
1176 {
1177 static const GParamSpecTypeInfo pspec_info = {
1178 sizeof (GParamSpecChar), /* instance_size */
1179 16, /* n_preallocs */
1180 param_char_init, /* instance_init */
1181 G_TYPE_CHAR, /* value_type */
1182 NULL, /* finalize */
1183 param_char_set_default, /* value_set_default */
1184 param_char_validate, /* value_validate */
1185 param_int_values_cmp, /* values_cmp */
1186 };
1187 type = g_param_type_register_static (g_intern_static_string ("GParamChar"), &pspec_info);
1188 *spec_types++ = type;
1189 g_assert (type == G_TYPE_PARAM_CHAR);
1190 }
1191
1192 /* G_TYPE_PARAM_UCHAR
1193 */
1194 {
1195 static const GParamSpecTypeInfo pspec_info = {
1196 sizeof (GParamSpecUChar), /* instance_size */
1197 16, /* n_preallocs */
1198 param_uchar_init, /* instance_init */
1199 G_TYPE_UCHAR, /* value_type */
1200 NULL, /* finalize */
1201 param_uchar_set_default, /* value_set_default */
1202 param_uchar_validate, /* value_validate */
1203 param_uint_values_cmp, /* values_cmp */
1204 };
1205 type = g_param_type_register_static (g_intern_static_string ("GParamUChar"), &pspec_info);
1206 *spec_types++ = type;
1207 g_assert (type == G_TYPE_PARAM_UCHAR);
1208 }
1209
1210 /* G_TYPE_PARAM_BOOLEAN
1211 */
1212 {
1213 static const GParamSpecTypeInfo pspec_info = {
1214 sizeof (GParamSpecBoolean), /* instance_size */
1215 16, /* n_preallocs */
1216 NULL, /* instance_init */
1217 G_TYPE_BOOLEAN, /* value_type */
1218 NULL, /* finalize */
1219 param_boolean_set_default, /* value_set_default */
1220 param_boolean_validate, /* value_validate */
1221 param_int_values_cmp, /* values_cmp */
1222 };
1223 type = g_param_type_register_static (g_intern_static_string ("GParamBoolean"), &pspec_info);
1224 *spec_types++ = type;
1225 g_assert (type == G_TYPE_PARAM_BOOLEAN);
1226 }
1227
1228 /* G_TYPE_PARAM_INT
1229 */
1230 {
1231 static const GParamSpecTypeInfo pspec_info = {
1232 sizeof (GParamSpecInt), /* instance_size */
1233 16, /* n_preallocs */
1234 param_int_init, /* instance_init */
1235 G_TYPE_INT, /* value_type */
1236 NULL, /* finalize */
1237 param_int_set_default, /* value_set_default */
1238 param_int_validate, /* value_validate */
1239 param_int_values_cmp, /* values_cmp */
1240 };
1241 type = g_param_type_register_static (g_intern_static_string ("GParamInt"), &pspec_info);
1242 *spec_types++ = type;
1243 g_assert (type == G_TYPE_PARAM_INT);
1244 }
1245
1246 /* G_TYPE_PARAM_UINT
1247 */
1248 {
1249 static const GParamSpecTypeInfo pspec_info = {
1250 sizeof (GParamSpecUInt), /* instance_size */
1251 16, /* n_preallocs */
1252 param_uint_init, /* instance_init */
1253 G_TYPE_UINT, /* value_type */
1254 NULL, /* finalize */
1255 param_uint_set_default, /* value_set_default */
1256 param_uint_validate, /* value_validate */
1257 param_uint_values_cmp, /* values_cmp */
1258 };
1259 type = g_param_type_register_static (g_intern_static_string ("GParamUInt"), &pspec_info);
1260 *spec_types++ = type;
1261 g_assert (type == G_TYPE_PARAM_UINT);
1262 }
1263
1264 /* G_TYPE_PARAM_LONG
1265 */
1266 {
1267 static const GParamSpecTypeInfo pspec_info = {
1268 sizeof (GParamSpecLong), /* instance_size */
1269 16, /* n_preallocs */
1270 param_long_init, /* instance_init */
1271 G_TYPE_LONG, /* value_type */
1272 NULL, /* finalize */
1273 param_long_set_default, /* value_set_default */
1274 param_long_validate, /* value_validate */
1275 param_long_values_cmp, /* values_cmp */
1276 };
1277 type = g_param_type_register_static (g_intern_static_string ("GParamLong"), &pspec_info);
1278 *spec_types++ = type;
1279 g_assert (type == G_TYPE_PARAM_LONG);
1280 }
1281
1282 /* G_TYPE_PARAM_ULONG
1283 */
1284 {
1285 static const GParamSpecTypeInfo pspec_info = {
1286 sizeof (GParamSpecULong), /* instance_size */
1287 16, /* n_preallocs */
1288 param_ulong_init, /* instance_init */
1289 G_TYPE_ULONG, /* value_type */
1290 NULL, /* finalize */
1291 param_ulong_set_default, /* value_set_default */
1292 param_ulong_validate, /* value_validate */
1293 param_ulong_values_cmp, /* values_cmp */
1294 };
1295 type = g_param_type_register_static (g_intern_static_string ("GParamULong"), &pspec_info);
1296 *spec_types++ = type;
1297 g_assert (type == G_TYPE_PARAM_ULONG);
1298 }
1299
1300 /* G_TYPE_PARAM_INT64
1301 */
1302 {
1303 static const GParamSpecTypeInfo pspec_info = {
1304 sizeof (GParamSpecInt64), /* instance_size */
1305 16, /* n_preallocs */
1306 param_int64_init, /* instance_init */
1307 G_TYPE_INT64, /* value_type */
1308 NULL, /* finalize */
1309 param_int64_set_default, /* value_set_default */
1310 param_int64_validate, /* value_validate */
1311 param_int64_values_cmp, /* values_cmp */
1312 };
1313 type = g_param_type_register_static (g_intern_static_string ("GParamInt64"), &pspec_info);
1314 *spec_types++ = type;
1315 g_assert (type == G_TYPE_PARAM_INT64);
1316 }
1317
1318 /* G_TYPE_PARAM_UINT64
1319 */
1320 {
1321 static const GParamSpecTypeInfo pspec_info = {
1322 sizeof (GParamSpecUInt64), /* instance_size */
1323 16, /* n_preallocs */
1324 param_uint64_init, /* instance_init */
1325 G_TYPE_UINT64, /* value_type */
1326 NULL, /* finalize */
1327 param_uint64_set_default, /* value_set_default */
1328 param_uint64_validate, /* value_validate */
1329 param_uint64_values_cmp, /* values_cmp */
1330 };
1331 type = g_param_type_register_static (g_intern_static_string ("GParamUInt64"), &pspec_info);
1332 *spec_types++ = type;
1333 g_assert (type == G_TYPE_PARAM_UINT64);
1334 }
1335
1336 /* G_TYPE_PARAM_UNICHAR
1337 */
1338 {
1339 static const GParamSpecTypeInfo pspec_info = {
1340 sizeof (GParamSpecUnichar), /* instance_size */
1341 16, /* n_preallocs */
1342 param_unichar_init, /* instance_init */
1343 G_TYPE_UINT, /* value_type */
1344 NULL, /* finalize */
1345 param_unichar_set_default, /* value_set_default */
1346 param_unichar_validate, /* value_validate */
1347 param_unichar_values_cmp, /* values_cmp */
1348 };
1349 type = g_param_type_register_static (g_intern_static_string ("GParamUnichar"), &pspec_info);
1350 *spec_types++ = type;
1351 g_assert (type == G_TYPE_PARAM_UNICHAR);
1352 }
1353
1354 /* G_TYPE_PARAM_ENUM
1355 */
1356 {
1357 static const GParamSpecTypeInfo pspec_info = {
1358 sizeof (GParamSpecEnum), /* instance_size */
1359 16, /* n_preallocs */
1360 param_enum_init, /* instance_init */
1361 G_TYPE_ENUM, /* value_type */
1362 param_enum_finalize, /* finalize */
1363 param_enum_set_default, /* value_set_default */
1364 param_enum_validate, /* value_validate */
1365 param_long_values_cmp, /* values_cmp */
1366 };
1367 type = g_param_type_register_static (g_intern_static_string ("GParamEnum"), &pspec_info);
1368 *spec_types++ = type;
1369 g_assert (type == G_TYPE_PARAM_ENUM);
1370 }
1371
1372 /* G_TYPE_PARAM_FLAGS
1373 */
1374 {
1375 static const GParamSpecTypeInfo pspec_info = {
1376 sizeof (GParamSpecFlags), /* instance_size */
1377 16, /* n_preallocs */
1378 param_flags_init, /* instance_init */
1379 G_TYPE_FLAGS, /* value_type */
1380 param_flags_finalize, /* finalize */
1381 param_flags_set_default, /* value_set_default */
1382 param_flags_validate, /* value_validate */
1383 param_ulong_values_cmp, /* values_cmp */
1384 };
1385 type = g_param_type_register_static (g_intern_static_string ("GParamFlags"), &pspec_info);
1386 *spec_types++ = type;
1387 g_assert (type == G_TYPE_PARAM_FLAGS);
1388 }
1389
1390 /* G_TYPE_PARAM_FLOAT
1391 */
1392 {
1393 static const GParamSpecTypeInfo pspec_info = {
1394 sizeof (GParamSpecFloat), /* instance_size */
1395 16, /* n_preallocs */
1396 param_float_init, /* instance_init */
1397 G_TYPE_FLOAT, /* value_type */
1398 NULL, /* finalize */
1399 param_float_set_default, /* value_set_default */
1400 param_float_validate, /* value_validate */
1401 param_float_values_cmp, /* values_cmp */
1402 };
1403 type = g_param_type_register_static (g_intern_static_string ("GParamFloat"), &pspec_info);
1404 *spec_types++ = type;
1405 g_assert (type == G_TYPE_PARAM_FLOAT);
1406 }
1407
1408 /* G_TYPE_PARAM_DOUBLE
1409 */
1410 {
1411 static const GParamSpecTypeInfo pspec_info = {
1412 sizeof (GParamSpecDouble), /* instance_size */
1413 16, /* n_preallocs */
1414 param_double_init, /* instance_init */
1415 G_TYPE_DOUBLE, /* value_type */
1416 NULL, /* finalize */
1417 param_double_set_default, /* value_set_default */
1418 param_double_validate, /* value_validate */
1419 param_double_values_cmp, /* values_cmp */
1420 };
1421 type = g_param_type_register_static (g_intern_static_string ("GParamDouble"), &pspec_info);
1422 *spec_types++ = type;
1423 g_assert (type == G_TYPE_PARAM_DOUBLE);
1424 }
1425
1426 /* G_TYPE_PARAM_STRING
1427 */
1428 {
1429 static const GParamSpecTypeInfo pspec_info = {
1430 sizeof (GParamSpecString), /* instance_size */
1431 16, /* n_preallocs */
1432 param_string_init, /* instance_init */
1433 G_TYPE_STRING, /* value_type */
1434 param_string_finalize, /* finalize */
1435 param_string_set_default, /* value_set_default */
1436 param_string_validate, /* value_validate */
1437 param_string_values_cmp, /* values_cmp */
1438 };
1439 type = g_param_type_register_static (g_intern_static_string ("GParamString"), &pspec_info);
1440 *spec_types++ = type;
1441 g_assert (type == G_TYPE_PARAM_STRING);
1442 }
1443
1444 /* G_TYPE_PARAM_PARAM
1445 */
1446 {
1447 static const GParamSpecTypeInfo pspec_info = {
1448 sizeof (GParamSpecParam), /* instance_size */
1449 16, /* n_preallocs */
1450 param_param_init, /* instance_init */
1451 G_TYPE_PARAM, /* value_type */
1452 NULL, /* finalize */
1453 param_param_set_default, /* value_set_default */
1454 param_param_validate, /* value_validate */
1455 param_pointer_values_cmp, /* values_cmp */
1456 };
1457 type = g_param_type_register_static (g_intern_static_string ("GParamParam"), &pspec_info);
1458 *spec_types++ = type;
1459 g_assert (type == G_TYPE_PARAM_PARAM);
1460 }
1461
1462 /* G_TYPE_PARAM_BOXED
1463 */
1464 {
1465 static const GParamSpecTypeInfo pspec_info = {
1466 sizeof (GParamSpecBoxed), /* instance_size */
1467 4, /* n_preallocs */
1468 param_boxed_init, /* instance_init */
1469 G_TYPE_BOXED, /* value_type */
1470 NULL, /* finalize */
1471 param_boxed_set_default, /* value_set_default */
1472 param_boxed_validate, /* value_validate */
1473 param_boxed_values_cmp, /* values_cmp */
1474 };
1475 type = g_param_type_register_static (g_intern_static_string ("GParamBoxed"), &pspec_info);
1476 *spec_types++ = type;
1477 g_assert (type == G_TYPE_PARAM_BOXED);
1478 }
1479
1480 /* G_TYPE_PARAM_POINTER
1481 */
1482 {
1483 static const GParamSpecTypeInfo pspec_info = {
1484 sizeof (GParamSpecPointer), /* instance_size */
1485 0, /* n_preallocs */
1486 param_pointer_init, /* instance_init */
1487 G_TYPE_POINTER, /* value_type */
1488 NULL, /* finalize */
1489 param_pointer_set_default, /* value_set_default */
1490 param_pointer_validate, /* value_validate */
1491 param_pointer_values_cmp, /* values_cmp */
1492 };
1493 type = g_param_type_register_static (g_intern_static_string ("GParamPointer"), &pspec_info);
1494 *spec_types++ = type;
1495 g_assert (type == G_TYPE_PARAM_POINTER);
1496 }
1497
1498 /* G_TYPE_PARAM_VALUE_ARRAY
1499 */
1500 {
1501 static /* const */ GParamSpecTypeInfo pspec_info = {
1502 sizeof (GParamSpecValueArray), /* instance_size */
1503 0, /* n_preallocs */
1504 param_value_array_init, /* instance_init */
1505 0xdeadbeef, /* value_type, assigned further down */
1506 param_value_array_finalize, /* finalize */
1507 param_value_array_set_default, /* value_set_default */
1508 param_value_array_validate, /* value_validate */
1509 param_value_array_values_cmp, /* values_cmp */
1510 };
1511 pspec_info.value_type = G_TYPE_VALUE_ARRAY;
1512 type = g_param_type_register_static (g_intern_static_string ("GParamValueArray"), &pspec_info);
1513 *spec_types++ = type;
1514 g_assert (type == G_TYPE_PARAM_VALUE_ARRAY);
1515 }
1516
1517 /* G_TYPE_PARAM_OBJECT
1518 */
1519 {
1520 static const GParamSpecTypeInfo pspec_info = {
1521 sizeof (GParamSpecObject), /* instance_size */
1522 16, /* n_preallocs */
1523 param_object_init, /* instance_init */
1524 G_TYPE_OBJECT, /* value_type */
1525 NULL, /* finalize */
1526 param_object_set_default, /* value_set_default */
1527 param_object_validate, /* value_validate */
1528 param_object_values_cmp, /* values_cmp */
1529 };
1530 type = g_param_type_register_static (g_intern_static_string ("GParamObject"), &pspec_info);
1531 *spec_types++ = type;
1532 g_assert (type == G_TYPE_PARAM_OBJECT);
1533 }
1534
1535 /* G_TYPE_PARAM_OVERRIDE
1536 */
1537 {
1538 static const GParamSpecTypeInfo pspec_info = {
1539 sizeof (GParamSpecOverride), /* instance_size */
1540 16, /* n_preallocs */
1541 param_override_init, /* instance_init */
1542 G_TYPE_NONE, /* value_type */
1543 param_override_finalize, /* finalize */
1544 param_override_set_default, /* value_set_default */
1545 param_override_validate, /* value_validate */
1546 param_override_values_cmp, /* values_cmp */
1547 };
1548 type = g_param_type_register_static (g_intern_static_string ("GParamOverride"), &pspec_info);
1549 *spec_types++ = type;
1550 g_assert (type == G_TYPE_PARAM_OVERRIDE);
1551 }
1552
1553 /* G_TYPE_PARAM_GTYPE
1554 */
1555 {
1556 GParamSpecTypeInfo pspec_info = {
1557 sizeof (GParamSpecGType), /* instance_size */
1558 0, /* n_preallocs */
1559 param_gtype_init, /* instance_init */
1560 0xdeadbeef, /* value_type, assigned further down */
1561 NULL, /* finalize */
1562 param_gtype_set_default, /* value_set_default */
1563 param_gtype_validate, /* value_validate */
1564 param_gtype_values_cmp, /* values_cmp */
1565 };
1566 pspec_info.value_type = G_TYPE_GTYPE;
1567 type = g_param_type_register_static (g_intern_static_string ("GParamGType"), &pspec_info);
1568 *spec_types++ = type;
1569 g_assert (type == G_TYPE_PARAM_GTYPE);
1570 }
1571
1572 /* G_TYPE_PARAM_VARIANT
1573 */
1574 {
1575 const GParamSpecTypeInfo pspec_info = {
1576 sizeof (GParamSpecVariant), /* instance_size */
1577 0, /* n_preallocs */
1578 param_variant_init, /* instance_init */
1579 G_TYPE_VARIANT, /* value_type */
1580 param_variant_finalize, /* finalize */
1581 param_variant_set_default, /* value_set_default */
1582 param_variant_validate, /* value_validate */
1583 param_variant_values_cmp, /* values_cmp */
1584 };
1585 type = g_param_type_register_static (g_intern_static_string ("GParamVariant"), &pspec_info);
1586 *spec_types++ = type;
1587 g_assert (type == G_TYPE_PARAM_VARIANT);
1588 }
1589
1590 g_assert (spec_types == spec_types_bound);
1591 }
1592
1593 /* --- GParamSpec initialization --- */
1594
1595 /**
1596 * g_param_spec_char:
1597 * @name: canonical name of the property specified
1598 * @nick: nick name for the property specified
1599 * @blurb: description of the property specified
1600 * @minimum: minimum value for the property specified
1601 * @maximum: maximum value for the property specified
1602 * @default_value: default value for the property specified
1603 * @flags: flags for the property specified
1604 *
1605 * Creates a new #GParamSpecChar instance specifying a %G_TYPE_CHAR property.
1606 *
1607 * Returns: (transfer full): a newly created parameter specification
1608 */
1609 GParamSpec*
1610 g_param_spec_char (const gchar *name,
1611 const gchar *nick,
1612 const gchar *blurb,
1613 gint8 minimum,
1614 gint8 maximum,
1615 gint8 default_value,
1616 GParamFlags flags)
1617 {
1618 GParamSpecChar *cspec;
1619
1620 g_return_val_if_fail (default_value >= minimum && default_value <= maximum, NULL);
1621
1622 cspec = g_param_spec_internal (G_TYPE_PARAM_CHAR,
1623 name,
1624 nick,
1625 blurb,
1626 flags);
1627 if (cspec == NULL)
1628 return NULL;
1629
1630 cspec->minimum = minimum;
1631 cspec->maximum = maximum;
1632 cspec->default_value = default_value;
1633
1634 return G_PARAM_SPEC (cspec);
1635 }
1636
1637 /**
1638 * g_param_spec_uchar:
1639 * @name: canonical name of the property specified
1640 * @nick: nick name for the property specified
1641 * @blurb: description of the property specified
1642 * @minimum: minimum value for the property specified
1643 * @maximum: maximum value for the property specified
1644 * @default_value: default value for the property specified
1645 * @flags: flags for the property specified
1646 *
1647 * Creates a new #GParamSpecUChar instance specifying a %G_TYPE_UCHAR property.
1648 *
1649 * Returns: (transfer full): a newly created parameter specification
1650 */
1651 GParamSpec*
1652 g_param_spec_uchar (const gchar *name,
1653 const gchar *nick,
1654 const gchar *blurb,
1655 guint8 minimum,
1656 guint8 maximum,
1657 guint8 default_value,
1658 GParamFlags flags)
1659 {
1660 GParamSpecUChar *uspec;
1661
1662 g_return_val_if_fail (default_value >= minimum && default_value <= maximum, NULL);
1663
1664 uspec = g_param_spec_internal (G_TYPE_PARAM_UCHAR,
1665 name,
1666 nick,
1667 blurb,
1668 flags);
1669 if (uspec == NULL)
1670 return NULL;
1671
1672 uspec->minimum = minimum;
1673 uspec->maximum = maximum;
1674 uspec->default_value = default_value;
1675
1676 return G_PARAM_SPEC (uspec);
1677 }
1678
1679 /**
1680 * g_param_spec_boolean:
1681 * @name: canonical name of the property specified
1682 * @nick: nick name for the property specified
1683 * @blurb: description of the property specified
1684 * @default_value: default value for the property specified
1685 * @flags: flags for the property specified
1686 *
1687 * Creates a new #GParamSpecBoolean instance specifying a %G_TYPE_BOOLEAN
1688 * property.
1689 *
1690 * See g_param_spec_internal() for details on property names.
1691 *
1692 * Returns: (transfer full): a newly created parameter specification
1693 */
1694 GParamSpec*
1695 g_param_spec_boolean (const gchar *name,
1696 const gchar *nick,
1697 const gchar *blurb,
1698 gboolean default_value,
1699 GParamFlags flags)
1700 {
1701 GParamSpecBoolean *bspec;
1702
1703 g_return_val_if_fail (default_value == TRUE || default_value == FALSE, NULL);
1704
1705 bspec = g_param_spec_internal (G_TYPE_PARAM_BOOLEAN,
1706 name,
1707 nick,
1708 blurb,
1709 flags);
1710 if (bspec == NULL)
1711 return NULL;
1712
1713 bspec->default_value = default_value;
1714
1715 return G_PARAM_SPEC (bspec);
1716 }
1717
1718 /**
1719 * g_param_spec_int:
1720 * @name: canonical name of the property specified
1721 * @nick: nick name for the property specified
1722 * @blurb: description of the property specified
1723 * @minimum: minimum value for the property specified
1724 * @maximum: maximum value for the property specified
1725 * @default_value: default value for the property specified
1726 * @flags: flags for the property specified
1727 *
1728 * Creates a new #GParamSpecInt instance specifying a %G_TYPE_INT property.
1729 *
1730 * See g_param_spec_internal() for details on property names.
1731 *
1732 * Returns: (transfer full): a newly created parameter specification
1733 */
1734 GParamSpec*
1735 g_param_spec_int (const gchar *name,
1736 const gchar *nick,
1737 const gchar *blurb,
1738 gint minimum,
1739 gint maximum,
1740 gint default_value,
1741 GParamFlags flags)
1742 {
1743 GParamSpecInt *ispec;
1744
1745 g_return_val_if_fail (default_value >= minimum && default_value <= maximum, NULL);
1746
1747 ispec = g_param_spec_internal (G_TYPE_PARAM_INT,
1748 name,
1749 nick,
1750 blurb,
1751 flags);
1752 if (ispec == NULL)
1753 return NULL;
1754
1755 ispec->minimum = minimum;
1756 ispec->maximum = maximum;
1757 ispec->default_value = default_value;
1758
1759 return G_PARAM_SPEC (ispec);
1760 }
1761
1762 /**
1763 * g_param_spec_uint:
1764 * @name: canonical name of the property specified
1765 * @nick: nick name for the property specified
1766 * @blurb: description of the property specified
1767 * @minimum: minimum value for the property specified
1768 * @maximum: maximum value for the property specified
1769 * @default_value: default value for the property specified
1770 * @flags: flags for the property specified
1771 *
1772 * Creates a new #GParamSpecUInt instance specifying a %G_TYPE_UINT property.
1773 *
1774 * See g_param_spec_internal() for details on property names.
1775 *
1776 * Returns: (transfer full): a newly created parameter specification
1777 */
1778 GParamSpec*
1779 g_param_spec_uint (const gchar *name,
1780 const gchar *nick,
1781 const gchar *blurb,
1782 guint minimum,
1783 guint maximum,
1784 guint default_value,
1785 GParamFlags flags)
1786 {
1787 GParamSpecUInt *uspec;
1788
1789 g_return_val_if_fail (default_value >= minimum && default_value <= maximum, NULL);
1790
1791 uspec = g_param_spec_internal (G_TYPE_PARAM_UINT,
1792 name,
1793 nick,
1794 blurb,
1795 flags);
1796 if (uspec == NULL)
1797 return NULL;
1798
1799 uspec->minimum = minimum;
1800 uspec->maximum = maximum;
1801 uspec->default_value = default_value;
1802
1803 return G_PARAM_SPEC (uspec);
1804 }
1805
1806 /**
1807 * g_param_spec_long:
1808 * @name: canonical name of the property specified
1809 * @nick: nick name for the property specified
1810 * @blurb: description of the property specified
1811 * @minimum: minimum value for the property specified
1812 * @maximum: maximum value for the property specified
1813 * @default_value: default value for the property specified
1814 * @flags: flags for the property specified
1815 *
1816 * Creates a new #GParamSpecLong instance specifying a %G_TYPE_LONG property.
1817 *
1818 * See g_param_spec_internal() for details on property names.
1819 *
1820 * Returns: (transfer full): a newly created parameter specification
1821 */
1822 GParamSpec*
1823 g_param_spec_long (const gchar *name,
1824 const gchar *nick,
1825 const gchar *blurb,
1826 glong minimum,
1827 glong maximum,
1828 glong default_value,
1829 GParamFlags flags)
1830 {
1831 GParamSpecLong *lspec;
1832
1833 g_return_val_if_fail (default_value >= minimum && default_value <= maximum, NULL);
1834
1835 lspec = g_param_spec_internal (G_TYPE_PARAM_LONG,
1836 name,
1837 nick,
1838 blurb,
1839 flags);
1840 if (lspec == NULL)
1841 return NULL;
1842
1843 lspec->minimum = minimum;
1844 lspec->maximum = maximum;
1845 lspec->default_value = default_value;
1846
1847 return G_PARAM_SPEC (lspec);
1848 }
1849
1850 /**
1851 * g_param_spec_ulong:
1852 * @name: canonical name of the property specified
1853 * @nick: nick name for the property specified
1854 * @blurb: description of the property specified
1855 * @minimum: minimum value for the property specified
1856 * @maximum: maximum value for the property specified
1857 * @default_value: default value for the property specified
1858 * @flags: flags for the property specified
1859 *
1860 * Creates a new #GParamSpecULong instance specifying a %G_TYPE_ULONG
1861 * property.
1862 *
1863 * See g_param_spec_internal() for details on property names.
1864 *
1865 * Returns: (transfer full): a newly created parameter specification
1866 */
1867 GParamSpec*
1868 g_param_spec_ulong (const gchar *name,
1869 const gchar *nick,
1870 const gchar *blurb,
1871 gulong minimum,
1872 gulong maximum,
1873 gulong default_value,
1874 GParamFlags flags)
1875 {
1876 GParamSpecULong *uspec;
1877
1878 g_return_val_if_fail (default_value >= minimum && default_value <= maximum, NULL);
1879
1880 uspec = g_param_spec_internal (G_TYPE_PARAM_ULONG,
1881 name,
1882 nick,
1883 blurb,
1884 flags);
1885 if (uspec == NULL)
1886 return NULL;
1887
1888 uspec->minimum = minimum;
1889 uspec->maximum = maximum;
1890 uspec->default_value = default_value;
1891
1892 return G_PARAM_SPEC (uspec);
1893 }
1894
1895 /**
1896 * g_param_spec_int64:
1897 * @name: canonical name of the property specified
1898 * @nick: nick name for the property specified
1899 * @blurb: description of the property specified
1900 * @minimum: minimum value for the property specified
1901 * @maximum: maximum value for the property specified
1902 * @default_value: default value for the property specified
1903 * @flags: flags for the property specified
1904 *
1905 * Creates a new #GParamSpecInt64 instance specifying a %G_TYPE_INT64 property.
1906 *
1907 * See g_param_spec_internal() for details on property names.
1908 *
1909 * Returns: (transfer full): a newly created parameter specification
1910 */
1911 GParamSpec*
1912 g_param_spec_int64 (const gchar *name,
1913 const gchar *nick,
1914 const gchar *blurb,
1915 gint64 minimum,
1916 gint64 maximum,
1917 gint64 default_value,
1918 GParamFlags flags)
1919 {
1920 GParamSpecInt64 *lspec;
1921
1922 g_return_val_if_fail (default_value >= minimum && default_value <= maximum, NULL);
1923
1924 lspec = g_param_spec_internal (G_TYPE_PARAM_INT64,
1925 name,
1926 nick,
1927 blurb,
1928 flags);
1929 if (lspec == NULL)
1930 return NULL;
1931
1932 lspec->minimum = minimum;
1933 lspec->maximum = maximum;
1934 lspec->default_value = default_value;
1935
1936 return G_PARAM_SPEC (lspec);
1937 }
1938
1939 /**
1940 * g_param_spec_uint64:
1941 * @name: canonical name of the property specified
1942 * @nick: nick name for the property specified
1943 * @blurb: description of the property specified
1944 * @minimum: minimum value for the property specified
1945 * @maximum: maximum value for the property specified
1946 * @default_value: default value for the property specified
1947 * @flags: flags for the property specified
1948 *
1949 * Creates a new #GParamSpecUInt64 instance specifying a %G_TYPE_UINT64
1950 * property.
1951 *
1952 * See g_param_spec_internal() for details on property names.
1953 *
1954 * Returns: (transfer full): a newly created parameter specification
1955 */
1956 GParamSpec*
1957 g_param_spec_uint64 (const gchar *name,
1958 const gchar *nick,
1959 const gchar *blurb,
1960 guint64 minimum,
1961 guint64 maximum,
1962 guint64 default_value,
1963 GParamFlags flags)
1964 {
1965 GParamSpecUInt64 *uspec;
1966
1967 g_return_val_if_fail (default_value >= minimum && default_value <= maximum, NULL);
1968
1969 uspec = g_param_spec_internal (G_TYPE_PARAM_UINT64,
1970 name,
1971 nick,
1972 blurb,
1973 flags);
1974 if (uspec == NULL)
1975 return NULL;
1976
1977 uspec->minimum = minimum;
1978 uspec->maximum = maximum;
1979 uspec->default_value = default_value;
1980
1981 return G_PARAM_SPEC (uspec);
1982 }
1983
1984 /**
1985 * g_param_spec_unichar:
1986 * @name: canonical name of the property specified
1987 * @nick: nick name for the property specified
1988 * @blurb: description of the property specified
1989 * @default_value: default value for the property specified
1990 * @flags: flags for the property specified
1991 *
1992 * Creates a new #GParamSpecUnichar instance specifying a %G_TYPE_UINT
1993 * property. #GValue structures for this property can be accessed with
1994 * g_value_set_uint() and g_value_get_uint().
1995 *
1996 * See g_param_spec_internal() for details on property names.
1997 *
1998 * Returns: (transfer full): a newly created parameter specification
1999 */
2000 GParamSpec*
2001 g_param_spec_unichar (const gchar *name,
2002 const gchar *nick,
2003 const gchar *blurb,
2004 gunichar default_value,
2005 GParamFlags flags)
2006 {
2007 GParamSpecUnichar *uspec;
2008
2009 uspec = g_param_spec_internal (G_TYPE_PARAM_UNICHAR,
2010 name,
2011 nick,
2012 blurb,
2013 flags);
2014 if (uspec == NULL)
2015 return NULL;
2016
2017 uspec->default_value = default_value;
2018
2019 return G_PARAM_SPEC (uspec);
2020 }
2021
2022 /**
2023 * g_param_spec_enum:
2024 * @name: canonical name of the property specified
2025 * @nick: nick name for the property specified
2026 * @blurb: description of the property specified
2027 * @enum_type: a #GType derived from %G_TYPE_ENUM
2028 * @default_value: default value for the property specified
2029 * @flags: flags for the property specified
2030 *
2031 * Creates a new #GParamSpecEnum instance specifying a %G_TYPE_ENUM
2032 * property.
2033 *
2034 * See g_param_spec_internal() for details on property names.
2035 *
2036 * Returns: (transfer full): a newly created parameter specification
2037 */
2038 GParamSpec*
2039 g_param_spec_enum (const gchar *name,
2040 const gchar *nick,
2041 const gchar *blurb,
2042 GType enum_type,
2043 gint default_value,
2044 GParamFlags flags)
2045 {
2046 GParamSpecEnum *espec;
2047 GEnumClass *enum_class;
2048
2049 g_return_val_if_fail (G_TYPE_IS_ENUM (enum_type), NULL);
2050
2051 enum_class = g_type_class_ref (enum_type);
2052
2053 g_return_val_if_fail (g_enum_get_value (enum_class, default_value) != NULL, NULL);
2054
2055 espec = g_param_spec_internal (G_TYPE_PARAM_ENUM,
2056 name,
2057 nick,
2058 blurb,
2059 flags);
2060 if (espec == NULL)
2061 return NULL;
2062
2063 espec->enum_class = enum_class;
2064 espec->default_value = default_value;
2065 G_PARAM_SPEC (espec)->value_type = enum_type;
2066
2067 return G_PARAM_SPEC (espec);
2068 }
2069
2070 /**
2071 * g_param_spec_flags:
2072 * @name: canonical name of the property specified
2073 * @nick: nick name for the property specified
2074 * @blurb: description of the property specified
2075 * @flags_type: a #GType derived from %G_TYPE_FLAGS
2076 * @default_value: default value for the property specified
2077 * @flags: flags for the property specified
2078 *
2079 * Creates a new #GParamSpecFlags instance specifying a %G_TYPE_FLAGS
2080 * property.
2081 *
2082 * See g_param_spec_internal() for details on property names.
2083 *
2084 * Returns: (transfer full): a newly created parameter specification
2085 */
2086 GParamSpec*
2087 g_param_spec_flags (const gchar *name,
2088 const gchar *nick,
2089 const gchar *blurb,
2090 GType flags_type,
2091 guint default_value,
2092 GParamFlags flags)
2093 {
2094 GParamSpecFlags *fspec;
2095 GFlagsClass *flags_class;
2096
2097 g_return_val_if_fail (G_TYPE_IS_FLAGS (flags_type), NULL);
2098
2099 flags_class = g_type_class_ref (flags_type);
2100
2101 g_return_val_if_fail ((default_value & flags_class->mask) == default_value, NULL);
2102
2103 fspec = g_param_spec_internal (G_TYPE_PARAM_FLAGS,
2104 name,
2105 nick,
2106 blurb,
2107 flags);
2108 if (fspec == NULL)
2109 return NULL;
2110
2111 fspec->flags_class = flags_class;
2112 fspec->default_value = default_value;
2113 G_PARAM_SPEC (fspec)->value_type = flags_type;
2114
2115 return G_PARAM_SPEC (fspec);
2116 }
2117
2118 /**
2119 * g_param_spec_float:
2120 * @name: canonical name of the property specified
2121 * @nick: nick name for the property specified
2122 * @blurb: description of the property specified
2123 * @minimum: minimum value for the property specified
2124 * @maximum: maximum value for the property specified
2125 * @default_value: default value for the property specified
2126 * @flags: flags for the property specified
2127 *
2128 * Creates a new #GParamSpecFloat instance specifying a %G_TYPE_FLOAT property.
2129 *
2130 * See g_param_spec_internal() for details on property names.
2131 *
2132 * Returns: (transfer full): a newly created parameter specification
2133 */
2134 GParamSpec*
2135 g_param_spec_float (const gchar *name,
2136 const gchar *nick,
2137 const gchar *blurb,
2138 gfloat minimum,
2139 gfloat maximum,
2140 gfloat default_value,
2141 GParamFlags flags)
2142 {
2143 GParamSpecFloat *fspec;
2144
2145 g_return_val_if_fail (default_value >= minimum && default_value <= maximum, NULL);
2146
2147 fspec = g_param_spec_internal (G_TYPE_PARAM_FLOAT,
2148 name,
2149 nick,
2150 blurb,
2151 flags);
2152 if (fspec == NULL)
2153 return NULL;
2154
2155 fspec->minimum = minimum;
2156 fspec->maximum = maximum;
2157 fspec->default_value = default_value;
2158
2159 return G_PARAM_SPEC (fspec);
2160 }
2161
2162 /**
2163 * g_param_spec_double:
2164 * @name: canonical name of the property specified
2165 * @nick: nick name for the property specified
2166 * @blurb: description of the property specified
2167 * @minimum: minimum value for the property specified
2168 * @maximum: maximum value for the property specified
2169 * @default_value: default value for the property specified
2170 * @flags: flags for the property specified
2171 *
2172 * Creates a new #GParamSpecDouble instance specifying a %G_TYPE_DOUBLE
2173 * property.
2174 *
2175 * See g_param_spec_internal() for details on property names.
2176 *
2177 * Returns: (transfer full): a newly created parameter specification
2178 */
2179 GParamSpec*
2180 g_param_spec_double (const gchar *name,
2181 const gchar *nick,
2182 const gchar *blurb,
2183 gdouble minimum,
2184 gdouble maximum,
2185 gdouble default_value,
2186 GParamFlags flags)
2187 {
2188 GParamSpecDouble *dspec;
2189
2190 g_return_val_if_fail (default_value >= minimum && default_value <= maximum, NULL);
2191
2192 dspec = g_param_spec_internal (G_TYPE_PARAM_DOUBLE,
2193 name,
2194 nick,
2195 blurb,
2196 flags);
2197 if (dspec == NULL)
2198 return NULL;
2199
2200 dspec->minimum = minimum;
2201 dspec->maximum = maximum;
2202 dspec->default_value = default_value;
2203
2204 return G_PARAM_SPEC (dspec);
2205 }
2206
2207 /**
2208 * g_param_spec_string:
2209 * @name: canonical name of the property specified
2210 * @nick: nick name for the property specified
2211 * @blurb: description of the property specified
2212 * @default_value: default value for the property specified
2213 * @flags: flags for the property specified
2214 *
2215 * Creates a new #GParamSpecString instance.
2216 *
2217 * See g_param_spec_internal() for details on property names.
2218 *
2219 * Returns: (transfer full): a newly created parameter specification
2220 */
2221 GParamSpec*
2222 g_param_spec_string (const gchar *name,
2223 const gchar *nick,
2224 const gchar *blurb,
2225 const gchar *default_value,
2226 GParamFlags flags)
2227 {
2228 GParamSpecString *sspec = g_param_spec_internal (G_TYPE_PARAM_STRING,
2229 name,
2230 nick,
2231 blurb,
2232 flags);
2233 if (sspec == NULL)
2234 return NULL;
2235
2236 g_free (sspec->default_value);
2237 sspec->default_value = g_strdup (default_value);
2238
2239 return G_PARAM_SPEC (sspec);
2240 }
2241
2242 /**
2243 * g_param_spec_param:
2244 * @name: canonical name of the property specified
2245 * @nick: nick name for the property specified
2246 * @blurb: description of the property specified
2247 * @param_type: a #GType derived from %G_TYPE_PARAM
2248 * @flags: flags for the property specified
2249 *
2250 * Creates a new #GParamSpecParam instance specifying a %G_TYPE_PARAM
2251 * property.
2252 *
2253 * See g_param_spec_internal() for details on property names.
2254 *
2255 * Returns: (transfer full): a newly created parameter specification
2256 */
2257 GParamSpec*
2258 g_param_spec_param (const gchar *name,
2259 const gchar *nick,
2260 const gchar *blurb,
2261 GType param_type,
2262 GParamFlags flags)
2263 {
2264 GParamSpecParam *pspec;
2265
2266 g_return_val_if_fail (G_TYPE_IS_PARAM (param_type), NULL);
2267
2268 pspec = g_param_spec_internal (G_TYPE_PARAM_PARAM,
2269 name,
2270 nick,
2271 blurb,
2272 flags);
2273 if (pspec == NULL)
2274 return NULL;
2275
2276 G_PARAM_SPEC (pspec)->value_type = param_type;
2277
2278 return G_PARAM_SPEC (pspec);
2279 }
2280
2281 /**
2282 * g_param_spec_boxed:
2283 * @name: canonical name of the property specified
2284 * @nick: nick name for the property specified
2285 * @blurb: description of the property specified
2286 * @boxed_type: %G_TYPE_BOXED derived type of this property
2287 * @flags: flags for the property specified
2288 *
2289 * Creates a new #GParamSpecBoxed instance specifying a %G_TYPE_BOXED
2290 * derived property.
2291 *
2292 * See g_param_spec_internal() for details on property names.
2293 *
2294 * Returns: (transfer full): a newly created parameter specification
2295 */
2296 GParamSpec*
2297 g_param_spec_boxed (const gchar *name,
2298 const gchar *nick,
2299 const gchar *blurb,
2300 GType boxed_type,
2301 GParamFlags flags)
2302 {
2303 GParamSpecBoxed *bspec;
2304
2305 g_return_val_if_fail (G_TYPE_IS_BOXED (boxed_type), NULL);
2306 g_return_val_if_fail (G_TYPE_IS_VALUE_TYPE (boxed_type), NULL);
2307
2308 bspec = g_param_spec_internal (G_TYPE_PARAM_BOXED,
2309 name,
2310 nick,
2311 blurb,
2312 flags);
2313 if (bspec == NULL)
2314 return NULL;
2315
2316 G_PARAM_SPEC (bspec)->value_type = boxed_type;
2317
2318 return G_PARAM_SPEC (bspec);
2319 }
2320
2321 /**
2322 * g_param_spec_pointer:
2323 * @name: canonical name of the property specified
2324 * @nick: nick name for the property specified
2325 * @blurb: description of the property specified
2326 * @flags: flags for the property specified
2327 *
2328 * Creates a new #GParamSpecPointer instance specifying a pointer property.
2329 *
2330 * See g_param_spec_internal() for details on property names.
2331 *
2332 * Returns: (transfer full): a newly created parameter specification
2333 */
2334 GParamSpec*
2335 g_param_spec_pointer (const gchar *name,
2336 const gchar *nick,
2337 const gchar *blurb,
2338 GParamFlags flags)
2339 {
2340 GParamSpecPointer *pspec;
2341
2342 pspec = g_param_spec_internal (G_TYPE_PARAM_POINTER,
2343 name,
2344 nick,
2345 blurb,
2346 flags);
2347 if (pspec == NULL)
2348 return NULL;
2349
2350 return G_PARAM_SPEC (pspec);
2351 }
2352
2353 /**
2354 * g_param_spec_gtype:
2355 * @name: canonical name of the property specified
2356 * @nick: nick name for the property specified
2357 * @blurb: description of the property specified
2358 * @is_a_type: a #GType whose subtypes are allowed as values
2359 * of the property (use %G_TYPE_NONE for any type)
2360 * @flags: flags for the property specified
2361 *
2362 * Creates a new #GParamSpecGType instance specifying a
2363 * %G_TYPE_GTYPE property.
2364 *
2365 * See g_param_spec_internal() for details on property names.
2366 *
2367 * Since: 2.10
2368 *
2369 * Returns: (transfer full): a newly created parameter specification
2370 */
2371 GParamSpec*
2372 g_param_spec_gtype (const gchar *name,
2373 const gchar *nick,
2374 const gchar *blurb,
2375 GType is_a_type,
2376 GParamFlags flags)
2377 {
2378 GParamSpecGType *tspec;
2379
2380 tspec = g_param_spec_internal (G_TYPE_PARAM_GTYPE,
2381 name,
2382 nick,
2383 blurb,
2384 flags);
2385 if (tspec == NULL)
2386 return NULL;
2387
2388 tspec->is_a_type = is_a_type;
2389
2390 return G_PARAM_SPEC (tspec);
2391 }
2392
2393 /**
2394 * g_param_spec_value_array: (skip)
2395 * @name: canonical name of the property specified
2396 * @nick: nick name for the property specified
2397 * @blurb: description of the property specified
2398 * @element_spec: a #GParamSpec describing the elements contained in
2399 * arrays of this property, may be %NULL
2400 * @flags: flags for the property specified
2401 *
2402 * Creates a new #GParamSpecValueArray instance specifying a
2403 * %G_TYPE_VALUE_ARRAY property. %G_TYPE_VALUE_ARRAY is a
2404 * %G_TYPE_BOXED type, as such, #GValue structures for this property
2405 * can be accessed with g_value_set_boxed() and g_value_get_boxed().
2406 *
2407 * See g_param_spec_internal() for details on property names.
2408 *
2409 * Returns: a newly created parameter specification
2410 */
2411 GParamSpec*
2412 g_param_spec_value_array (const gchar *name,
2413 const gchar *nick,
2414 const gchar *blurb,
2415 GParamSpec *element_spec,
2416 GParamFlags flags)
2417 {
2418 GParamSpecValueArray *aspec;
2419
2420 if (element_spec)
2421 g_return_val_if_fail (G_IS_PARAM_SPEC (element_spec), NULL);
2422
2423 aspec = g_param_spec_internal (G_TYPE_PARAM_VALUE_ARRAY,
2424 name,
2425 nick,
2426 blurb,
2427 flags);
2428 if (aspec == NULL)
2429 return NULL;
2430
2431 if (element_spec)
2432 {
2433 aspec->element_spec = g_param_spec_ref (element_spec);
2434 g_param_spec_sink (element_spec);
2435 }
2436
2437 return G_PARAM_SPEC (aspec);
2438 }
2439
2440 /**
2441 * g_param_spec_object:
2442 * @name: canonical name of the property specified
2443 * @nick: nick name for the property specified
2444 * @blurb: description of the property specified
2445 * @object_type: %G_TYPE_OBJECT derived type of this property
2446 * @flags: flags for the property specified
2447 *
2448 * Creates a new #GParamSpecBoxed instance specifying a %G_TYPE_OBJECT
2449 * derived property.
2450 *
2451 * See g_param_spec_internal() for details on property names.
2452 *
2453 * Returns: (transfer full): a newly created parameter specification
2454 */
2455 GParamSpec*
2456 g_param_spec_object (const gchar *name,
2457 const gchar *nick,
2458 const gchar *blurb,
2459 GType object_type,
2460 GParamFlags flags)
2461 {
2462 GParamSpecObject *ospec;
2463
2464 g_return_val_if_fail (g_type_is_a (object_type, G_TYPE_OBJECT), NULL);
2465
2466 ospec = g_param_spec_internal (G_TYPE_PARAM_OBJECT,
2467 name,
2468 nick,
2469 blurb,
2470 flags);
2471 if (ospec == NULL)
2472 return NULL;
2473
2474 G_PARAM_SPEC (ospec)->value_type = object_type;
2475
2476 return G_PARAM_SPEC (ospec);
2477 }
2478
2479 /**
2480 * g_param_spec_override: (skip)
2481 * @name: the name of the property.
2482 * @overridden: The property that is being overridden
2483 *
2484 * Creates a new property of type #GParamSpecOverride. This is used
2485 * to direct operations to another paramspec, and will not be directly
2486 * useful unless you are implementing a new base type similar to GObject.
2487 *
2488 * Since: 2.4
2489 *
2490 * Returns: the newly created #GParamSpec
2491 */
2492 GParamSpec*
2493 g_param_spec_override (const gchar *name,
2494 GParamSpec *overridden)
2495 {
2496 GParamSpec *pspec;
2497
2498 g_return_val_if_fail (name != NULL, NULL);
2499 g_return_val_if_fail (G_IS_PARAM_SPEC (overridden), NULL);
2500
2501 /* Dereference further redirections for property that was passed in
2502 */
2503 while (TRUE)
2504 {
2505 GParamSpec *indirect = g_param_spec_get_redirect_target (overridden);
2506 if (indirect)
2507 overridden = indirect;
2508 else
2509 break;
2510 }
2511
2512 pspec = g_param_spec_internal (G_TYPE_PARAM_OVERRIDE,
2513 name, NULL, NULL,
2514 overridden->flags);
2515 if (pspec == NULL)
2516 return NULL;
2517
2518 pspec->value_type = G_PARAM_SPEC_VALUE_TYPE (overridden);
2519 G_PARAM_SPEC_OVERRIDE (pspec)->overridden = g_param_spec_ref (overridden);
2520
2521 return pspec;
2522 }
2523
2524 /**
2525 * g_param_spec_variant:
2526 * @name: canonical name of the property specified
2527 * @nick: nick name for the property specified
2528 * @blurb: description of the property specified
2529 * @type: a #GVariantType
2530 * @default_value: (allow-none) (transfer full): a #GVariant of type @type to
2531 * use as the default value, or %NULL
2532 * @flags: flags for the property specified
2533 *
2534 * Creates a new #GParamSpecVariant instance specifying a #GVariant
2535 * property.
2536 *
2537 * If @default_value is floating, it is consumed.
2538 *
2539 * See g_param_spec_internal() for details on property names.
2540 *
2541 * Returns: (transfer full): the newly created #GParamSpec
2542 *
2543 * Since: 2.26
2544 */
2545 GParamSpec*
2546 g_param_spec_variant (const gchar *name,
2547 const gchar *nick,
2548 const gchar *blurb,
2549 const GVariantType *type,
2550 GVariant *default_value,
2551 GParamFlags flags)
2552 {
2553 GParamSpecVariant *vspec;
2554
2555 g_return_val_if_fail (type != NULL, NULL);
2556 g_return_val_if_fail (default_value == NULL ||
2557 g_variant_is_of_type (default_value, type), NULL);
2558
2559 vspec = g_param_spec_internal (G_TYPE_PARAM_VARIANT,
2560 name,
2561 nick,
2562 blurb,
2563 flags);
2564 if (vspec == NULL)
2565 return NULL;
2566
2567 vspec->type = g_variant_type_copy (type);
2568 if (default_value)
2569 vspec->default_value = g_variant_ref_sink (default_value);
2570
2571 return G_PARAM_SPEC (vspec);
2572 }
glib mirror