gobject/gparamspecs.c

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