gtype.h source code [include/glib-2.0/gobject/gtype.h]

1	/ GObject - GLib Type, Object, Parameter and Signal Library*
2	* Copyright (C) 1998-1999, 2000-2001 Tim Janik and Red Hat, Inc.
3	*
4	* SPDX-License-Identifier: LGPL-2.1-or-later
5	*
6	* This library is free software; you can redistribute it and/or
7	* modify it under the terms of the GNU Lesser General Public
8	* License as published by the Free Software Foundation; either
9	* version 2.1 of the License, or (at your option) any later version.
10	*
11	* This library is distributed in the hope that it will be useful,
12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14	* Lesser General Public License for more details.
15	*
16	* You should have received a copy of the GNU Lesser General
17	* Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
18	*/
19	#ifndef __G_TYPE_H__
20	#define __G_TYPE_H__
21
22	#if !defined (__GLIB_GOBJECT_H_INSIDE__) && !defined (GOBJECT_COMPILATION)
23	#error "Only <glib-object.h> can be included directly."
24	#endif
25
26	#include <glib.h>
27	#include <gobject/gobject-visibility.h>
28
29	G_BEGIN_DECLS
30
31	/ Basic Type Macros*
32	*/
33	/**
34	* G_TYPE_FUNDAMENTAL:
35	* @type: A #GType value.
36	*
37	* The fundamental type which is the ancestor of @type.
38	*
39	* Fundamental types are types that serve as ultimate bases for the derived types,
40	* thus they are the roots of distinct inheritance hierarchies.
41	*/
42	#define G_TYPE_FUNDAMENTAL(type) (g_type_fundamental (type))
43	/**
44	* G_TYPE_FUNDAMENTAL_SHIFT:
45	*
46	* Shift value used in converting numbers to type IDs.
47	*/
48	#define G_TYPE_FUNDAMENTAL_SHIFT (2)
49	/**
50	* G_TYPE_FUNDAMENTAL_MAX: (value 1020)
51	*
52	* An integer constant that represents the number of identifiers reserved
53	* for types that are assigned at compile-time.
54	*/
55	#define G_TYPE_FUNDAMENTAL_MAX (255 << G_TYPE_FUNDAMENTAL_SHIFT)
56
57	/ Constant fundamental types,*
58	*/
59	/**
60	* G_TYPE_INVALID:
61	*
62	* An invalid #GType used as error return value in some functions which return
63	* a #GType.
64	*/
65	#define G_TYPE_INVALID G_TYPE_MAKE_FUNDAMENTAL (0)
66	/**
67	* G_TYPE_NONE:
68	*
69	* A fundamental type which is used as a replacement for the C
70	* void return type.
71	*/
72	#define G_TYPE_NONE G_TYPE_MAKE_FUNDAMENTAL (1)
73	/**
74	* G_TYPE_INTERFACE:
75	*
76	* The fundamental type from which all interfaces are derived.
77	*/
78	#define G_TYPE_INTERFACE G_TYPE_MAKE_FUNDAMENTAL (2)
79	/**
80	* G_TYPE_CHAR:
81	*
82	* The fundamental type corresponding to #gchar.
83	*
84	* The type designated by %G_TYPE_CHAR is unconditionally an 8-bit signed integer.
85	* This may or may not be the same type a the C type "gchar".
86	*/
87	#define G_TYPE_CHAR G_TYPE_MAKE_FUNDAMENTAL (3)
88	/**
89	* G_TYPE_UCHAR:
90	*
91	* The fundamental type corresponding to #guchar.
92	*/
93	#define G_TYPE_UCHAR G_TYPE_MAKE_FUNDAMENTAL (4)
94	/**
95	* G_TYPE_BOOLEAN:
96	*
97	* The fundamental type corresponding to #gboolean.
98	*/
99	#define G_TYPE_BOOLEAN G_TYPE_MAKE_FUNDAMENTAL (5)
100	/**
101	* G_TYPE_INT:
102	*
103	* The fundamental type corresponding to #gint.
104	*/
105	#define G_TYPE_INT G_TYPE_MAKE_FUNDAMENTAL (6)
106	/**
107	* G_TYPE_UINT:
108	*
109	* The fundamental type corresponding to #guint.
110	*/
111	#define G_TYPE_UINT G_TYPE_MAKE_FUNDAMENTAL (7)
112	/**
113	* G_TYPE_LONG:
114	*
115	* The fundamental type corresponding to #glong.
116	*/
117	#define G_TYPE_LONG G_TYPE_MAKE_FUNDAMENTAL (8)
118	/**
119	* G_TYPE_ULONG:
120	*
121	* The fundamental type corresponding to #gulong.
122	*/
123	#define G_TYPE_ULONG G_TYPE_MAKE_FUNDAMENTAL (9)
124	/**
125	* G_TYPE_INT64:
126	*
127	* The fundamental type corresponding to #gint64.
128	*/
129	#define G_TYPE_INT64 G_TYPE_MAKE_FUNDAMENTAL (10)
130	/**
131	* G_TYPE_UINT64:
132	*
133	* The fundamental type corresponding to #guint64.
134	*/
135	#define G_TYPE_UINT64 G_TYPE_MAKE_FUNDAMENTAL (11)
136	/**
137	* G_TYPE_ENUM:
138	*
139	* The fundamental type from which all enumeration types are derived.
140	*/
141	#define G_TYPE_ENUM G_TYPE_MAKE_FUNDAMENTAL (12)
142	/**
143	* G_TYPE_FLAGS:
144	*
145	* The fundamental type from which all flags types are derived.
146	*/
147	#define G_TYPE_FLAGS G_TYPE_MAKE_FUNDAMENTAL (13)
148	/**
149	* G_TYPE_FLOAT:
150	*
151	* The fundamental type corresponding to #gfloat.
152	*/
153	#define G_TYPE_FLOAT G_TYPE_MAKE_FUNDAMENTAL (14)
154	/**
155	* G_TYPE_DOUBLE:
156	*
157	* The fundamental type corresponding to #gdouble.
158	*/
159	#define G_TYPE_DOUBLE G_TYPE_MAKE_FUNDAMENTAL (15)
160	/**
161	* G_TYPE_STRING:
162	*
163	* The fundamental type corresponding to nul-terminated C strings.
164	*/
165	#define G_TYPE_STRING G_TYPE_MAKE_FUNDAMENTAL (16)
166	/**
167	* G_TYPE_POINTER:
168	*
169	* The fundamental type corresponding to #gpointer.
170	*/
171	#define G_TYPE_POINTER G_TYPE_MAKE_FUNDAMENTAL (17)
172	/**
173	* G_TYPE_BOXED:
174	*
175	* The fundamental type from which all boxed types are derived.
176	*/
177	#define G_TYPE_BOXED G_TYPE_MAKE_FUNDAMENTAL (18)
178	/**
179	* G_TYPE_PARAM:
180	*
181	* The fundamental type from which all #GParamSpec types are derived.
182	*/
183	#define G_TYPE_PARAM G_TYPE_MAKE_FUNDAMENTAL (19)
184	/**
185	* G_TYPE_OBJECT:
186	*
187	* The fundamental type for #GObject.
188	*/
189	#define G_TYPE_OBJECT G_TYPE_MAKE_FUNDAMENTAL (20)
190	/**
191	* G_TYPE_VARIANT:
192	*
193	* The fundamental type corresponding to #GVariant.
194	*
195	* All floating #GVariant instances passed through the #GType system are
196	* consumed.
197	*
198	* Note that callbacks in closures, and signal handlers
199	* for signals of return type %G_TYPE_VARIANT, must never return floating
200	* variants.
201	*
202	* Note: GLib 2.24 did include a boxed type with this name. It was replaced
203	* with this fundamental type in 2.26.
204	*
205	* Since: 2.26
206	*/
207	#define G_TYPE_VARIANT G_TYPE_MAKE_FUNDAMENTAL (21)
208
209
210	/ Reserved fundamental type numbers to create new fundamental*
211	* type IDs with G_TYPE_MAKE_FUNDAMENTAL().
212	*
213	* Open an issue on https://gitlab.gnome.org/GNOME/glib/issues/new for
214	* reservations.
215	*/
216	/**
217	* G_TYPE_MAKE_FUNDAMENTAL:
218	* @x: the fundamental type number.
219	*
220	* Get the type ID for the fundamental type number @x.
221	*
222	* Use g_type_fundamental_next() instead of this macro to create new fundamental
223	* types.
224	*
225	* Returns: the GType
226	*/
227	#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT))
228	/**
229	* G_TYPE_RESERVED_GLIB_FIRST:
230	*
231	* First fundamental type number to create a new fundamental type id with
232	* G_TYPE_MAKE_FUNDAMENTAL() reserved for GLib.
233	*/
234	#define G_TYPE_RESERVED_GLIB_FIRST (22)
235	/**
236	* G_TYPE_RESERVED_GLIB_LAST:
237	*
238	* Last fundamental type number reserved for GLib.
239	*/
240	#define G_TYPE_RESERVED_GLIB_LAST (31)
241	/**
242	* G_TYPE_RESERVED_BSE_FIRST:
243	*
244	* First fundamental type number to create a new fundamental type id with
245	* G_TYPE_MAKE_FUNDAMENTAL() reserved for BSE.
246	*/
247	#define G_TYPE_RESERVED_BSE_FIRST (32)
248	/**
249	* G_TYPE_RESERVED_BSE_LAST:
250	*
251	* Last fundamental type number reserved for BSE.
252	*/
253	#define G_TYPE_RESERVED_BSE_LAST (48)
254	/**
255	* G_TYPE_RESERVED_USER_FIRST:
256	*
257	* First available fundamental type number to create new fundamental
258	* type id with G_TYPE_MAKE_FUNDAMENTAL().
259	*/
260	#define G_TYPE_RESERVED_USER_FIRST (49)
261
262
263	/ Type Checking Macros*
264	*/
265	/**
266	* G_TYPE_IS_FUNDAMENTAL:
267	* @type: A #GType value
268	*
269	* Checks if @type is a fundamental type.
270	*
271	* Returns: %TRUE is @type is fundamental
272	*/
273	#define G_TYPE_IS_FUNDAMENTAL(type) ((type) <= G_TYPE_FUNDAMENTAL_MAX)
274	/**
275	* G_TYPE_IS_DERIVED:
276	* @type: A #GType value
277	*
278	* Checks if @type is derived (or in object-oriented terminology:
279	* inherited) from another type (this holds true for all non-fundamental
280	* types).
281	*
282	* Returns: %TRUE if @type is derived
283	*/
284	#define G_TYPE_IS_DERIVED(type) ((type) > G_TYPE_FUNDAMENTAL_MAX)
285	/**
286	* G_TYPE_IS_INTERFACE:
287	* @type: A #GType value
288	*
289	* Checks if @type is an interface type.
290	*
291	* An interface type provides a pure API, the implementation
292	* of which is provided by another type (which is then said to conform
293	* to the interface). GLib interfaces are somewhat analogous to Java
294	* interfaces and C++ classes containing only pure virtual functions,
295	* with the difference that GType interfaces are not derivable (but see
296	* g_type_interface_add_prerequisite() for an alternative).
297	*
298	* Returns: %TRUE if @type is an interface
299	*/
300	#define G_TYPE_IS_INTERFACE(type) (G_TYPE_FUNDAMENTAL (type) == G_TYPE_INTERFACE)
301	/**
302	* G_TYPE_IS_CLASSED:
303	* @type: A #GType value
304	*
305	* Checks if @type is a classed type.
306	*
307	* A classed type has an associated #GTypeClass which can be derived to store
308	* class-wide virtual function pointers and data for all instances of the type.
309	* This allows for subclassing. All #GObjects are classed; none of the scalar
310	* fundamental types built into GLib are classed.
311	*
312	* Interfaces are not classed: while their #GTypeInterface struct could be
313	* considered similar to #GTypeClass, and classes can derive interfaces,
314	* #GTypeInterface doesn’t allow for subclassing.
315	*
316	* Returns: %TRUE if @type is classed
317	*/
318	#define G_TYPE_IS_CLASSED(type) (g_type_test_flags ((type), G_TYPE_FLAG_CLASSED))
319	/**
320	* G_TYPE_IS_INSTANTIATABLE:
321	* @type: A #GType value
322	*
323	* Checks if @type can be instantiated. Instantiation is the
324	* process of creating an instance (object) of this type.
325	*
326	* Returns: %TRUE if @type is instantiatable
327	*/
328	#define G_TYPE_IS_INSTANTIATABLE(type) (g_type_test_flags ((type), G_TYPE_FLAG_INSTANTIATABLE))
329	/**
330	* G_TYPE_IS_DERIVABLE:
331	* @type: A #GType value
332	*
333	* Checks if @type is a derivable type. A derivable type can
334	* be used as the base class of a flat (single-level) class hierarchy.
335	*
336	* Returns: %TRUE if @type is derivable
337	*/
338	#define G_TYPE_IS_DERIVABLE(type) (g_type_test_flags ((type), G_TYPE_FLAG_DERIVABLE))
339	/**
340	* G_TYPE_IS_DEEP_DERIVABLE:
341	* @type: A #GType value
342	*
343	* Checks if @type is a deep derivable type. A deep derivable type
344	* can be used as the base class of a deep (multi-level) class hierarchy.
345	*
346	* Returns: %TRUE if @type is deep derivable
347	*/
348	#define G_TYPE_IS_DEEP_DERIVABLE(type) (g_type_test_flags ((type), G_TYPE_FLAG_DEEP_DERIVABLE))
349	/**
350	* G_TYPE_IS_ABSTRACT:
351	* @type: A #GType value
352	*
353	* Checks if @type is an abstract type. An abstract type cannot be
354	* instantiated and is normally used as an abstract base class for
355	* derived classes.
356	*
357	* Returns: %TRUE if @type is abstract
358	*/
359	#define G_TYPE_IS_ABSTRACT(type) (g_type_test_flags ((type), G_TYPE_FLAG_ABSTRACT))
360	/**
361	* G_TYPE_IS_VALUE_ABSTRACT:
362	* @type: A #GType value
363	*
364	* Checks if @type is an abstract value type. An abstract value type introduces
365	* a value table, but can't be used for g_value_init() and is normally used as
366	* an abstract base type for derived value types.
367	*
368	* Returns: %TRUE if @type is an abstract value type
369	*/
370	#define G_TYPE_IS_VALUE_ABSTRACT(type) (g_type_test_flags ((type), G_TYPE_FLAG_VALUE_ABSTRACT))
371	/**
372	* G_TYPE_IS_VALUE_TYPE:
373	* @type: A #GType value
374	*
375	* Checks if @type is a value type and can be used with g_value_init().
376	*
377	* Returns: %TRUE if @type is a value type
378	*/
379	#define G_TYPE_IS_VALUE_TYPE(type) (g_type_check_is_value_type (type))
380	/**
381	* G_TYPE_HAS_VALUE_TABLE:
382	* @type: A #GType value
383	*
384	* Checks if @type has a #GTypeValueTable.
385	*
386	* Returns: %TRUE if @type has a value table
387	*/
388	#define G_TYPE_HAS_VALUE_TABLE(type) (g_type_value_table_peek (type) != NULL)
389	/**
390	* G_TYPE_IS_FINAL:
391	* @type: a #GType value
392	*
393	* Checks if @type is a final type. A final type cannot be derived any
394	* further.
395	*
396	* Returns: %TRUE if @type is final
397	*
398	* Since: 2.70
399	*/
400	#define G_TYPE_IS_FINAL(type) (g_type_test_flags ((type), G_TYPE_FLAG_FINAL)) GOBJECT_AVAILABLE_MACRO_IN_2_70
401
402	/**
403	* G_TYPE_IS_DEPRECATED:
404	* @type: a #GType value
405	*
406	* Checks if @type is deprecated. Instantiating a deprecated type will
407	* trigger a warning if running with `G_ENABLE_DIAGNOSTIC=1`.
408	*
409	* Returns: %TRUE if the type is deprecated
410	*
411	* Since: 2.76
412	*/
413	#define G_TYPE_IS_DEPRECATED(type) (g_type_test_flags ((type), G_TYPE_FLAG_DEPRECATED)) GOBJECT_AVAILABLE_MACRO_IN_2_76
414
415
416	/ Typedefs*
417	*/
418	/**
419	* GType:
420	*
421	* A numerical value which represents the unique identifier of a registered
422	* type.
423	*/
424	#if GLIB_SIZEOF_VOID_P > GLIB_SIZEOF_SIZE_T
425	typedef guintptr GType;
426	#elif GLIB_SIZEOF_SIZE_T != GLIB_SIZEOF_LONG \|\| !defined (G_CXX_STD_VERSION)
427	typedef gsize GType;
428	#else /* for historic reasons, C++ on non-Morello/CHERI systems links against gulong GTypes */
429	typedef gulong GType;
430	#endif
431	typedef struct _GValue GValue;
432	typedef union _GTypeCValue GTypeCValue;
433	typedef struct _GTypePlugin GTypePlugin;
434	typedef struct _GTypeClass GTypeClass;
435	typedef struct _GTypeInterface GTypeInterface;
436	typedef struct _GTypeInstance GTypeInstance;
437	typedef struct _GTypeInfo GTypeInfo;
438	typedef struct _GTypeFundamentalInfo GTypeFundamentalInfo;
439	typedef struct _GInterfaceInfo GInterfaceInfo;
440	typedef struct _GTypeValueTable GTypeValueTable;
441	typedef struct _GTypeQuery GTypeQuery;
442
443
444	/ Basic Type Structures*
445	*/
446	/**
447	* GTypeClass:
448	*
449	* An opaque structure used as the base of all classes.
450	*/
451	struct _GTypeClass
452	{
453	/< private >/
454	GType g_type;
455	};
456	/**
457	* GTypeInstance:
458	*
459	* An opaque structure used as the base of all type instances.
460	*/
461	struct _GTypeInstance
462	{
463	/< private >/
464	GTypeClass *g_class;
465	};
466	/**
467	* GTypeInterface:
468	*
469	* An opaque structure used as the base of all interface types.
470	*/
471	struct _GTypeInterface
472	{
473	/< private >/
474	GType g_type; / iface type /
475	GType g_instance_type;
476	};
477	/**
478	* GTypeQuery:
479	* @type: the #GType value of the type
480	* @type_name: the name of the type
481	* @class_size: the size of the class structure
482	* @instance_size: the size of the instance structure
483	*
484	* A structure holding information for a specific type.
485	*
486	* See also: g_type_query()
487	*/
488	struct _GTypeQuery
489	{
490	GType type;
491	const gchar *type_name;
492	guint class_size;
493	guint instance_size;
494	};
495
496
497	/ Casts, checks and accessors for structured types*
498	* usage of these macros is reserved to type implementations only
499	*/
500	/< protected >/
501	/**
502	* G_TYPE_CHECK_INSTANCE:
503	* @instance: Location of a #GTypeInstance structure
504	*
505	* Checks if @instance is a valid #GTypeInstance structure,
506	* otherwise issues a warning and returns %FALSE. %NULL is not a valid
507	* #GTypeInstance.
508	*
509	* This macro should only be used in type implementations.
510	*
511	* Returns: %TRUE if @instance is valid
512	*/
513	#define G_TYPE_CHECK_INSTANCE(instance) (_G_TYPE_CHI ((GTypeInstance*) (instance)))
514	/**
515	* G_TYPE_CHECK_INSTANCE_CAST:
516	* @instance: (nullable): Location of a #GTypeInstance structure
517	* @g_type: The type to be returned
518	* @c_type: The corresponding C type of @g_type
519	*
520	* Checks that @instance is an instance of the type identified by @g_type
521	* and issues a warning if this is not the case. Returns @instance casted
522	* to a pointer to @c_type.
523	*
524	* No warning will be issued if @instance is %NULL, and %NULL will be returned.
525	*
526	* This macro should only be used in type implementations.
527	*/
528	#define G_TYPE_CHECK_INSTANCE_CAST(instance, g_type, c_type) (_G_TYPE_CIC ((instance), (g_type), c_type))
529	/**
530	* G_TYPE_CHECK_INSTANCE_TYPE:
531	* @instance: (nullable): Location of a #GTypeInstance structure.
532	* @g_type: The type to be checked
533	*
534	* Checks if @instance is an instance of the type identified by @g_type. If
535	* @instance is %NULL, %FALSE will be returned.
536	*
537	* This macro should only be used in type implementations.
538	*
539	* Returns: %TRUE if @instance is an instance of @g_type
540	*/
541	#define G_TYPE_CHECK_INSTANCE_TYPE(instance, g_type) (_G_TYPE_CIT ((instance), (g_type)))
542	/**
543	* G_TYPE_CHECK_INSTANCE_FUNDAMENTAL_TYPE:
544	* @instance: (nullable): Location of a #GTypeInstance structure.
545	* @g_type: The fundamental type to be checked
546	*
547	* Checks if @instance is an instance of the fundamental type identified by @g_type.
548	* If @instance is %NULL, %FALSE will be returned.
549	*
550	* This macro should only be used in type implementations.
551	*
552	* Returns: %TRUE if @instance is an instance of @g_type
553	*/
554	#define G_TYPE_CHECK_INSTANCE_FUNDAMENTAL_TYPE(instance, g_type) (_G_TYPE_CIFT ((instance), (g_type)))
555	/**
556	* G_TYPE_INSTANCE_GET_CLASS:
557	* @instance: Location of the #GTypeInstance structure
558	* @g_type: The #GType of the class to be returned
559	* @c_type: The C type of the class structure
560	*
561	* Get the class structure of a given @instance, casted
562	* to a specified ancestor type @g_type of the instance.
563	*
564	* Note that while calling a GInstanceInitFunc(), the class pointer
565	* gets modified, so it might not always return the expected pointer.
566	*
567	* This macro should only be used in type implementations.
568	*
569	* Returns: a pointer to the class structure
570	*/
571	#define G_TYPE_INSTANCE_GET_CLASS(instance, g_type, c_type) (_G_TYPE_IGC ((instance), (g_type), c_type))
572	/**
573	* G_TYPE_INSTANCE_GET_INTERFACE:
574	* @instance: Location of the #GTypeInstance structure
575	* @g_type: The #GType of the interface to be returned
576	* @c_type: The C type of the interface structure
577	*
578	* Get the interface structure for interface @g_type of a given @instance.
579	*
580	* This macro should only be used in type implementations.
581	*
582	* Returns: a pointer to the interface structure
583	*/
584	#define G_TYPE_INSTANCE_GET_INTERFACE(instance, g_type, c_type) (_G_TYPE_IGI ((instance), (g_type), c_type))
585	/**
586	* G_TYPE_CHECK_CLASS_CAST:
587	* @g_class: Location of a #GTypeClass structure
588	* @g_type: The type to be returned
589	* @c_type: The corresponding C type of class structure of @g_type
590	*
591	* Checks that @g_class is a class structure of the type identified by @g_type
592	* and issues a warning if this is not the case. Returns @g_class casted
593	* to a pointer to @c_type. %NULL is not a valid class structure.
594	*
595	* This macro should only be used in type implementations.
596	*/
597	#define G_TYPE_CHECK_CLASS_CAST(g_class, g_type, c_type) (_G_TYPE_CCC ((g_class), (g_type), c_type))
598	/**
599	* G_TYPE_CHECK_CLASS_TYPE:
600	* @g_class: (nullable): Location of a #GTypeClass structure
601	* @g_type: The type to be checked
602	*
603	* Checks if @g_class is a class structure of the type identified by
604	* @g_type. If @g_class is %NULL, %FALSE will be returned.
605	*
606	* This macro should only be used in type implementations.
607	*
608	* Returns: %TRUE if @g_class is a class structure of @g_type
609	*/
610	#define G_TYPE_CHECK_CLASS_TYPE(g_class, g_type) (_G_TYPE_CCT ((g_class), (g_type)))
611	/**
612	* G_TYPE_CHECK_VALUE:
613	* @value: a #GValue
614	*
615	* Checks if @value has been initialized to hold values
616	* of a value type.
617	*
618	* This macro should only be used in type implementations.
619	*
620	* Returns: %TRUE if @value is initialized
621	*/
622	#define G_TYPE_CHECK_VALUE(value) (_G_TYPE_CHV ((value)))
623	/**
624	* G_TYPE_CHECK_VALUE_TYPE:
625	* @value: a #GValue
626	* @g_type: The type to be checked
627	*
628	* Checks if @value has been initialized to hold values
629	* of type @g_type.
630	*
631	* This macro should only be used in type implementations.
632	*
633	* Returns: %TRUE if @value has been initialized to hold values of type @g_type
634	*/
635	#define G_TYPE_CHECK_VALUE_TYPE(value, g_type) (_G_TYPE_CVH ((value), (g_type)))
636	/**
637	* G_TYPE_FROM_INSTANCE:
638	* @instance: Location of a valid #GTypeInstance structure
639	*
640	* Get the type identifier from a given @instance structure.
641	*
642	* This macro should only be used in type implementations.
643	*
644	* Returns: the #GType
645	*/
646	#define G_TYPE_FROM_INSTANCE(instance) (G_TYPE_FROM_CLASS (((GTypeInstance*) (instance))->g_class))
647	/**
648	* G_TYPE_FROM_CLASS:
649	* @g_class: Location of a valid #GTypeClass structure
650	*
651	* Get the type identifier from a given @class structure.
652	*
653	* This macro should only be used in type implementations.
654	*
655	* Returns: the #GType
656	*/
657	#define G_TYPE_FROM_CLASS(g_class) (((GTypeClass*) (g_class))->g_type)
658	/**
659	* G_TYPE_FROM_INTERFACE:
660	* @g_iface: Location of a valid #GTypeInterface structure
661	*
662	* Get the type identifier from a given @interface structure.
663	*
664	* This macro should only be used in type implementations.
665	*
666	* Returns: the #GType
667	*/
668	#define G_TYPE_FROM_INTERFACE(g_iface) (((GTypeInterface*) (g_iface))->g_type)
669
670	/**
671	* G_TYPE_INSTANCE_GET_PRIVATE:
672	* @instance: the instance of a type deriving from @private_type
673	* @g_type: the type identifying which private data to retrieve
674	* @c_type: The C type for the private structure
675	*
676	* Gets the private structure for a particular type.
677	*
678	* The private structure must have been registered in the
679	* class_init function with g_type_class_add_private().
680	*
681	* This macro should only be used in type implementations.
682	*
683	* Since: 2.4
684	* Deprecated: 2.58: Use G_ADD_PRIVATE() and the generated
685	* `your_type_get_instance_private()` function instead
686	* Returns: (not nullable): a pointer to the private data structure
687	*/
688	#define G_TYPE_INSTANCE_GET_PRIVATE(instance, g_type, c_type) ((c_type) g_type_instance_get_private ((GTypeInstance) (instance), (g_type))) GOBJECT_DEPRECATED_MACRO_IN_2_58_FOR(G_ADD_PRIVATE)
689
690	/**
691	* G_TYPE_CLASS_GET_PRIVATE:
692	* @klass: the class of a type deriving from @private_type
693	* @g_type: the type identifying which private data to retrieve
694	* @c_type: The C type for the private structure
695	*
696	* Gets the private class structure for a particular type.
697	*
698	* The private structure must have been registered in the
699	* get_type() function with g_type_add_class_private().
700	*
701	* This macro should only be used in type implementations.
702	*
703	* Since: 2.24
704	* Returns: (not nullable): a pointer to the private data structure
705	*/
706	#define G_TYPE_CLASS_GET_PRIVATE(klass, g_type, c_type) ((c_type) g_type_class_get_private ((GTypeClass) (klass), (g_type)))
707
708	/**
709	* GTypeDebugFlags:
710	* @G_TYPE_DEBUG_NONE: Print no messages
711	* @G_TYPE_DEBUG_OBJECTS: Print messages about object bookkeeping
712	* @G_TYPE_DEBUG_SIGNALS: Print messages about signal emissions
713	* @G_TYPE_DEBUG_MASK: Mask covering all debug flags
714	* @G_TYPE_DEBUG_INSTANCE_COUNT: Keep a count of instances of each type
715	*
716	* These flags used to be passed to g_type_init_with_debug_flags() which
717	* is now deprecated.
718	*
719	* If you need to enable debugging features, use the `GOBJECT_DEBUG`
720	* environment variable.
721	*
722	* Deprecated: 2.36: g_type_init() is now done automatically
723	*/
724	typedef enum /< skip >/
725	{
726	G_TYPE_DEBUG_NONE = `0`,
727	G_TYPE_DEBUG_OBJECTS = `1` << `0`,
728	G_TYPE_DEBUG_SIGNALS = `1` << `1`,
729	G_TYPE_DEBUG_INSTANCE_COUNT = `1` << `2`,
730	G_TYPE_DEBUG_MASK = `0x07`
731	} GTypeDebugFlags GOBJECT_DEPRECATED_TYPE_IN_2_36;
732
733
734	/ --- prototypes --- /
735	G_GNUC_BEGIN_IGNORE_DEPRECATIONS
736	GOBJECT_DEPRECATED_IN_2_36
737	void g_type_init (void);
738	GOBJECT_DEPRECATED_IN_2_36
739	void g_type_init_with_debug_flags (GTypeDebugFlags debug_flags);
740	G_GNUC_END_IGNORE_DEPRECATIONS
741
742	GOBJECT_AVAILABLE_IN_ALL
743	const gchar * g_type_name (GType type);
744	GOBJECT_AVAILABLE_IN_ALL
745	GQuark g_type_qname (GType type);
746	GOBJECT_AVAILABLE_IN_ALL
747	GType g_type_from_name (const gchar *name);
748	GOBJECT_AVAILABLE_IN_ALL
749	GType g_type_parent (GType type);
750	GOBJECT_AVAILABLE_IN_ALL
751	guint g_type_depth (GType type);
752	GOBJECT_AVAILABLE_IN_ALL
753	GType g_type_next_base (GType leaf_type,
754	GType root_type);
755	GOBJECT_AVAILABLE_IN_ALL
756	gboolean g_type_is_a (GType type,
757	GType is_a_type);
758
759	/ Hoist exact GType comparisons into the caller /
760	#define g_type_is_a(a,b) ((a) == (b) \|\| (g_type_is_a) ((a), (b)))
761
762	GOBJECT_AVAILABLE_IN_2_84
763	gpointer g_type_class_get (GType type);
764	GOBJECT_AVAILABLE_IN_ALL
765	gpointer g_type_class_ref (GType type);
766	GOBJECT_AVAILABLE_IN_ALL
767	gpointer g_type_class_peek (GType type);
768	GOBJECT_AVAILABLE_IN_ALL
769	gpointer g_type_class_peek_static (GType type);
770	GOBJECT_AVAILABLE_IN_ALL
771	void g_type_class_unref (gpointer g_class);
772	GOBJECT_AVAILABLE_IN_ALL
773	gpointer g_type_class_peek_parent (gpointer g_class);
774	GOBJECT_AVAILABLE_IN_ALL
775	gpointer g_type_interface_peek (gpointer instance_class,
776	GType iface_type);
777	GOBJECT_AVAILABLE_IN_ALL
778	gpointer g_type_interface_peek_parent (gpointer g_iface);
779
780	GOBJECT_AVAILABLE_IN_2_84
781	gpointer g_type_default_interface_get (GType g_type);
782	GOBJECT_AVAILABLE_IN_ALL
783	gpointer g_type_default_interface_ref (GType g_type);
784	GOBJECT_AVAILABLE_IN_ALL
785	gpointer g_type_default_interface_peek (GType g_type);
786	GOBJECT_AVAILABLE_IN_ALL
787	void g_type_default_interface_unref (gpointer g_iface);
788
789	/ g_free() the returned arrays /
790	GOBJECT_AVAILABLE_IN_ALL
791	GType* g_type_children (GType type,
792	guint *n_children);
793	GOBJECT_AVAILABLE_IN_ALL
794	GType* g_type_interfaces (GType type,
795	guint *n_interfaces);
796
797	/ per-type _static_ data /
798	GOBJECT_AVAILABLE_IN_ALL
799	void g_type_set_qdata (GType type,
800	GQuark quark,
801	gpointer data);
802	GOBJECT_AVAILABLE_IN_ALL
803	gpointer g_type_get_qdata (GType type,
804	GQuark quark);
805	GOBJECT_AVAILABLE_IN_ALL
806	void g_type_query (GType type,
807	GTypeQuery *query);
808
809	GOBJECT_AVAILABLE_IN_2_44
810	int g_type_get_instance_count (GType type);
811
812	/ --- type registration --- /
813	/**
814	* GBaseInitFunc:
815	* @g_class: (type GObject.TypeClass): The #GTypeClass structure to initialize
816	*
817	* A callback function used by the type system to do base initialization
818	* of the class structures of derived types.
819	*
820	* This function is called as part of the initialization process of all derived
821	* classes and should reallocate or reset all dynamic class members copied over
822	* from the parent class.
823	*
824	* For example, class members (such as strings) that are not sufficiently
825	* handled by a plain memory copy of the parent class into the derived class
826	* have to be altered. See GClassInitFunc() for a discussion of the class
827	* initialization process.
828	*/
829	typedef void (*GBaseInitFunc) (gpointer g_class);
830	/**
831	* GBaseFinalizeFunc:
832	* @g_class: (type GObject.TypeClass): The #GTypeClass structure to finalize
833	*
834	* A callback function used by the type system to finalize those portions
835	* of a derived types class structure that were setup from the corresponding
836	* GBaseInitFunc() function.
837	*
838	* Class finalization basically works the inverse way in which class
839	* initialization is performed.
840	*
841	* See GClassInitFunc() for a discussion of the class initialization process.
842	*/
843	typedef void (*GBaseFinalizeFunc) (gpointer g_class);
844	/**
845	* GClassInitFunc:
846	* @g_class: (type GObject.TypeClass): The #GTypeClass structure to initialize.
847	* @class_data: The @class_data member supplied via the #GTypeInfo structure.
848	*
849	* A callback function used by the type system to initialize the class
850	* of a specific type.
851	*
852	* This function should initialize all static class members.
853	*
854	* The initialization process of a class involves:
855	*
856	* - Copying common members from the parent class over to the
857	* derived class structure.
858	* - Zero initialization of the remaining members not copied
859	* over from the parent class.
860	* - Invocation of the GBaseInitFunc() initializers of all parent
861	* types and the class' type.
862	* - Invocation of the class' GClassInitFunc() initializer.
863	*
864	* Since derived classes are partially initialized through a memory copy
865	* of the parent class, the general rule is that GBaseInitFunc() and
866	* GBaseFinalizeFunc() should take care of necessary reinitialization
867	* and release of those class members that were introduced by the type
868	* that specified these GBaseInitFunc()/GBaseFinalizeFunc().
869	* GClassInitFunc() should only care about initializing static
870	* class members, while dynamic class members (such as allocated strings
871	* or reference counted resources) are better handled by a GBaseInitFunc()
872	* for this type, so proper initialization of the dynamic class members
873	* is performed for class initialization of derived types as well.
874	*
875	* An example may help to correspond the intend of the different class
876	* initializers:
877	*
878	* \|[<!-- language="C" -->
879	* typedef struct {
880	* GObjectClass parent_class;
881	* gint static_integer;
882	* gchar *dynamic_string;
883	* } TypeAClass;
884	* static void
885	* type_a_base_class_init (TypeAClass *class)
886	* {
887	* class->dynamic_string = g_strdup ("some string");
888	* }
889	* static void
890	* type_a_base_class_finalize (TypeAClass *class)
891	* {
892	* g_free (class->dynamic_string);
893	* }
894	* static void
895	* type_a_class_init (TypeAClass *class)
896	* {
897	* class->static_integer = 42;
898	* }
899	*
900	* typedef struct {
901	* TypeAClass parent_class;
902	* gfloat static_float;
903	* GString *dynamic_gstring;
904	* } TypeBClass;
905	* static void
906	* type_b_base_class_init (TypeBClass *class)
907	* {
908	* class->dynamic_gstring = g_string_new ("some other string");
909	* }
910	* static void
911	* type_b_base_class_finalize (TypeBClass *class)
912	* {
913	* g_string_free (class->dynamic_gstring);
914	* }
915	* static void
916	* type_b_class_init (TypeBClass *class)
917	* {
918	* class->static_float = 3.14159265358979323846;
919	* }
920	* ]\|
921	*
922	* Initialization of TypeBClass will first cause initialization of
923	* TypeAClass (derived classes reference their parent classes, see
924	* g_type_class_ref() on this).
925	*
926	* Initialization of TypeAClass roughly involves zero-initializing its fields,
927	* then calling its GBaseInitFunc() type_a_base_class_init() to allocate
928	* its dynamic members (dynamic_string), and finally calling its GClassInitFunc()
929	* type_a_class_init() to initialize its static members (static_integer).
930	* The first step in the initialization process of TypeBClass is then
931	* a plain memory copy of the contents of TypeAClass into TypeBClass and
932	* zero-initialization of the remaining fields in TypeBClass.
933	* The dynamic members of TypeAClass within TypeBClass now need
934	* reinitialization which is performed by calling type_a_base_class_init()
935	* with an argument of TypeBClass.
936	*
937	* After that, the GBaseInitFunc() of TypeBClass, type_b_base_class_init()
938	* is called to allocate the dynamic members of TypeBClass (dynamic_gstring),
939	* and finally the GClassInitFunc() of TypeBClass, type_b_class_init(),
940	* is called to complete the initialization process with the static members
941	* (static_float).
942	*
943	* Corresponding finalization counter parts to the GBaseInitFunc() functions
944	* have to be provided to release allocated resources at class finalization
945	* time.
946	*/
947	typedef void (*GClassInitFunc) (gpointer g_class,
948	gpointer class_data);
949	/**
950	* GClassFinalizeFunc:
951	* @g_class: (type GObject.TypeClass): The #GTypeClass structure to finalize
952	* @class_data: The @class_data member supplied via the #GTypeInfo structure
953	*
954	* A callback function used by the type system to finalize a class.
955	*
956	* This function is rarely needed, as dynamically allocated class resources
957	* should be handled by GBaseInitFunc() and GBaseFinalizeFunc().
958	*
959	* Also, specification of a GClassFinalizeFunc() in the #GTypeInfo
960	* structure of a static type is invalid, because classes of static types
961	* will never be finalized (they are artificially kept alive when their
962	* reference count drops to zero).
963	*/
964	typedef void (*GClassFinalizeFunc) (gpointer g_class,
965	gpointer class_data);
966	/**
967	* GInstanceInitFunc:
968	* @instance: The instance to initialize
969	* @g_class: (type GObject.TypeClass): The class of the type the instance is
970	* created for
971	*
972	* A callback function used by the type system to initialize a new
973	* instance of a type.
974	*
975	* This function initializes all instance members and allocates any resources
976	* required by it.
977	*
978	* Initialization of a derived instance involves calling all its parent
979	* types instance initializers, so the class member of the instance
980	* is altered during its initialization to always point to the class that
981	* belongs to the type the current initializer was introduced for.
982	*
983	* The extended members of @instance are guaranteed to have been filled with
984	* zeros before this function is called.
985	*/
986	typedef void (GInstanceInitFunc) (GTypeInstance instance,
987	gpointer g_class);
988	/**
989	* GInterfaceInitFunc:
990	* @g_iface: (type GObject.TypeInterface): The interface structure to initialize
991	* @iface_data: The @interface_data supplied via the #GInterfaceInfo structure
992	*
993	* A callback function used by the type system to initialize a new
994	* interface.
995	*
996	* This function should initialize all internal data and* allocate any
997	* resources required by the interface.
998	*
999	* The members of @iface_data are guaranteed to have been filled with
1000	* zeros before this function is called.
1001	*/
1002	typedef void (*GInterfaceInitFunc) (gpointer g_iface,
1003	gpointer iface_data);
1004	/**
1005	* GInterfaceFinalizeFunc:
1006	* @g_iface: (type GObject.TypeInterface): The interface structure to finalize
1007	* @iface_data: The @interface_data supplied via the #GInterfaceInfo structure
1008	*
1009	* A callback function used by the type system to finalize an interface.
1010	*
1011	* This function should destroy any internal data and release any resources
1012	* allocated by the corresponding GInterfaceInitFunc() function.
1013	*/
1014	typedef void (*GInterfaceFinalizeFunc) (gpointer g_iface,
1015	gpointer iface_data);
1016	/**
1017	* GTypeClassCacheFunc:
1018	* @cache_data: data that was given to the g_type_add_class_cache_func() call
1019	* @g_class: (type GObject.TypeClass): The #GTypeClass structure which is
1020	* unreferenced
1021	*
1022	* A callback function which is called when the reference count of a class
1023	* drops to zero.
1024	*
1025	* It may use g_type_class_ref() to prevent the class from being freed. You
1026	* should not call g_type_class_unref() from a #GTypeClassCacheFunc function
1027	* to prevent infinite recursion, use g_type_class_unref_uncached() instead.
1028	*
1029	* The functions have to check the class id passed in to figure
1030	* whether they actually want to cache the class of this type, since all
1031	* classes are routed through the same #GTypeClassCacheFunc chain.
1032	*
1033	* Returns: %TRUE to stop further #GTypeClassCacheFuncs from being
1034	* called, %FALSE to continue
1035	*/
1036	typedef gboolean (*GTypeClassCacheFunc) (gpointer cache_data,
1037	GTypeClass *g_class);
1038	/**
1039	* GTypeInterfaceCheckFunc:
1040	* @check_data: data passed to g_type_add_interface_check()
1041	* @g_iface: (type GObject.TypeInterface): the interface that has been
1042	* initialized
1043	*
1044	* A callback called after an interface vtable is initialized.
1045	*
1046	* See g_type_add_interface_check().
1047	*
1048	* Since: 2.4
1049	*/
1050	typedef void (*GTypeInterfaceCheckFunc) (gpointer check_data,
1051	gpointer g_iface);
1052	/**
1053	* GTypeFundamentalFlags:
1054	* @G_TYPE_FLAG_CLASSED: Indicates a classed type
1055	* @G_TYPE_FLAG_INSTANTIATABLE: Indicates an instantiatable type (implies classed)
1056	* @G_TYPE_FLAG_DERIVABLE: Indicates a flat derivable type
1057	* @G_TYPE_FLAG_DEEP_DERIVABLE: Indicates a deep derivable type (implies derivable)
1058	*
1059	* Bit masks used to check or determine specific characteristics of a
1060	* fundamental type.
1061	*/
1062	typedef enum /< skip >/
1063	{
1064	/ There is no G_TYPE_FUNDAMENTAL_FLAGS_NONE: this is implemented to use*
1065	* the same bits as GTypeFlags */
1066	G_TYPE_FLAG_CLASSED = (`1` << `0`),
1067	G_TYPE_FLAG_INSTANTIATABLE = (`1` << `1`),
1068	G_TYPE_FLAG_DERIVABLE = (`1` << `2`),
1069	G_TYPE_FLAG_DEEP_DERIVABLE = (`1` << `3`)
1070	} GTypeFundamentalFlags;
1071	/**
1072	* GTypeFlags:
1073	* @G_TYPE_FLAG_NONE: No special flags. Since: 2.74
1074	* @G_TYPE_FLAG_ABSTRACT: Indicates an abstract type. No instances can be
1075	* created for an abstract type
1076	* @G_TYPE_FLAG_VALUE_ABSTRACT: Indicates an abstract value type, i.e. a type
1077	* that introduces a value table, but can't be used for
1078	* g_value_init()
1079	* @G_TYPE_FLAG_FINAL: Indicates a final type. A final type is a non-derivable
1080	* leaf node in a deep derivable type hierarchy tree. Since: 2.70
1081	* @G_TYPE_FLAG_DEPRECATED: The type is deprecated and may be removed in a
1082	* future version. A warning will be emitted if it is instantiated while
1083	* running with `G_ENABLE_DIAGNOSTIC=1`. Since 2.76
1084	*
1085	* Bit masks used to check or determine characteristics of a type.
1086	*/
1087	typedef enum /< skip >/
1088	{
1089	G_TYPE_FLAG_NONE GOBJECT_AVAILABLE_ENUMERATOR_IN_2_74 = `0`,
1090	G_TYPE_FLAG_ABSTRACT = (`1` << `4`),
1091	G_TYPE_FLAG_VALUE_ABSTRACT = (`1` << `5`),
1092	G_TYPE_FLAG_FINAL GOBJECT_AVAILABLE_ENUMERATOR_IN_2_70 = (`1` << `6`),
1093	G_TYPE_FLAG_DEPRECATED GOBJECT_AVAILABLE_ENUMERATOR_IN_2_76 = (`1` << `7`)
1094	} GTypeFlags;
1095	/**
1096	* GTypeInfo:
1097	* @class_size: Size of the class structure (required for interface, classed and instantiatable types)
1098	* @base_init: Location of the base initialization function (optional)
1099	* @base_finalize: Location of the base finalization function (optional)
1100	* @class_init: Location of the class initialization function for
1101	* classed and instantiatable types. Location of the default vtable
1102	* initialization function for interface types. (optional) This function
1103	* is used both to fill in virtual functions in the class or default vtable,
1104	* and to do type-specific setup such as registering signals and object
1105	* properties.
1106	* @class_finalize: Location of the class finalization function for
1107	* classed and instantiatable types. Location of the default vtable
1108	* finalization function for interface types. (optional)
1109	* @class_data: User-supplied data passed to the class init/finalize functions
1110	* @instance_size: Size of the instance (object) structure (required for instantiatable types only)
1111	* @n_preallocs: Prior to GLib 2.10, it specified the number of pre-allocated (cached) instances to reserve memory for (0 indicates no caching). Since GLib 2.10 this field is ignored.
1112	* @instance_init: Location of the instance initialization function (optional, for instantiatable types only)
1113	* @value_table: A #GTypeValueTable function table for generic handling of GValues
1114	* of this type (usually only useful for fundamental types)
1115	*
1116	* This structure is used to provide the type system with the information
1117	* required to initialize and destruct (finalize) a type's class and
1118	* its instances.
1119	*
1120	* The initialized structure is passed to the g_type_register_static() function
1121	* (or is copied into the provided #GTypeInfo structure in the
1122	* g_type_plugin_complete_type_info()). The type system will perform a deep
1123	* copy of this structure, so its memory does not need to be persistent
1124	* across invocation of g_type_register_static().
1125	*/
1126	struct _GTypeInfo
1127	{
1128	/ interface types, classed types, instantiated types /
1129	guint16 class_size;
1130
1131	GBaseInitFunc base_init;
1132	GBaseFinalizeFunc base_finalize;
1133
1134	/ interface types, classed types, instantiated types /
1135	GClassInitFunc class_init;
1136	GClassFinalizeFunc class_finalize;
1137	gconstpointer class_data;
1138
1139	/ instantiated types /
1140	guint16 instance_size;
1141	guint16 n_preallocs;
1142	GInstanceInitFunc instance_init;
1143
1144	/ value handling /
1145	const GTypeValueTable *value_table;
1146	};
1147	/**
1148	* GTypeFundamentalInfo:
1149	* @type_flags: #GTypeFundamentalFlags describing the characteristics of the fundamental type
1150	*
1151	* A structure that provides information to the type system which is
1152	* used specifically for managing fundamental types.
1153	*/
1154	struct _GTypeFundamentalInfo
1155	{
1156	GTypeFundamentalFlags type_flags;
1157	};
1158	/**
1159	* GInterfaceInfo:
1160	* @interface_init: location of the interface initialization function
1161	* @interface_finalize: location of the interface finalization function
1162	* @interface_data: user-supplied data passed to the interface init/finalize functions
1163	*
1164	* A structure that provides information to the type system which is
1165	* used specifically for managing interface types.
1166	*/
1167	struct _GInterfaceInfo
1168	{
1169	GInterfaceInitFunc interface_init;
1170	GInterfaceFinalizeFunc interface_finalize;
1171	gpointer interface_data;
1172	};
1173
1174	/**
1175	* GTypeValueInitFunc:
1176	* @value: the value to initialize
1177	*
1178	* Initializes the value contents by setting the fields of the `value->data`
1179	* array.
1180	*
1181	* The data array of the #GValue passed into this function was zero-filled
1182	* with `memset()`, so no care has to be taken to free any old contents.
1183	* For example, in the case of a string value that may never be %NULL, the
1184	* implementation might look like:
1185	*
1186	* \|[<!-- language="C" -->
1187	* value->data[0].v_pointer = g_strdup ("");
1188	* ]\|
1189	*
1190	* Since: 2.78
1191	*/
1192	GOBJECT_AVAILABLE_TYPE_IN_2_78
1193	typedef void (* GTypeValueInitFunc) (GValue *value);
1194
1195	/**
1196	* GTypeValueFreeFunc:
1197	* @value: the value to free
1198	*
1199	* Frees any old contents that might be left in the `value->data` array of
1200	* the given value.
1201	*
1202	* No resources may remain allocated through the #GValue contents after this
1203	* function returns. E.g. for our above string type:
1204	*
1205	* \|[<!-- language="C" -->
1206	* // only free strings without a specific flag for static storage
1207	* if (!(value->data[1].v_uint & G_VALUE_NOCOPY_CONTENTS))
1208	* g_free (value->data[0].v_pointer);
1209	* ]\|
1210	*
1211	* Since: 2.78
1212	*/
1213	GOBJECT_AVAILABLE_TYPE_IN_2_78
1214	typedef void (* GTypeValueFreeFunc) (GValue *value);
1215
1216	/**
1217	* GTypeValueCopyFunc:
1218	* @src_value: the value to copy
1219	* @dest_value: (out): the location of the copy
1220	*
1221	* Copies the content of a #GValue into another.
1222	*
1223	* The @dest_value is a #GValue with zero-filled data section and @src_value
1224	* is a properly initialized #GValue of same type, or derived type.
1225	*
1226	* The purpose of this function is to copy the contents of @src_value
1227	* into @dest_value in a way, that even after @src_value has been freed, the
1228	* contents of @dest_value remain valid. String type example:
1229	*
1230	* \|[<!-- language="C" -->
1231	* dest_value->data[0].v_pointer = g_strdup (src_value->data[0].v_pointer);
1232	* ]\|
1233	*
1234	* Since: 2.78
1235	*/
1236	GOBJECT_AVAILABLE_TYPE_IN_2_78
1237	typedef void (* GTypeValueCopyFunc) (const GValue *src_value,
1238	GValue *dest_value);
1239
1240	/**
1241	* GTypeValuePeekPointerFunc:
1242	* @value: the value to peek
1243	*
1244	* If the value contents fit into a pointer, such as objects or strings,
1245	* return this pointer, so the caller can peek at the current contents.
1246	*
1247	* To extend on our above string example:
1248	*
1249	* \|[<!-- language="C" -->
1250	* return value->data[0].v_pointer;
1251	* ]\|
1252	*
1253	* Returns: (transfer none): a pointer to the value contents
1254	*
1255	* Since: 2.78
1256	*/
1257	GOBJECT_AVAILABLE_TYPE_IN_2_78
1258	typedef gpointer (* GTypeValuePeekPointerFunc) (const GValue *value);
1259
1260	/**
1261	* GTypeValueCollectFunc:
1262	* @value: the value to initialize
1263	* @n_collect_values: the number of collected values
1264	* @collect_values: (array length=n_collect_values): the collected values
1265	* @collect_flags: optional flags
1266	*
1267	* This function is responsible for converting the values collected from
1268	* a variadic argument list into contents suitable for storage in a #GValue.
1269	*
1270	* This function should setup @value similar to #GTypeValueInitFunc; e.g.
1271	* for a string value that does not allow `NULL` pointers, it needs to either
1272	* emit an error, or do an implicit conversion by storing an empty string.
1273	*
1274	* The @value passed in to this function has a zero-filled data array, so
1275	* just like for #GTypeValueInitFunc it is guaranteed to not contain any old
1276	* contents that might need freeing.
1277	*
1278	* The @n_collect_values argument is the string length of the `collect_format`
1279	* field of #GTypeValueTable, and `collect_values` is an array of #GTypeCValue
1280	* with length of @n_collect_values, containing the collected values according
1281	* to `collect_format`.
1282	*
1283	* The @collect_flags argument provided as a hint by the caller. It may
1284	* contain the flag %G_VALUE_NOCOPY_CONTENTS indicating that the collected
1285	* value contents may be considered ‘static’ for the duration of the @value
1286	* lifetime. Thus an extra copy of the contents stored in @collect_values is
1287	* not required for assignment to @value.
1288	*
1289	* For our above string example, we continue with:
1290	*
1291	* \|[<!-- language="C" -->
1292	* if (!collect_values[0].v_pointer)
1293	* value->data[0].v_pointer = g_strdup ("");
1294	* else if (collect_flags & G_VALUE_NOCOPY_CONTENTS)
1295	* {
1296	* value->data[0].v_pointer = collect_values[0].v_pointer;
1297	* // keep a flag for the value_free() implementation to not free this string
1298	* value->data[1].v_uint = G_VALUE_NOCOPY_CONTENTS;
1299	* }
1300	* else
1301	* value->data[0].v_pointer = g_strdup (collect_values[0].v_pointer);
1302	* return NULL;
1303	* ]\|
1304	*
1305	* It should be noted, that it is generally a bad idea to follow the
1306	* %G_VALUE_NOCOPY_CONTENTS hint for reference counted types. Due to
1307	* reentrancy requirements and reference count assertions performed
1308	* by the signal emission code, reference counts should always be
1309	* incremented for reference counted contents stored in the `value->data`
1310	* array. To deviate from our string example for a moment, and taking
1311	* a look at an exemplary implementation for `GTypeValueTable.collect_value()`
1312	* of `GObject`:
1313	*
1314	* \|[<!-- language="C" -->
1315	* GObject *object = G_OBJECT (collect_values[0].v_pointer);
1316	* g_return_val_if_fail (object != NULL,
1317	* g_strdup_printf ("Object %p passed as invalid NULL pointer", object));
1318	* // never honour G_VALUE_NOCOPY_CONTENTS for ref-counted types
1319	* value->data[0].v_pointer = g_object_ref (object);
1320	* return NULL;
1321	* ]\|
1322	*
1323	* The reference count for valid objects is always incremented, regardless
1324	* of `collect_flags`. For invalid objects, the example returns a newly
1325	* allocated string without altering `value`.
1326	*
1327	* Upon success, `collect_value()` needs to return `NULL`. If, however,
1328	* an error condition occurred, `collect_value()` should return a newly
1329	* allocated string containing an error diagnostic.
1330	*
1331	* The calling code makes no assumptions about the `value` contents being
1332	* valid upon error returns, `value` is simply thrown away without further
1333	* freeing. As such, it is a good idea to not allocate `GValue` contents
1334	* prior to returning an error; however, `collect_values()` is not obliged
1335	* to return a correctly setup @value for error returns, simply because
1336	* any non-`NULL` return is considered a fatal programming error, and
1337	* further program behaviour is undefined.
1338	*
1339	* Returns: (transfer full) (nullable): `NULL` on success, otherwise a
1340	* newly allocated error string on failure
1341	*
1342	* Since: 2.78
1343	*/
1344	GOBJECT_AVAILABLE_TYPE_IN_2_78
1345	typedef gchar * (* GTypeValueCollectFunc) (GValue *value,
1346	guint n_collect_values,
1347	GTypeCValue *collect_values,
1348	guint collect_flags);
1349
1350	/**
1351	* GTypeValueLCopyFunc:
1352	* @value: the value to lcopy
1353	* @n_collect_values: the number of collected values
1354	* @collect_values: (array length=n_collect_values): the collected
1355	* locations for storage
1356	* @collect_flags: optional flags
1357	*
1358	* This function is responsible for storing the `value`
1359	* contents into arguments passed through a variadic argument list which
1360	* got collected into `collect_values` according to `lcopy_format`.
1361	*
1362	* The `n_collect_values` argument equals the string length of
1363	* `lcopy_format`, and `collect_flags` may contain %G_VALUE_NOCOPY_CONTENTS.
1364	*
1365	* In contrast to #GTypeValueCollectFunc, this function is obliged to always
1366	* properly support %G_VALUE_NOCOPY_CONTENTS.
1367	*
1368	* Similar to #GTypeValueCollectFunc the function may prematurely abort by
1369	* returning a newly allocated string describing an error condition. To
1370	* complete the string example:
1371	*
1372	* \|[<!-- language="C" -->
1373	* gchar **string_p = collect_values[0].v_pointer;
1374	* g_return_val_if_fail (string_p != NULL,
1375	* g_strdup ("string location passed as NULL"));
1376	*
1377	* if (collect_flags & G_VALUE_NOCOPY_CONTENTS)
1378	* *string_p = value->data[0].v_pointer;
1379	* else
1380	* *string_p = g_strdup (value->data[0].v_pointer);
1381	* ]\|
1382	*
1383	* And an illustrative version of this function for reference-counted
1384	* types:
1385	*
1386	* \|[<!-- language="C" -->
1387	* GObject **object_p = collect_values[0].v_pointer;
1388	* g_return_val_if_fail (object_p != NULL,
1389	* g_strdup ("object location passed as NULL"));
1390	*
1391	* if (value->data[0].v_pointer == NULL)
1392	* *object_p = NULL;
1393	* else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) // always honour
1394	* *object_p = value->data[0].v_pointer;
1395	* else
1396	* *object_p = g_object_ref (value->data[0].v_pointer);
1397	*
1398	* return NULL;
1399	* ]\|
1400	*
1401	* Returns: (transfer full) (nullable): `NULL` on success, otherwise
1402	* a newly allocated error string on failure
1403	*
1404	* Since: 2.78
1405	*/
1406	GOBJECT_AVAILABLE_TYPE_IN_2_78
1407	typedef gchar * (* GTypeValueLCopyFunc) (const GValue *value,
1408	guint n_collect_values,
1409	GTypeCValue *collect_values,
1410	guint collect_flags);
1411
1412	/**
1413	* GTypeValueTable:
1414	* @value_init: Function to initialize a GValue
1415	* @value_free: Function to free a GValue
1416	* @value_copy: Function to copy a GValue
1417	* @value_peek_pointer: Function to peek the contents of a GValue if they fit
1418	* into a pointer
1419	* @collect_format: A string format describing how to collect the contents of
1420	* this value bit-by-bit. Each character in the format represents
1421	* an argument to be collected, and the characters themselves indicate
1422	* the type of the argument. Currently supported arguments are:
1423	*
1424	* - `'i'`: Integers, passed as `collect_values[].v_int`
1425	* - `'l'`: Longs, passed as `collect_values[].v_long`
1426	* - `'d'`: Doubles, passed as `collect_values[].v_double`
1427	* - `'p'`: Pointers, passed as `collect_values[].v_pointer`
1428	*
1429	* It should be noted that for variable argument list construction,
1430	* ANSI C promotes every type smaller than an integer to an int, and
1431	* floats to doubles. So for collection of short int or char, `'i'`
1432	* needs to be used, and for collection of floats `'d'`.
1433	* @collect_value: Function to initialize a GValue from the values
1434	* collected from variadic arguments
1435	* @lcopy_format: Format description of the arguments to collect for @lcopy_value,
1436	* analogous to @collect_format. Usually, @lcopy_format string consists
1437	* only of `'p'`s to provide lcopy_value() with pointers to storage locations.
1438	* @lcopy_value: Function to store the contents of a value into the
1439	* locations collected from variadic arguments
1440	*
1441	* The #GTypeValueTable provides the functions required by the #GValue
1442	* implementation, to serve as a container for values of a type.
1443	*/
1444	G_GNUC_BEGIN_IGNORE_DEPRECATIONS
1445	struct _GTypeValueTable
1446	{
1447	GTypeValueInitFunc value_init;
1448	GTypeValueFreeFunc value_free;
1449	GTypeValueCopyFunc value_copy;
1450	GTypeValuePeekPointerFunc value_peek_pointer;
1451
1452	const gchar *collect_format;
1453	GTypeValueCollectFunc collect_value;
1454
1455	const gchar *lcopy_format;
1456	GTypeValueLCopyFunc lcopy_value;
1457	};
1458	G_GNUC_END_IGNORE_DEPRECATIONS
1459
1460	GOBJECT_AVAILABLE_IN_ALL
1461	GType g_type_register_static (GType parent_type,
1462	const gchar *type_name,
1463	const GTypeInfo *info,
1464	GTypeFlags flags);
1465	GOBJECT_AVAILABLE_IN_ALL
1466	GType g_type_register_static_simple (GType parent_type,
1467	const gchar *type_name,
1468	guint class_size,
1469	GClassInitFunc class_init,
1470	guint instance_size,
1471	GInstanceInitFunc instance_init,
1472	GTypeFlags flags);
1473
1474	GOBJECT_AVAILABLE_IN_ALL
1475	GType g_type_register_dynamic (GType parent_type,
1476	const gchar *type_name,
1477	GTypePlugin *plugin,
1478	GTypeFlags flags);
1479	GOBJECT_AVAILABLE_IN_ALL
1480	GType g_type_register_fundamental (GType type_id,
1481	const gchar *type_name,
1482	const GTypeInfo *info,
1483	const GTypeFundamentalInfo *finfo,
1484	GTypeFlags flags);
1485	GOBJECT_AVAILABLE_IN_ALL
1486	void g_type_add_interface_static (GType instance_type,
1487	GType interface_type,
1488	const GInterfaceInfo *info);
1489	GOBJECT_AVAILABLE_IN_ALL
1490	void g_type_add_interface_dynamic (GType instance_type,
1491	GType interface_type,
1492	GTypePlugin *plugin);
1493	GOBJECT_AVAILABLE_IN_ALL
1494	void g_type_interface_add_prerequisite (GType interface_type,
1495	GType prerequisite_type);
1496	GOBJECT_AVAILABLE_IN_ALL
1497	GType*g_type_interface_prerequisites (GType interface_type,
1498	guint *n_prerequisites);
1499	GOBJECT_AVAILABLE_IN_2_68
1500	GType g_type_interface_instantiatable_prerequisite
1501	(GType interface_type);
1502	GOBJECT_DEPRECATED_IN_2_58
1503	void g_type_class_add_private (gpointer g_class,
1504	gsize private_size);
1505	GOBJECT_AVAILABLE_IN_2_38
1506	gint g_type_add_instance_private (GType class_type,
1507	gsize private_size);
1508	GOBJECT_AVAILABLE_IN_ALL
1509	gpointer g_type_instance_get_private (GTypeInstance *instance,
1510	GType private_type);
1511	GOBJECT_AVAILABLE_IN_2_38
1512	void g_type_class_adjust_private_offset (gpointer g_class,
1513	gint *private_size_or_offset);
1514
1515	GOBJECT_AVAILABLE_IN_ALL
1516	void g_type_add_class_private (GType class_type,
1517	gsize private_size);
1518	GOBJECT_AVAILABLE_IN_ALL
1519	gpointer g_type_class_get_private (GTypeClass *klass,
1520	GType private_type);
1521	GOBJECT_AVAILABLE_IN_2_38
1522	gint g_type_class_get_instance_private_offset (gpointer g_class);
1523
1524	GOBJECT_AVAILABLE_IN_2_34
1525	void g_type_ensure (GType type);
1526	GOBJECT_AVAILABLE_IN_2_36
1527	guint g_type_get_type_registration_serial (void);
1528
1529
1530	/ --- GType boilerplate --- /
1531	/**
1532	* G_DECLARE_FINAL_TYPE:
1533	* @ModuleObjName: The name of the new type, in camel case (like `GtkWidget`)
1534	* @module_obj_name: The name of the new type in lowercase, with words
1535	* separated by `_` (like `gtk_widget`)
1536	* @MODULE: The name of the module, in all caps (like `GTK`)
1537	* @OBJ_NAME: The bare name of the type, in all caps (like `WIDGET`)
1538	* @ParentName: the name of the parent type, in camel case (like `GtkWidget`)
1539	*
1540	* A convenience macro for emitting the usual declarations in the header file
1541	* for a type which is not (at the present time) intended to be subclassed.
1542	*
1543	* You might use it in a header as follows:
1544	*
1545	* \|[<!-- language="C" -->
1546	* #ifndef _myapp_window_h_
1547	* #define _myapp_window_h_
1548	*
1549	* #include <gtk/gtk.h>
1550	*
1551	* #define MY_APP_TYPE_WINDOW my_app_window_get_type ()
1552	* G_DECLARE_FINAL_TYPE (MyAppWindow, my_app_window, MY_APP, WINDOW, GtkWindow)
1553	*
1554	* MyAppWindow * my_app_window_new (void);
1555	*
1556	* ...
1557	*
1558	* #endif
1559	* ]\|
1560	*
1561	* And use it as follow in your C file:
1562	*
1563	* \|[<!-- language="C" -->
1564	* struct _MyAppWindow
1565	* {
1566	* GtkWindow parent;
1567	* ...
1568	* };
1569	* G_DEFINE_TYPE (MyAppWindow, my_app_window, GTK_TYPE_WINDOW)
1570	* ]\|
1571	*
1572	* This results in the following things happening:
1573	*
1574	* - the usual `my_app_window_get_type()` function is declared with a return type of #GType
1575	*
1576	* - the `MyAppWindow` type is defined as a `typedef` of `struct _MyAppWindow`. The struct itself is not
1577	* defined and should be defined from the .c file before G_DEFINE_TYPE() is used.
1578	*
1579	* - the `MY_APP_WINDOW()` cast is emitted as `static inline` function along with the `MY_APP_IS_WINDOW()` type
1580	* checking function
1581	*
1582	* - the `MyAppWindowClass` type is defined as a struct containing `GtkWindowClass`. This is done for the
1583	* convenience of the person defining the type and should not be considered to be part of the ABI. In
1584	* particular, without a firm declaration of the instance structure, it is not possible to subclass the type
1585	* and therefore the fact that the size of the class structure is exposed is not a concern and it can be
1586	* freely changed at any point in the future.
1587	*
1588	* - g_autoptr() support being added for your type, based on the type of your parent class
1589	*
1590	* You can only use this function if your parent type also supports g_autoptr().
1591	*
1592	* Because the type macro (`MY_APP_TYPE_WINDOW` in the above example) is not a callable, you must continue to
1593	* manually define this as a macro for yourself.
1594	*
1595	* The declaration of the `_get_type()` function is the first thing emitted by the macro. This allows this macro
1596	* to be used in the usual way with export control and API versioning macros.
1597	*
1598	* If you want to declare your own class structure, use G_DECLARE_DERIVABLE_TYPE().
1599	*
1600	* If you are writing a library, it is important to note that it is possible to convert a type from using
1601	* G_DECLARE_FINAL_TYPE() to G_DECLARE_DERIVABLE_TYPE() without breaking API or ABI. As a precaution, you
1602	* should therefore use G_DECLARE_FINAL_TYPE() until you are sure that it makes sense for your class to be
1603	* subclassed. Once a class structure has been exposed it is not possible to change its size or remove or
1604	* reorder items without breaking the API and/or ABI.
1605	*
1606	* Since: 2.44
1607	**/
1608	#define G_DECLARE_FINAL_TYPE(ModuleObjName, module_obj_name, MODULE, OBJ_NAME, ParentName) \
1609	GType module_obj_name##_get_type (void); \
1610	G_GNUC_BEGIN_IGNORE_DEPRECATIONS \
1611	typedef struct _##ModuleObjName ModuleObjName; \
1612	typedef struct { ParentName##Class parent_class; } ModuleObjName##Class; \
1613	\
1614	_GLIB_DEFINE_AUTOPTR_CHAINUP (ModuleObjName, ParentName) \
1615	G_DEFINE_AUTOPTR_CLEANUP_FUNC (ModuleObjName##Class, g_type_class_unref) \
1616	\
1617	G_GNUC_UNUSED static inline ModuleObjName * MODULE##_##OBJ_NAME (gpointer ptr) { \
1618	return G_TYPE_CHECK_INSTANCE_CAST (ptr, module_obj_name##_get_type (), ModuleObjName); } \
1619	G_GNUC_UNUSED static inline gboolean MODULE##_IS_##OBJ_NAME (gpointer ptr) { \
1620	return G_TYPE_CHECK_INSTANCE_TYPE (ptr, module_obj_name##_get_type ()); } \
1621	G_GNUC_END_IGNORE_DEPRECATIONS
1622
1623	/**
1624	* G_DECLARE_DERIVABLE_TYPE:
1625	* @ModuleObjName: The name of the new type, in camel case (like `GtkWidget`)
1626	* @module_obj_name: The name of the new type in lowercase, with words
1627	* separated by `_` (like `gtk_widget`)
1628	* @MODULE: The name of the module, in all caps (like `GTK`)
1629	* @OBJ_NAME: The bare name of the type, in all caps (like `WIDGET`)
1630	* @ParentName: the name of the parent type, in camel case (like `GtkWidget`)
1631	*
1632	* A convenience macro for emitting the usual declarations in the
1633	* header file for a type which is intended to be subclassed.
1634	*
1635	* You might use it in a header as follows:
1636	*
1637	* \|[<!-- language="C" -->
1638	* #ifndef _gtk_frobber_h_
1639	* #define _gtk_frobber_h_
1640	*
1641	* #define GTK_TYPE_FROBBER gtk_frobber_get_type ()
1642	* GDK_AVAILABLE_IN_3_12
1643	* G_DECLARE_DERIVABLE_TYPE (GtkFrobber, gtk_frobber, GTK, FROBBER, GtkWidget)
1644	*
1645	* struct _GtkFrobberClass
1646	* {
1647	* GtkWidgetClass parent_class;
1648	*
1649	* void (* handle_frob) (GtkFrobber *frobber,
1650	* guint n_frobs);
1651	*
1652	* gpointer padding[12];
1653	* };
1654	*
1655	* GtkWidget * gtk_frobber_new (void);
1656	*
1657	* ...
1658	*
1659	* #endif
1660	* ]\|
1661	*
1662	* Since the instance structure is public it is often needed to declare a
1663	* private struct as follow in your C file:
1664	*
1665	* \|[<!-- language="C" -->
1666	* typedef struct _GtkFrobberPrivate GtkFrobberPrivate;
1667	* struct _GtkFrobberPrivate
1668	* {
1669	* ...
1670	* };
1671	* G_DEFINE_TYPE_WITH_PRIVATE (GtkFrobber, gtk_frobber, GTK_TYPE_WIDGET)
1672	* ]\|
1673	*
1674	* This results in the following things happening:
1675	*
1676	* - the usual `gtk_frobber_get_type()` function is declared with a return type of #GType
1677	*
1678	* - the `GtkFrobber` struct is created with `GtkWidget` as the first and only item. You are expected to use
1679	* a private structure from your .c file to store your instance variables.
1680	*
1681	* - the `GtkFrobberClass` type is defined as a typedef to `struct _GtkFrobberClass`, which is left undefined.
1682	* You should do this from the header file directly after you use the macro.
1683	*
1684	* - the `GTK_FROBBER()` and `GTK_FROBBER_CLASS()` casts are emitted as `static inline` functions along with
1685	* the `GTK_IS_FROBBER()` and `GTK_IS_FROBBER_CLASS()` type checking functions and `GTK_FROBBER_GET_CLASS()`
1686	* function.
1687	*
1688	* - g_autoptr() support being added for your type, based on the type of your parent class
1689	*
1690	* You can only use this function if your parent type also supports g_autoptr().
1691	*
1692	* Because the type macro (`GTK_TYPE_FROBBER` in the above example) is not a callable, you must continue to
1693	* manually define this as a macro for yourself.
1694	*
1695	* The declaration of the `_get_type()` function is the first thing emitted by the macro. This allows this macro
1696	* to be used in the usual way with export control and API versioning macros.
1697	*
1698	* If you are writing a library, it is important to note that it is possible to convert a type from using
1699	* G_DECLARE_FINAL_TYPE() to G_DECLARE_DERIVABLE_TYPE() without breaking API or ABI. As a precaution, you
1700	* should therefore use G_DECLARE_FINAL_TYPE() until you are sure that it makes sense for your class to be
1701	* subclassed. Once a class structure has been exposed it is not possible to change its size or remove or
1702	* reorder items without breaking the API and/or ABI. If you want to declare your own class structure, use
1703	* G_DECLARE_DERIVABLE_TYPE(). If you want to declare a class without exposing the class or instance
1704	* structures, use G_DECLARE_FINAL_TYPE().
1705	*
1706	* If you must use G_DECLARE_DERIVABLE_TYPE() you should be sure to include some padding at the bottom of your
1707	* class structure to leave space for the addition of future virtual functions.
1708	*
1709	* Since: 2.44
1710	**/
1711	#define G_DECLARE_DERIVABLE_TYPE(ModuleObjName, module_obj_name, MODULE, OBJ_NAME, ParentName) \
1712	GType module_obj_name##_get_type (void); \
1713	G_GNUC_BEGIN_IGNORE_DEPRECATIONS \
1714	typedef struct _##ModuleObjName ModuleObjName; \
1715	typedef struct _##ModuleObjName##Class ModuleObjName##Class; \
1716	struct _##ModuleObjName { ParentName parent_instance; }; \
1717	\
1718	_GLIB_DEFINE_AUTOPTR_CHAINUP (ModuleObjName, ParentName) \
1719	G_DEFINE_AUTOPTR_CLEANUP_FUNC (ModuleObjName##Class, g_type_class_unref) \
1720	\
1721	G_GNUC_UNUSED static inline ModuleObjName * MODULE##_##OBJ_NAME (gpointer ptr) { \
1722	return G_TYPE_CHECK_INSTANCE_CAST (ptr, module_obj_name##_get_type (), ModuleObjName); } \
1723	G_GNUC_UNUSED static inline ModuleObjName##Class * MODULE##_##OBJ_NAME##_CLASS (gpointer ptr) { \
1724	return G_TYPE_CHECK_CLASS_CAST (ptr, module_obj_name##_get_type (), ModuleObjName##Class); } \
1725	G_GNUC_UNUSED static inline gboolean MODULE##_IS_##OBJ_NAME (gpointer ptr) { \
1726	return G_TYPE_CHECK_INSTANCE_TYPE (ptr, module_obj_name##_get_type ()); } \
1727	G_GNUC_UNUSED static inline gboolean MODULE##_IS_##OBJ_NAME##_CLASS (gpointer ptr) { \
1728	return G_TYPE_CHECK_CLASS_TYPE (ptr, module_obj_name##_get_type ()); } \
1729	G_GNUC_UNUSED static inline ModuleObjName##Class * MODULE##_##OBJ_NAME##_GET_CLASS (gpointer ptr) { \
1730	return G_TYPE_INSTANCE_GET_CLASS (ptr, module_obj_name##_get_type (), ModuleObjName##Class); } \
1731	G_GNUC_END_IGNORE_DEPRECATIONS
1732
1733	/**
1734	* G_DECLARE_INTERFACE:
1735	* @ModuleObjName: The name of the new type, in camel case (like `GtkWidget`)
1736	* @module_obj_name: The name of the new type in lowercase, with words
1737	* separated by `_` (like `gtk_widget`)
1738	* @MODULE: The name of the module, in all caps (like `GTK`)
1739	* @OBJ_NAME: The bare name of the type, in all caps (like `WIDGET`)
1740	* @PrerequisiteName: the name of the prerequisite type, in camel case (like `GtkWidget`)
1741	*
1742	* A convenience macro for emitting the usual declarations in the header file for a #GInterface type.
1743	*
1744	* You might use it in a header as follows:
1745	*
1746	* \|[<!-- language="C" -->
1747	* #ifndef _my_model_h_
1748	* #define _my_model_h_
1749	*
1750	* #define MY_TYPE_MODEL my_model_get_type ()
1751	* GDK_AVAILABLE_IN_3_12
1752	* G_DECLARE_INTERFACE (MyModel, my_model, MY, MODEL, GObject)
1753	*
1754	* struct _MyModelInterface
1755	* {
1756	* GTypeInterface g_iface;
1757	*
1758	* gpointer (* get_item) (MyModel *model);
1759	* };
1760	*
1761	* gpointer my_model_get_item (MyModel *model);
1762	*
1763	* ...
1764	*
1765	* #endif
1766	* ]\|
1767	*
1768	* And use it as follow in your C file:
1769	*
1770	* \|[<!-- language="C" -->
1771	* G_DEFINE_INTERFACE (MyModel, my_model, G_TYPE_OBJECT);
1772	*
1773	* static void
1774	* my_model_default_init (MyModelInterface *iface)
1775	* {
1776	* ...
1777	* }
1778	* ]\|
1779	*
1780	* This results in the following things happening:
1781	*
1782	* - the usual `my_model_get_type()` function is declared with a return type of #GType
1783	*
1784	* - the `MyModelInterface` type is defined as a typedef to `struct _MyModelInterface`,
1785	* which is left undefined. You should do this from the header file directly after
1786	* you use the macro.
1787	*
1788	* - the `MY_MODEL()` cast is emitted as `static inline` functions along with
1789	* the `MY_IS_MODEL()` type checking function and `MY_MODEL_GET_IFACE()` function.
1790	*
1791	* - g_autoptr() support being added for your type, based on your prerequisite type.
1792	*
1793	* You can only use this function if your prerequisite type also supports g_autoptr().
1794	*
1795	* Because the type macro (`MY_TYPE_MODEL` in the above example) is not a callable, you must continue to
1796	* manually define this as a macro for yourself.
1797	*
1798	* The declaration of the `_get_type()` function is the first thing emitted by the macro. This allows this macro
1799	* to be used in the usual way with export control and API versioning macros.
1800	*
1801	* Since: 2.44
1802	**/
1803	#define G_DECLARE_INTERFACE(ModuleObjName, module_obj_name, MODULE, OBJ_NAME, PrerequisiteName) \
1804	GType module_obj_name##_get_type (void); \
1805	G_GNUC_BEGIN_IGNORE_DEPRECATIONS \
1806	typedef struct _##ModuleObjName ModuleObjName; \
1807	typedef struct _##ModuleObjName##Interface ModuleObjName##Interface; \
1808	\
1809	_GLIB_DEFINE_AUTOPTR_CHAINUP (ModuleObjName, PrerequisiteName) \
1810	\
1811	G_GNUC_UNUSED static inline ModuleObjName * MODULE##_##OBJ_NAME (gpointer ptr) { \
1812	return G_TYPE_CHECK_INSTANCE_CAST (ptr, module_obj_name##_get_type (), ModuleObjName); } \
1813	G_GNUC_UNUSED static inline gboolean MODULE##_IS_##OBJ_NAME (gpointer ptr) { \
1814	return G_TYPE_CHECK_INSTANCE_TYPE (ptr, module_obj_name##_get_type ()); } \
1815	G_GNUC_UNUSED static inline ModuleObjName##Interface * MODULE##_##OBJ_NAME##_GET_IFACE (gpointer ptr) { \
1816	return G_TYPE_INSTANCE_GET_INTERFACE (ptr, module_obj_name##_get_type (), ModuleObjName##Interface); } \
1817	G_GNUC_END_IGNORE_DEPRECATIONS
1818
1819	/**
1820	* G_DEFINE_TYPE:
1821	* @TN: The name of the new type, in Camel case.
1822	* @t_n: The name of the new type, in lowercase, with words
1823	* separated by `_`.
1824	* @T_P: The #GType of the parent type.
1825	*
1826	* A convenience macro for type implementations, which declares a class
1827	* initialization function, an instance initialization function (see #GTypeInfo
1828	* for information about these) and a static variable named `t_n_parent_class`
1829	* pointing to the parent class. Furthermore, it defines a `*_get_type()` function.
1830	* See G_DEFINE_TYPE_EXTENDED() for an example.
1831	*
1832	* Since: 2.4
1833	*/
1834	#define G_DEFINE_TYPE(TN, t_n, T_P) G_DEFINE_TYPE_EXTENDED (TN, t_n, T_P, 0, {})
1835	/**
1836	* G_DEFINE_TYPE_WITH_CODE:
1837	* @TN: The name of the new type, in Camel case.
1838	* @t_n: The name of the new type in lowercase, with words separated by `_`.
1839	* @T_P: The #GType of the parent type.
1840	* @_C_: Custom code that gets inserted in the `*_get_type()` function.
1841	*
1842	* A convenience macro for type implementations.
1843	*
1844	* Similar to G_DEFINE_TYPE(), but allows you to insert custom code into the
1845	* `*_get_type()` function, e.g. interface implementations via G_IMPLEMENT_INTERFACE().
1846	* See G_DEFINE_TYPE_EXTENDED() for an example.
1847	*
1848	* Since: 2.4
1849	*/
1850	#define G_DEFINE_TYPE_WITH_CODE(TN, t_n, T_P, _C_) _G_DEFINE_TYPE_EXTENDED_BEGIN (TN, t_n, T_P, 0) {_C_;} _G_DEFINE_TYPE_EXTENDED_END()
1851	/**
1852	* G_DEFINE_TYPE_WITH_PRIVATE:
1853	* @TN: The name of the new type, in Camel case.
1854	* @t_n: The name of the new type, in lowercase, with words
1855	* separated by `_`.
1856	* @T_P: The #GType of the parent type.
1857	*
1858	* A convenience macro for type implementations, which declares a class
1859	* initialization function, an instance initialization function (see #GTypeInfo
1860	* for information about these), a static variable named `t_n_parent_class`
1861	* pointing to the parent class, and adds private instance data to the type.
1862	*
1863	* Furthermore, it defines a `*_get_type()` function. See G_DEFINE_TYPE_EXTENDED()
1864	* for an example.
1865	*
1866	* Note that private structs added with this macros must have a struct
1867	* name of the form `TN ## Private`.
1868	*
1869	* The private instance data can be retrieved using the automatically generated
1870	* getter function `t_n_get_instance_private()`.
1871	*
1872	* See also: G_ADD_PRIVATE()
1873	*
1874	* Since: 2.38
1875	*/
1876	#define G_DEFINE_TYPE_WITH_PRIVATE(TN, t_n, T_P) G_DEFINE_TYPE_EXTENDED (TN, t_n, T_P, 0, G_ADD_PRIVATE (TN))
1877	/**
1878	* G_DEFINE_ABSTRACT_TYPE:
1879	* @TN: The name of the new type, in Camel case.
1880	* @t_n: The name of the new type, in lowercase, with words
1881	* separated by `_`.
1882	* @T_P: The #GType of the parent type.
1883	*
1884	* A convenience macro for type implementations.
1885	*
1886	* Similar to G_DEFINE_TYPE(), but defines an abstract type.
1887	* See G_DEFINE_TYPE_EXTENDED() for an example.
1888	*
1889	* Since: 2.4
1890	*/
1891	#define G_DEFINE_ABSTRACT_TYPE(TN, t_n, T_P) G_DEFINE_TYPE_EXTENDED (TN, t_n, T_P, G_TYPE_FLAG_ABSTRACT, {})
1892	/**
1893	* G_DEFINE_ABSTRACT_TYPE_WITH_CODE:
1894	* @TN: The name of the new type, in Camel case.
1895	* @t_n: The name of the new type, in lowercase, with words
1896	* separated by `_`.
1897	* @T_P: The #GType of the parent type.
1898	* @_C_: Custom code that gets inserted in the `type_name_get_type()` function.
1899	*
1900	* A convenience macro for type implementations.
1901	*
1902	* Similar to G_DEFINE_TYPE_WITH_CODE(), but defines an abstract type and
1903	* allows you to insert custom code into the `*_get_type()` function, e.g.
1904	* interface implementations via G_IMPLEMENT_INTERFACE().
1905	*
1906	* See G_DEFINE_TYPE_EXTENDED() for an example.
1907	*
1908	* Since: 2.4
1909	*/
1910	#define G_DEFINE_ABSTRACT_TYPE_WITH_CODE(TN, t_n, T_P, _C_) _G_DEFINE_TYPE_EXTENDED_BEGIN (TN, t_n, T_P, G_TYPE_FLAG_ABSTRACT) {_C_;} _G_DEFINE_TYPE_EXTENDED_END()
1911	/**
1912	* G_DEFINE_ABSTRACT_TYPE_WITH_PRIVATE:
1913	* @TN: The name of the new type, in Camel case.
1914	* @t_n: The name of the new type, in lowercase, with words
1915	* separated by `_`.
1916	* @T_P: The #GType of the parent type.
1917	*
1918	* Similar to G_DEFINE_TYPE_WITH_PRIVATE(), but defines an abstract type.
1919	*
1920	* See G_DEFINE_TYPE_EXTENDED() for an example.
1921	*
1922	* Since: 2.38
1923	*/
1924	#define G_DEFINE_ABSTRACT_TYPE_WITH_PRIVATE(TN, t_n, T_P) G_DEFINE_TYPE_EXTENDED (TN, t_n, T_P, G_TYPE_FLAG_ABSTRACT, G_ADD_PRIVATE (TN))
1925	/**
1926	* G_DEFINE_FINAL_TYPE:
1927	* @TN: the name of the new type, in Camel case
1928	* @t_n: the name of the new type, in lower case, with words
1929	* separated by `_` (snake case)
1930	* @T_P: the #GType of the parent type
1931	*
1932	* A convenience macro for type implementations.
1933	*
1934	* Similar to G_DEFINE_TYPE(), but defines a final type.
1935	*
1936	* See G_DEFINE_TYPE_EXTENDED() for an example.
1937	*
1938	* Since: 2.70
1939	*/
1940	#define G_DEFINE_FINAL_TYPE(TN, t_n, T_P) G_DEFINE_TYPE_EXTENDED (TN, t_n, T_P, G_TYPE_FLAG_FINAL, {}) GOBJECT_AVAILABLE_MACRO_IN_2_70
1941	/**
1942	* G_DEFINE_FINAL_TYPE_WITH_CODE:
1943	* @TN: the name of the new type, in Camel case
1944	* @t_n: the name of the new type, in lower case, with words
1945	* separated by `_` (snake case)
1946	* @T_P: the #GType of the parent type
1947	* @_C_: Custom code that gets inserted in the `type_name_get_type()` function.
1948	*
1949	* A convenience macro for type implementations.
1950	*
1951	* Similar to G_DEFINE_TYPE_WITH_CODE(), but defines a final type and
1952	* allows you to insert custom code into the `*_get_type()` function, e.g.
1953	* interface implementations via G_IMPLEMENT_INTERFACE().
1954	*
1955	* See G_DEFINE_TYPE_EXTENDED() for an example.
1956	*
1957	* Since: 2.70
1958	*/
1959	#define G_DEFINE_FINAL_TYPE_WITH_CODE(TN, t_n, T_P, _C_) _G_DEFINE_TYPE_EXTENDED_BEGIN (TN, t_n, T_P, G_TYPE_FLAG_FINAL) {_C_;} _G_DEFINE_TYPE_EXTENDED_END() GOBJECT_AVAILABLE_MACRO_IN_2_70
1960	/**
1961	* G_DEFINE_FINAL_TYPE_WITH_PRIVATE:
1962	* @TN: the name of the new type, in Camel case
1963	* @t_n: the name of the new type, in lower case, with words
1964	* separated by `_` (snake case)
1965	* @T_P: the #GType of the parent type
1966	*
1967	* A convenience macro for type implementations.
1968	*
1969	* Similar to G_DEFINE_TYPE_WITH_PRIVATE(), but defines a final type.
1970	*
1971	* See G_DEFINE_TYPE_EXTENDED() for an example.
1972	*
1973	* Since: 2.70
1974	*/
1975	#define G_DEFINE_FINAL_TYPE_WITH_PRIVATE(TN, t_n, T_P) G_DEFINE_TYPE_EXTENDED (TN, t_n, T_P, G_TYPE_FLAG_FINAL, G_ADD_PRIVATE (TN)) GOBJECT_AVAILABLE_MACRO_IN_2_70
1976	/**
1977	* G_DEFINE_TYPE_EXTENDED:
1978	* @TN: The name of the new type, in Camel case.
1979	* @t_n: The name of the new type, in lowercase, with words
1980	* separated by `_`.
1981	* @T_P: The #GType of the parent type.
1982	* @_f_: #GTypeFlags to pass to g_type_register_static()
1983	* @_C_: Custom code that gets inserted in the `*_get_type()` function.
1984	*
1985	* The most general convenience macro for type implementations, on which
1986	* G_DEFINE_TYPE(), etc are based.
1987	*
1988	* \|[<!-- language="C" -->
1989	* G_DEFINE_TYPE_EXTENDED (GtkGadget,
1990	* gtk_gadget,
1991	* GTK_TYPE_WIDGET,
1992	* 0,
1993	* G_ADD_PRIVATE (GtkGadget)
1994	* G_IMPLEMENT_INTERFACE (TYPE_GIZMO,
1995	* gtk_gadget_gizmo_init));
1996	* ]\|
1997	*
1998	* expands to
1999	*
2000	* \|[<!-- language="C" -->
2001	* static void gtk_gadget_init (GtkGadget *self);
2002	* static void gtk_gadget_class_init (GtkGadgetClass *klass);
2003	* static gpointer gtk_gadget_parent_class = NULL;
2004	* static gint GtkGadget_private_offset;
2005	* static void gtk_gadget_class_intern_init (gpointer klass)
2006	* {
2007	* gtk_gadget_parent_class = g_type_class_peek_parent (klass);
2008	* if (GtkGadget_private_offset != 0)
2009	* g_type_class_adjust_private_offset (klass, &GtkGadget_private_offset);
2010	* gtk_gadget_class_init ((GtkGadgetClass*) klass);
2011	* }
2012	* static inline gpointer gtk_gadget_get_instance_private (GtkGadget *self)
2013	* {
2014	* return (G_STRUCT_MEMBER_P (self, GtkGadget_private_offset));
2015	* }
2016	*
2017	* GType
2018	* gtk_gadget_get_type (void)
2019	* {
2020	* static GType static_g_define_type_id = 0;
2021	* if (g_once_init_enter_pointer (&static_g_define_type_id))
2022	* {
2023	* GType g_define_type_id =
2024	* g_type_register_static_simple (GTK_TYPE_WIDGET,
2025	* g_intern_static_string ("GtkGadget"),
2026	* sizeof (GtkGadgetClass),
2027	* (GClassInitFunc) gtk_gadget_class_intern_init,
2028	* sizeof (GtkGadget),
2029	* (GInstanceInitFunc) gtk_gadget_init,
2030	* 0);
2031	* {
2032	* GtkGadget_private_offset =
2033	* g_type_add_instance_private (g_define_type_id, sizeof (GtkGadgetPrivate));
2034	* }
2035	* {
2036	* const GInterfaceInfo g_implement_interface_info = {
2037	* (GInterfaceInitFunc) gtk_gadget_gizmo_init
2038	* };
2039	* g_type_add_interface_static (g_define_type_id, TYPE_GIZMO, &g_implement_interface_info);
2040	* }
2041	* g_once_init_leave_pointer (&static_g_define_type_id, g_define_type_id);
2042	* }
2043	* return static_g_define_type_id;
2044	* }
2045	* ]\|
2046	*
2047	* The only pieces which have to be manually provided are the definitions of
2048	* the instance and class structure and the definitions of the instance and
2049	* class init functions.
2050	*
2051	* Since: 2.4
2052	*/
2053	#define G_DEFINE_TYPE_EXTENDED(TN, t_n, T_P, _f_, _C_) _G_DEFINE_TYPE_EXTENDED_BEGIN (TN, t_n, T_P, _f_) {_C_;} _G_DEFINE_TYPE_EXTENDED_END()
2054
2055	/**
2056	* G_DEFINE_INTERFACE:
2057	* @TN: The name of the new type, in Camel case.
2058	* @t_n: The name of the new type, in lowercase, with words separated by `_`.
2059	* @T_P: The #GType of the prerequisite type for the interface, or %G_TYPE_INVALID
2060	* for no prerequisite type.
2061	*
2062	* A convenience macro for #GTypeInterface definitions, which declares
2063	* a default vtable initialization function and defines a `*_get_type()`
2064	* function.
2065	*
2066	* The macro expects the interface initialization function to have the
2067	* name `t_n ## _default_init`, and the interface structure to have the
2068	* name `TN ## Interface`.
2069	*
2070	* The initialization function has signature
2071	* `static void t_n ## _default_init (TypeName##Interface *klass);`, rather than
2072	* the full #GInterfaceInitFunc signature, for brevity and convenience. If you
2073	* need to use an initialization function with an `iface_data` argument, you
2074	* must write the #GTypeInterface definitions manually.
2075	*
2076	* Since: 2.24
2077	*/
2078	#define G_DEFINE_INTERFACE(TN, t_n, T_P) G_DEFINE_INTERFACE_WITH_CODE(TN, t_n, T_P, ;)
2079
2080	/**
2081	* G_DEFINE_INTERFACE_WITH_CODE:
2082	* @TN: The name of the new type, in Camel case.
2083	* @t_n: The name of the new type, in lowercase, with words separated by `_`.
2084	* @T_P: The #GType of the prerequisite type for the interface, or %G_TYPE_INVALID
2085	* for no prerequisite type.
2086	* @_C_: Custom code that gets inserted in the `*_get_type()` function.
2087	*
2088	* A convenience macro for #GTypeInterface definitions.
2089	*
2090	* Similar to G_DEFINE_INTERFACE(), but allows you to insert custom code
2091	* into the `*_get_type()` function, e.g. additional interface implementations
2092	* via G_IMPLEMENT_INTERFACE(), or additional prerequisite types.
2093	*
2094	* See G_DEFINE_TYPE_EXTENDED() for a similar example using
2095	* G_DEFINE_TYPE_WITH_CODE().
2096	*
2097	* Since: 2.24
2098	*/
2099	#define G_DEFINE_INTERFACE_WITH_CODE(TN, t_n, T_P, _C_) _G_DEFINE_INTERFACE_EXTENDED_BEGIN(TN, t_n, T_P) {_C_;} _G_DEFINE_INTERFACE_EXTENDED_END()
2100
2101	/**
2102	* G_IMPLEMENT_INTERFACE:
2103	* @TYPE_IFACE: The #GType of the interface to add
2104	* @iface_init: (type GInterfaceInitFunc): The interface init function, of type #GInterfaceInitFunc
2105	*
2106	* A convenience macro to ease interface addition in the `_C_` section
2107	* of G_DEFINE_TYPE_WITH_CODE() or G_DEFINE_ABSTRACT_TYPE_WITH_CODE().
2108	* See G_DEFINE_TYPE_EXTENDED() for an example.
2109	*
2110	* Note that this macro can only be used together with the `G_DEFINE_TYPE_*`
2111	* macros, since it depends on variable names from those macros.
2112	*
2113	* Since: 2.4
2114	*/
2115	#define G_IMPLEMENT_INTERFACE(TYPE_IFACE, iface_init) { \
2116	const GInterfaceInfo g_implement_interface_info = { \
2117	(GInterfaceInitFunc)(void (*)(void)) iface_init, NULL, NULL \
2118	}; \
2119	g_type_add_interface_static (g_define_type_id, TYPE_IFACE, &g_implement_interface_info); \
2120	}
2121
2122	/**
2123	* G_ADD_PRIVATE:
2124	* @TypeName: the name of the type in CamelCase
2125	*
2126	* A convenience macro to ease adding private data to instances of a new type
2127	* in the @_C_ section of G_DEFINE_TYPE_WITH_CODE() or
2128	* G_DEFINE_ABSTRACT_TYPE_WITH_CODE().
2129	*
2130	* For instance:
2131	*
2132	* \|[<!-- language="C" -->
2133	* typedef struct _MyObject MyObject;
2134	* typedef struct _MyObjectClass MyObjectClass;
2135	*
2136	* typedef struct {
2137	* gint foo;
2138	* gint bar;
2139	* } MyObjectPrivate;
2140	*
2141	* G_DEFINE_TYPE_WITH_CODE (MyObject, my_object, G_TYPE_OBJECT,
2142	* G_ADD_PRIVATE (MyObject))
2143	* ]\|
2144	*
2145	* Will add `MyObjectPrivate` as the private data to any instance of the
2146	* `MyObject` type.
2147	*
2148	* `G_DEFINE_TYPE_*` macros will automatically create a private function
2149	* based on the arguments to this macro, which can be used to safely
2150	* retrieve the private data from an instance of the type; for instance:
2151	*
2152	* \|[<!-- language="C" -->
2153	* gint
2154	* my_object_get_foo (MyObject *obj)
2155	* {
2156	* MyObjectPrivate *priv = my_object_get_instance_private (obj);
2157	*
2158	* g_return_val_if_fail (MY_IS_OBJECT (obj), 0);
2159	*
2160	* return priv->foo;
2161	* }
2162	*
2163	* void
2164	* my_object_set_bar (MyObject *obj,
2165	* gint bar)
2166	* {
2167	* MyObjectPrivate *priv = my_object_get_instance_private (obj);
2168	*
2169	* g_return_if_fail (MY_IS_OBJECT (obj));
2170	*
2171	* if (priv->bar != bar)
2172	* priv->bar = bar;
2173	* }
2174	* ]\|
2175	*
2176	* Since GLib 2.72, the returned `MyObjectPrivate` pointer is guaranteed to be
2177	* aligned to at least the alignment of the largest basic GLib type (typically
2178	* this is #guint64 or #gdouble). If you need larger alignment for an element in
2179	* the struct, you should allocate it on the heap (aligned), or arrange for your
2180	* `MyObjectPrivate` struct to be appropriately padded.
2181	*
2182	* Note that this macro can only be used together with the `G_DEFINE_TYPE_*`
2183	* macros, since it depends on variable names from those macros.
2184	*
2185	* Also note that private structs added with these macros must have a struct
2186	* name of the form `TypeNamePrivate`.
2187	*
2188	* It is safe to call the `_get_instance_private` function on %NULL or invalid
2189	* objects since it's only adding an offset to the instance pointer. In that
2190	* case the returned pointer must not be dereferenced.
2191	*
2192	* Since: 2.38
2193	*/
2194	#define G_ADD_PRIVATE(TypeName) { \
2195	TypeName##_private_offset = \
2196	g_type_add_instance_private (g_define_type_id, sizeof (TypeName##Private)); \
2197	}
2198
2199	/**
2200	* G_PRIVATE_OFFSET:
2201	* @TypeName: the name of the type in CamelCase
2202	* @field: the name of the field in the private data structure
2203	*
2204	* Evaluates to the offset of the @field inside the instance private data
2205	* structure for @TypeName.
2206	*
2207	* Note that this macro can only be used together with the `G_DEFINE_TYPE_*`
2208	* and G_ADD_PRIVATE() macros, since it depends on variable names from
2209	* those macros.
2210	*
2211	* Since: 2.38
2212	*/
2213	#define G_PRIVATE_OFFSET(TypeName, field) \
2214	(TypeName##_private_offset + (G_STRUCT_OFFSET (TypeName##Private, field)))
2215
2216	/**
2217	* G_PRIVATE_FIELD_P:
2218	* @TypeName: the name of the type in CamelCase
2219	* @inst: the instance of @TypeName you wish to access
2220	* @field_name: the name of the field in the private data structure
2221	*
2222	* Evaluates to a pointer to the @field_name inside the @inst private data
2223	* structure for @TypeName.
2224	*
2225	* Note that this macro can only be used together with the `G_DEFINE_TYPE_*`
2226	* and G_ADD_PRIVATE() macros, since it depends on variable names from
2227	* those macros.
2228	*
2229	* Since: 2.38
2230	*/
2231	#define G_PRIVATE_FIELD_P(TypeName, inst, field_name) \
2232	G_STRUCT_MEMBER_P (inst, G_PRIVATE_OFFSET (TypeName, field_name))
2233
2234	/**
2235	* G_PRIVATE_FIELD:
2236	* @TypeName: the name of the type in CamelCase
2237	* @inst: the instance of @TypeName you wish to access
2238	* @field_type: the type of the field in the private data structure
2239	* @field_name: the name of the field in the private data structure
2240	*
2241	* Evaluates to the @field_name inside the @inst private data
2242	* structure for @TypeName.
2243	*
2244	* Note that this macro can only be used together with the `G_DEFINE_TYPE_*`
2245	* and G_ADD_PRIVATE() macros, since it depends on variable names from
2246	* those macros.
2247	*
2248	* Since: 2.38
2249	*/
2250	#define G_PRIVATE_FIELD(TypeName, inst, field_type, field_name) \
2251	G_STRUCT_MEMBER (field_type, inst, G_PRIVATE_OFFSET (TypeName, field_name))
2252
2253	/ we need to have this macro under conditional expansion, as it references*
2254	* a function that has been added in 2.38. see bug:
2255	* https://bugzilla.gnome.org/show_bug.cgi?id=703191
2256	*/
2257	#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
2258	#define _G_DEFINE_TYPE_EXTENDED_CLASS_INIT(TypeName, type_name) \
2259	static void type_name##_class_intern_init (gpointer klass) \
2260	{ \
2261	type_name##_parent_class = g_type_class_peek_parent (klass); \
2262	if (TypeName##_private_offset != 0) \
2263	g_type_class_adjust_private_offset (klass, &TypeName##_private_offset); \
2264	type_name##_class_init ((TypeName##Class*) klass); \
2265	}
2266
2267	#else
2268	#define _G_DEFINE_TYPE_EXTENDED_CLASS_INIT(TypeName, type_name) \
2269	static void type_name##_class_intern_init (gpointer klass) \
2270	{ \
2271	type_name##_parent_class = g_type_class_peek_parent (klass); \
2272	type_name##_class_init ((TypeName##Class*) klass); \
2273	}
2274	#endif /* GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38 */
2275
2276	#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_80
2277	#define _g_type_once_init_type GType
2278	#define _g_type_once_init_enter g_once_init_enter_pointer
2279	#define _g_type_once_init_leave g_once_init_leave_pointer
2280	#else /* if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_80 */
2281	#define _g_type_once_init_type gsize
2282	#define _g_type_once_init_enter g_once_init_enter
2283	#define _g_type_once_init_leave g_once_init_leave
2284	#endif /* GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_80 */
2285
2286	/ Added for _G_DEFINE_TYPE_EXTENDED_WITH_PRELUDE /
2287	#define _G_DEFINE_TYPE_EXTENDED_BEGIN_PRE(TypeName, type_name) \
2288	\
2289	static void type_name##_init (TypeName *self); \
2290	static void type_name##_class_init (TypeName##Class *klass); \
2291	static GType type_name##_get_type_once (void); \
2292	static gpointer type_name##_parent_class = NULL; \
2293	static gint TypeName##_private_offset; \
2294	\
2295	_G_DEFINE_TYPE_EXTENDED_CLASS_INIT(TypeName, type_name) \
2296	\
2297	G_GNUC_UNUSED \
2298	static inline gpointer \
2299	type_name##_get_instance_private (TypeName *self) \
2300	{ \
2301	return (G_STRUCT_MEMBER_P (self, TypeName##_private_offset)); \
2302	} \
2303	\
2304	GType \
2305	type_name##_get_type (void) \
2306	{ \
2307	static _g_type_once_init_type static_g_define_type_id = 0;
2308	/ Prelude goes here /
2309
2310	/ Added for _G_DEFINE_TYPE_EXTENDED_WITH_PRELUDE /
2311	#define _G_DEFINE_TYPE_EXTENDED_BEGIN_REGISTER(TypeName, type_name, TYPE_PARENT, flags) \
2312	if (_g_type_once_init_enter (&static_g_define_type_id)) \
2313	{ \
2314	GType g_define_type_id = type_name##_get_type_once (); \
2315	_g_type_once_init_leave (&static_g_define_type_id, g_define_type_id); \
2316	} \
2317	return static_g_define_type_id; \
2318	} /* closes type_name##_get_type() */ \
2319	\
2320	G_NO_INLINE \
2321	static GType \
2322	type_name##_get_type_once (void) \
2323	{ \
2324	GType g_define_type_id = \
2325	g_type_register_static_simple (TYPE_PARENT, \
2326	g_intern_static_string (#TypeName), \
2327	sizeof (TypeName##Class), \
2328	(GClassInitFunc)(void (*)(void)) type_name##_class_intern_init, \
2329	sizeof (TypeName), \
2330	(GInstanceInitFunc)(void (*)(void)) type_name##_init, \
2331	(GTypeFlags) flags); \
2332	{ /* custom code follows */
2333	#define _G_DEFINE_TYPE_EXTENDED_END() \
2334	/* following custom code */ \
2335	} \
2336	return g_define_type_id; \
2337	} /* closes type_name##_get_type_once() */
2338
2339	/ This was defined before we had _G_DEFINE_TYPE_EXTENDED_WITH_PRELUDE in*
2340	* gtype-private.h, it's simplest to keep it.
2341	*/
2342	#define _G_DEFINE_TYPE_EXTENDED_BEGIN(TypeName, type_name, TYPE_PARENT, flags) \
2343	_G_DEFINE_TYPE_EXTENDED_BEGIN_PRE (TypeName, type_name) \
2344	_G_DEFINE_TYPE_EXTENDED_BEGIN_REGISTER (TypeName, type_name, TYPE_PARENT, flags)
2345
2346	/ Intentionally using (GTypeFlags) 0 instead of G_TYPE_FLAG_NONE here,*
2347	* to avoid deprecation warnings with older GLIB_VERSION_MAX_ALLOWED */
2348	#define _G_DEFINE_INTERFACE_EXTENDED_BEGIN(TypeName, type_name, TYPE_PREREQ) \
2349	\
2350	static void type_name##_default_init (TypeName##Interface *klass); \
2351	\
2352	GType \
2353	type_name##_get_type (void) \
2354	{ \
2355	static _g_type_once_init_type static_g_define_type_id = 0; \
2356	if (_g_type_once_init_enter (&static_g_define_type_id)) \
2357	{ \
2358	GType g_define_type_id = \
2359	g_type_register_static_simple (G_TYPE_INTERFACE, \
2360	g_intern_static_string (#TypeName), \
2361	sizeof (TypeName##Interface), \
2362	(GClassInitFunc)(void (*)(void)) type_name##_default_init, \
2363	0, \
2364	(GInstanceInitFunc)NULL, \
2365	(GTypeFlags) 0); \
2366	if (TYPE_PREREQ != G_TYPE_INVALID) \
2367	g_type_interface_add_prerequisite (g_define_type_id, TYPE_PREREQ); \
2368	{ /* custom code follows */
2369	#define _G_DEFINE_INTERFACE_EXTENDED_END() \
2370	/* following custom code */ \
2371	} \
2372	_g_type_once_init_leave (&static_g_define_type_id, g_define_type_id); \
2373	} \
2374	return static_g_define_type_id; \
2375	} /* closes type_name##_get_type() */
2376
2377	/**
2378	* G_DEFINE_BOXED_TYPE:
2379	* @TypeName: The name of the new type, in Camel case
2380	* @type_name: The name of the new type, in lowercase, with words
2381	* separated by `_`
2382	* @copy_func: the #GBoxedCopyFunc for the new type
2383	* @free_func: the #GBoxedFreeFunc for the new type
2384	*
2385	* A convenience macro for defining a new custom boxed type.
2386	*
2387	* Using this macro is the recommended way of defining new custom boxed
2388	* types, over calling g_boxed_type_register_static() directly. It defines
2389	* a `type_name_get_type()` function which will return the newly defined
2390	* #GType, enabling lazy instantiation.
2391	*
2392	* You might start by putting declarations in a header as follows:
2393	*
2394	* \|[<!-- language="C" -->
2395	* #define MY_TYPE_STRUCT my_struct_get_type ()
2396	* GType my_struct_get_type (void) G_GNUC_CONST;
2397	*
2398	* MyStruct * my_struct_new (void);
2399	* void my_struct_free (MyStruct *self);
2400	* MyStruct * my_struct_copy (MyStruct *self);
2401	* ]\|
2402	*
2403	* And then use this macro and define your implementation in the source file as
2404	* follows:
2405	*
2406	* \|[<!-- language="C" -->
2407	* MyStruct *
2408	* my_struct_new (void)
2409	* {
2410	* // ... your code to allocate a new MyStruct ...
2411	* }
2412	*
2413	* void
2414	* my_struct_free (MyStruct *self)
2415	* {
2416	* // ... your code to free a MyStruct ...
2417	* }
2418	*
2419	* MyStruct *
2420	* my_struct_copy (MyStruct *self)
2421	* {
2422	* // ... your code return a newly allocated copy of a MyStruct ...
2423	* }
2424	*
2425	* G_DEFINE_BOXED_TYPE (MyStruct, my_struct, my_struct_copy, my_struct_free)
2426	*
2427	* void
2428	* foo ()
2429	* {
2430	* MyStruct *ms;
2431	*
2432	* ms = my_struct_new ();
2433	* // ... your code ...
2434	* my_struct_free (ms);
2435	* }
2436	* ]\|
2437	*
2438	* Since: 2.26
2439	*/
2440	#define G_DEFINE_BOXED_TYPE(TypeName, type_name, copy_func, free_func) G_DEFINE_BOXED_TYPE_WITH_CODE (TypeName, type_name, copy_func, free_func, {})
2441	/**
2442	* G_DEFINE_BOXED_TYPE_WITH_CODE:
2443	* @TypeName: The name of the new type, in Camel case
2444	* @type_name: The name of the new type, in lowercase, with words
2445	* separated by `_`
2446	* @copy_func: the #GBoxedCopyFunc for the new type
2447	* @free_func: the #GBoxedFreeFunc for the new type
2448	* @_C_: Custom code that gets inserted in the `*_get_type()` function
2449	*
2450	* A convenience macro for boxed type implementations.
2451	*
2452	* Similar to G_DEFINE_BOXED_TYPE(), but allows to insert custom code into the
2453	* `type_name_get_type()` function, e.g. to register value transformations with
2454	* g_value_register_transform_func(), for instance:
2455	*
2456	* \|[<!-- language="C" -->
2457	* G_DEFINE_BOXED_TYPE_WITH_CODE (GdkRectangle, gdk_rectangle,
2458	* gdk_rectangle_copy,
2459	* gdk_rectangle_free,
2460	* register_rectangle_transform_funcs (g_define_type_id))
2461	* ]\|
2462	*
2463	* Similarly to the `G_DEFINE_TYPE_*` family of macros, the #GType of the newly
2464	* defined boxed type is exposed in the `g_define_type_id` variable.
2465	*
2466	* Since: 2.26
2467	*/
2468	#define G_DEFINE_BOXED_TYPE_WITH_CODE(TypeName, type_name, copy_func, free_func, _C_) _G_DEFINE_BOXED_TYPE_BEGIN (TypeName, type_name, copy_func, free_func) {_C_;} _G_DEFINE_TYPE_EXTENDED_END()
2469
2470	/ Only use this in non-C++ on GCC >= 2.7, except for Darwin/ppc64.*
2471	* See https://bugzilla.gnome.org/show_bug.cgi?id=647145
2472	*/
2473	#if !defined (G_CXX_STD_VERSION) && (G_GNUC_CHECK_VERSION(2, 7)) && \
2474	!(defined (__APPLE__) && defined (__ppc64__))
2475	#define _G_DEFINE_BOXED_TYPE_BEGIN(TypeName, type_name, copy_func, free_func) \
2476	static GType type_name##_get_type_once (void); \
2477	\
2478	GType \
2479	type_name##_get_type (void) \
2480	{ \
2481	static _g_type_once_init_type static_g_define_type_id = 0; \
2482	if (_g_type_once_init_enter (&static_g_define_type_id)) \
2483	{ \
2484	GType g_define_type_id = type_name##_get_type_once (); \
2485	_g_type_once_init_leave (&static_g_define_type_id, g_define_type_id); \
2486	} \
2487	return static_g_define_type_id; \
2488	} \
2489	\
2490	G_NO_INLINE \
2491	static GType \
2492	type_name##_get_type_once (void) \
2493	{ \
2494	GType (* _g_register_boxed) \
2495	(const gchar *, \
2496	union \
2497	{ \
2498	TypeName * (do_copy_type) (TypeName ); \
2499	TypeName * (do_const_copy_type) (const TypeName ); \
2500	GBoxedCopyFunc do_copy_boxed; \
2501	} __attribute__((__transparent_union__)), \
2502	union \
2503	{ \
2504	void (* do_free_type) (TypeName *); \
2505	GBoxedFreeFunc do_free_boxed; \
2506	} __attribute__((__transparent_union__)) \
2507	) = g_boxed_type_register_static; \
2508	GType g_define_type_id = \
2509	_g_register_boxed (g_intern_static_string (#TypeName), copy_func, free_func); \
2510	{ /* custom code follows */
2511	#else
2512	#define _G_DEFINE_BOXED_TYPE_BEGIN(TypeName, type_name, copy_func, free_func) \
2513	static GType type_name##_get_type_once (void); \
2514	\
2515	GType \
2516	type_name##_get_type (void) \
2517	{ \
2518	static _g_type_once_init_type static_g_define_type_id = 0; \
2519	if (_g_type_once_init_enter (&static_g_define_type_id)) \
2520	{ \
2521	GType g_define_type_id = type_name##_get_type_once (); \
2522	_g_type_once_init_leave (&static_g_define_type_id, g_define_type_id); \
2523	} \
2524	return static_g_define_type_id; \
2525	} \
2526	\
2527	G_NO_INLINE \
2528	static GType \
2529	type_name##_get_type_once (void) \
2530	{ \
2531	GType g_define_type_id = \
2532	g_boxed_type_register_static (g_intern_static_string (#TypeName), \
2533	(GBoxedCopyFunc) copy_func, \
2534	(GBoxedFreeFunc) free_func); \
2535	{ /* custom code follows */
2536	#endif /* __GNUC__ */
2537
2538	/**
2539	* G_DEFINE_POINTER_TYPE:
2540	* @TypeName: The name of the new type, in Camel case
2541	* @type_name: The name of the new type, in lowercase, with words
2542	* separated by `_`
2543	*
2544	* A convenience macro for pointer type implementations, which defines a
2545	* `type_name_get_type()` function registering the pointer type.
2546	*
2547	* Since: 2.26
2548	*/
2549	#define G_DEFINE_POINTER_TYPE(TypeName, type_name) G_DEFINE_POINTER_TYPE_WITH_CODE (TypeName, type_name, {})
2550	/**
2551	* G_DEFINE_POINTER_TYPE_WITH_CODE:
2552	* @TypeName: The name of the new type, in Camel case
2553	* @type_name: The name of the new type, in lowercase, with words
2554	* separated by `_`
2555	* @_C_: Custom code that gets inserted in the `*_get_type()` function
2556	*
2557	* A convenience macro for pointer type implementations.
2558	* Similar to G_DEFINE_POINTER_TYPE(), but allows to insert
2559	* custom code into the `type_name_get_type()` function.
2560	*
2561	* Since: 2.26
2562	*/
2563	#define G_DEFINE_POINTER_TYPE_WITH_CODE(TypeName, type_name, _C_) _G_DEFINE_POINTER_TYPE_BEGIN (TypeName, type_name) {_C_;} _G_DEFINE_TYPE_EXTENDED_END()
2564
2565	#define _G_DEFINE_POINTER_TYPE_BEGIN(TypeName, type_name) \
2566	static GType type_name##_get_type_once (void); \
2567	\
2568	GType \
2569	type_name##_get_type (void) \
2570	{ \
2571	static _g_type_once_init_type static_g_define_type_id = 0; \
2572	if (_g_type_once_init_enter (&static_g_define_type_id)) \
2573	{ \
2574	GType g_define_type_id = type_name##_get_type_once (); \
2575	_g_type_once_init_leave (&static_g_define_type_id, g_define_type_id); \
2576	} \
2577	return static_g_define_type_id; \
2578	} \
2579	\
2580	G_NO_INLINE \
2581	static GType \
2582	type_name##_get_type_once (void) \
2583	{ \
2584	GType g_define_type_id = \
2585	g_pointer_type_register_static (g_intern_static_string (#TypeName)); \
2586	{ /* custom code follows */
2587
2588	/ --- protected (for fundamental type implementations) --- /
2589	GOBJECT_AVAILABLE_IN_ALL
2590	GTypePlugin* g_type_get_plugin (GType type);
2591	GOBJECT_AVAILABLE_IN_ALL
2592	GTypePlugin* g_type_interface_get_plugin (GType instance_type,
2593	GType interface_type);
2594	GOBJECT_AVAILABLE_IN_ALL
2595	GType g_type_fundamental_next (void);
2596	GOBJECT_AVAILABLE_IN_ALL
2597	GType g_type_fundamental (GType type_id);
2598	GOBJECT_AVAILABLE_IN_ALL
2599	GTypeInstance* g_type_create_instance (GType type);
2600	GOBJECT_AVAILABLE_IN_ALL
2601	void g_type_free_instance (GTypeInstance *instance);
2602
2603	GOBJECT_AVAILABLE_IN_ALL
2604	void g_type_add_class_cache_func (gpointer cache_data,
2605	GTypeClassCacheFunc cache_func);
2606	GOBJECT_AVAILABLE_IN_ALL
2607	void g_type_remove_class_cache_func (gpointer cache_data,
2608	GTypeClassCacheFunc cache_func);
2609	GOBJECT_AVAILABLE_IN_ALL
2610	void g_type_class_unref_uncached (gpointer g_class);
2611
2612	GOBJECT_AVAILABLE_IN_ALL
2613	void g_type_add_interface_check (gpointer check_data,
2614	GTypeInterfaceCheckFunc check_func);
2615	GOBJECT_AVAILABLE_IN_ALL
2616	void g_type_remove_interface_check (gpointer check_data,
2617	GTypeInterfaceCheckFunc check_func);
2618
2619	GOBJECT_AVAILABLE_IN_ALL
2620	GTypeValueTable* g_type_value_table_peek (GType type);
2621
2622
2623	/< private >/
2624	GOBJECT_AVAILABLE_IN_ALL
2625	gboolean g_type_check_instance (GTypeInstance *instance) G_GNUC_PURE;
2626	GOBJECT_AVAILABLE_IN_ALL
2627	GTypeInstance* g_type_check_instance_cast (GTypeInstance *instance,
2628	GType iface_type);
2629	GOBJECT_AVAILABLE_IN_ALL
2630	gboolean g_type_check_instance_is_a (GTypeInstance *instance,
2631	GType iface_type) G_GNUC_PURE;
2632	GOBJECT_AVAILABLE_IN_2_42
2633	gboolean g_type_check_instance_is_fundamentally_a (GTypeInstance *instance,
2634	GType fundamental_type) G_GNUC_PURE;
2635	GOBJECT_AVAILABLE_IN_ALL
2636	GTypeClass* g_type_check_class_cast (GTypeClass *g_class,
2637	GType is_a_type);
2638	GOBJECT_AVAILABLE_IN_ALL
2639	gboolean g_type_check_class_is_a (GTypeClass *g_class,
2640	GType is_a_type) G_GNUC_PURE;
2641	GOBJECT_AVAILABLE_IN_ALL
2642	gboolean g_type_check_is_value_type (GType type) G_GNUC_CONST;
2643	GOBJECT_AVAILABLE_IN_ALL
2644	gboolean g_type_check_value (const GValue *value) G_GNUC_PURE;
2645	GOBJECT_AVAILABLE_IN_ALL
2646	gboolean g_type_check_value_holds (const GValue *value,
2647	GType type) G_GNUC_PURE;
2648	GOBJECT_AVAILABLE_IN_ALL
2649	gboolean g_type_test_flags (GType type,
2650	guint flags) G_GNUC_CONST;
2651
2652
2653	/ --- debugging functions --- /
2654	GOBJECT_AVAILABLE_IN_ALL
2655	const gchar * g_type_name_from_instance (GTypeInstance *instance);
2656	GOBJECT_AVAILABLE_IN_ALL
2657	const gchar * g_type_name_from_class (GTypeClass *g_class);
2658
2659
2660	/ --- implementation bits --- /
2661	#if defined(G_DISABLE_CAST_CHECKS) \|\| defined(__OPTIMIZE__)
2662	# define _G_TYPE_CIC(ip, gt, ct) ((ct) (void ) ip)
2663	# define _G_TYPE_CCC(cp, gt, ct) ((ct) (void ) cp)
2664	#else
2665	# define _G_TYPE_CIC(ip, gt, ct) \
2666	((ct) (void ) g_type_check_instance_cast ((GTypeInstance*) ip, gt))
2667	# define _G_TYPE_CCC(cp, gt, ct) \
2668	((ct) (void ) g_type_check_class_cast ((GTypeClass*) cp, gt))
2669	#endif
2670
2671	#define _G_TYPE_CHI(ip) (g_type_check_instance ((GTypeInstance*) ip))
2672	#define _G_TYPE_CHV(vl) (g_type_check_value ((GValue*) vl))
2673	#define _G_TYPE_IGC(ip, gt, ct) ((ct) (((GTypeInstance) ip)->g_class))
2674	#define _G_TYPE_IGI(ip, gt, ct) ((ct) g_type_interface_peek (((GTypeInstance) ip)->g_class, gt))
2675	#define _G_TYPE_CIFT(ip, ft) (g_type_check_instance_is_fundamentally_a ((GTypeInstance*) ip, ft))
2676	#ifdef __GNUC__
2677	# define _G_TYPE_CIT(ip, gt) (G_GNUC_EXTENSION ({ \
2678	GTypeInstance __inst = (GTypeInstance) ip; GType __t = gt; gboolean __r; \
2679	if (!__inst) \
2680	__r = FALSE; \
2681	else if (__inst->g_class && __inst->g_class->g_type == __t) \
2682	__r = TRUE; \
2683	else \
2684	__r = g_type_check_instance_is_a (__inst, __t); \
2685	__r; \
2686	}))
2687	# define _G_TYPE_CCT(cp, gt) (G_GNUC_EXTENSION ({ \
2688	GTypeClass __class = (GTypeClass) cp; GType __t = gt; gboolean __r; \
2689	if (!__class) \
2690	__r = FALSE; \
2691	else if (__class->g_type == __t) \
2692	__r = TRUE; \
2693	else \
2694	__r = g_type_check_class_is_a (__class, __t); \
2695	__r; \
2696	}))
2697	# define _G_TYPE_CVH(vl, gt) (G_GNUC_EXTENSION ({ \
2698	const GValue __val = (const GValue) vl; GType __t = gt; gboolean __r; \
2699	if (!__val) \
2700	__r = FALSE; \
2701	else if (__val->g_type == __t) \
2702	__r = TRUE; \
2703	else \
2704	__r = g_type_check_value_holds (__val, __t); \
2705	__r; \
2706	}))
2707	#else /* !__GNUC__ */
2708	# define _G_TYPE_CIT(ip, gt) (g_type_check_instance_is_a ((GTypeInstance*) ip, gt))
2709	# define _G_TYPE_CCT(cp, gt) (g_type_check_class_is_a ((GTypeClass*) cp, gt))
2710	# define _G_TYPE_CVH(vl, gt) (g_type_check_value_holds ((const GValue*) vl, gt))
2711	#endif /* !__GNUC__ */
2712	/**
2713	* G_TYPE_FLAG_RESERVED_ID_BIT:
2714	*
2715	* A bit in the type number that's supposed to be left untouched.
2716	*/
2717	#define G_TYPE_FLAG_RESERVED_ID_BIT ((GType) (1 << 0))
2718
2719	/**
2720	* GPOINTER_TO_TYPE:
2721	* @p: The pointer to convert to a #GType
2722	*
2723	* This macro should be used instead of GPOINTER_TO_SIZE() to ensure
2724	* portability since #GType is not guaranteed to be the same as #gsize.
2725	*
2726	* Since: 2.80
2727	*/
2728	#define GPOINTER_TO_TYPE(p) ((GType) (guintptr) (p)) GOBJECT_AVAILABLE_MACRO_IN_2_80
2729	/**
2730	* GTYPE_TO_POINTER:
2731	* @t: The #GType to convert to a pointer
2732	*
2733	* This macro should be used instead of GSIZE_TO_POINTER() to ensure
2734	* portability since #GType is not guaranteed to be the same as #gsize.
2735	*
2736	* Since: 2.80
2737	*/
2738	#define GTYPE_TO_POINTER(t) ((gpointer) (guintptr) (t)) GOBJECT_AVAILABLE_MACRO_IN_2_80
2739
2740	G_END_DECLS
2741
2742	#endif /* __G_TYPE_H__ */
2743

Browse the source code of include/glib-2.0/gobject/gtype.h