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