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