Symaptic: os/ossrv/glib/gobject/gparamspecs.c@260cb5ec6c19 (annotated)

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

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200
changeset 1	260cb5ec6c19
permissions	-rw-r--r--