1 /*
2  * This file is part of gtkD.
3  *
4  * gtkD is free software; you can redistribute it and/or modify
5  * it under the terms of the GNU Lesser General Public License
6  * as published by the Free Software Foundation; either version 3
7  * of the License, or (at your option) any later version, with
8  * some exceptions, please read the COPYING file.
9  *
10  * gtkD is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU Lesser General Public License for more details.
14  *
15  * You should have received a copy of the GNU Lesser General Public License
16  * along with gtkD; if not, write to the Free Software
17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110, USA
18  */
19 
20 // generated automatically - do not change
21 // find conversion definition on APILookup.txt
22 // implement new conversion functionalities on the wrap.utils pakage
23 
24 
25 module gtkc.gobjecttypes;
26 
27 public import gtkc.glibtypes;
28 
29 /**
30  * This is the signature of marshaller functions, required to marshall
31  * arrays of parameter values to signal emissions into C language callback
32  * invocations. It is merely an alias to #GClosureMarshal since the #GClosure
33  * mechanism takes over responsibility of actual function invocation for the
34  * signal system.
35  */
36 public alias GClosureMarshal GSignalCMarshaller;
37 
38 /**
39  * This is the signature of va_list marshaller functions, an optional
40  * marshaller that can be used in some situations to avoid
41  * marshalling the signal argument into GValues.
42  */
43 public alias GVaClosureMarshal GSignalCVaMarshaller;
44 
45 /**
46  * A value which represents the unique identifier of a registered type.
47  */
48 enum GType : size_t
49 {
50 	INVALID = 0<<2,
51 	NONE = 1<<2,
52 	INTERFACE = 2<<2,
53 	CHAR = 3<<2,
54 	UCHAR = 4<<2,
55 	BOOLEAN = 5<<2,
56 	INT = 6<<2,
57 	UINT = 7<<2,
58 	LONG = 8<<2,
59 	ULONG = 9<<2,
60 	INT64 = 10<<2,
61 	UINT64 = 11<<2,
62 	ENUM = 12<<2,
63 	FLAGS = 13<<2,
64 	FLOAT = 14<<2,
65 	DOUBLE = 15<<2,
66 	STRING = 16<<2,
67 	POINTER = 17<<2,
68 	BOXED = 18<<2,
69 	PARAM = 19<<2,
70 	OBJECT = 20<<2,
71 	VARIANT = 21<<2,
72 }
73 
74 /**
75  * Flags to be passed to g_object_bind_property() or
76  * g_object_bind_property_full().
77  *
78  * This enumeration can be extended at later date.
79  *
80  * Since: 2.26
81  */
82 public enum GBindingFlags
83 {
84 	/**
85 	 * The default binding; if the source property
86 	 * changes, the target property is updated with its value.
87 	 */
88 	DEFAULT = 0,
89 	/**
90 	 * Bidirectional binding; if either the
91 	 * property of the source or the property of the target changes,
92 	 * the other is updated.
93 	 */
94 	BIDIRECTIONAL = 1,
95 	/**
96 	 * Synchronize the values of the source and
97 	 * target properties when creating the binding; the direction of
98 	 * the synchronization is always from the source to the target.
99 	 */
100 	SYNC_CREATE = 2,
101 	/**
102 	 * If the two properties being bound are
103 	 * booleans, setting one to %TRUE will result in the other being
104 	 * set to %FALSE and vice versa. This flag will only work for
105 	 * boolean properties, and cannot be used when passing custom
106 	 * transformation functions to g_object_bind_property_full().
107 	 */
108 	INVERT_BOOLEAN = 4,
109 }
110 alias GBindingFlags BindingFlags;
111 
112 /**
113  * The connection flags are used to specify the behaviour of a signal's
114  * connection.
115  */
116 public enum GConnectFlags
117 {
118 	/**
119 	 * whether the handler should be called before or after the
120 	 * default handler of the signal.
121 	 */
122 	AFTER = 1,
123 	/**
124 	 * whether the instance and data should be swapped when
125 	 * calling the handler; see g_signal_connect_swapped() for an example.
126 	 */
127 	SWAPPED = 2,
128 }
129 alias GConnectFlags ConnectFlags;
130 
131 /**
132  * Through the #GParamFlags flag values, certain aspects of parameters
133  * can be configured. See also #G_PARAM_STATIC_STRINGS.
134  */
135 public enum GParamFlags : uint
136 {
137 	/**
138 	 * the parameter is readable
139 	 */
140 	READABLE = 1,
141 	/**
142 	 * the parameter is writable
143 	 */
144 	WRITABLE = 2,
145 	/**
146 	 * alias for %G_PARAM_READABLE | %G_PARAM_WRITABLE
147 	 */
148 	READWRITE = 3,
149 	/**
150 	 * the parameter will be set upon object construction
151 	 */
152 	CONSTRUCT = 4,
153 	/**
154 	 * the parameter can only be set upon object construction
155 	 */
156 	CONSTRUCT_ONLY = 8,
157 	/**
158 	 * upon parameter conversion (see g_param_value_convert())
159 	 * strict validation is not required
160 	 */
161 	LAX_VALIDATION = 16,
162 	/**
163 	 * the string used as name when constructing the
164 	 * parameter is guaranteed to remain valid and
165 	 * unmodified for the lifetime of the parameter.
166 	 * Since 2.8
167 	 */
168 	STATIC_NAME = 32,
169 	/**
170 	 * internal
171 	 */
172 	PRIVATE = 32,
173 	/**
174 	 * the string used as nick when constructing the
175 	 * parameter is guaranteed to remain valid and
176 	 * unmmodified for the lifetime of the parameter.
177 	 * Since 2.8
178 	 */
179 	STATIC_NICK = 64,
180 	/**
181 	 * the string used as blurb when constructing the
182 	 * parameter is guaranteed to remain valid and
183 	 * unmodified for the lifetime of the parameter.
184 	 * Since 2.8
185 	 */
186 	STATIC_BLURB = 128,
187 	/**
188 	 * calls to g_object_set_property() for this
189 	 * property will not automatically result in a "notify" signal being
190 	 * emitted: the implementation must call g_object_notify() themselves
191 	 * in case the property actually changes.  Since: 2.42.
192 	 */
193 	EXPLICIT_NOTIFY = 1073741824,
194 	/**
195 	 * the parameter is deprecated and will be removed
196 	 * in a future version. A warning will be generated if it is used
197 	 * while running with G_ENABLE_DIAGNOSTIC=1.
198 	 * Since 2.26
199 	 */
200 	DEPRECATED = 2147483648,
201 }
202 alias GParamFlags ParamFlags;
203 
204 /**
205  * The signal flags are used to specify a signal's behaviour, the overall
206  * signal description outlines how especially the RUN flags control the
207  * stages of a signal emission.
208  */
209 public enum GSignalFlags
210 {
211 	/**
212 	 * Invoke the object method handler in the first emission stage.
213 	 */
214 	RUN_FIRST = 1,
215 	/**
216 	 * Invoke the object method handler in the third emission stage.
217 	 */
218 	RUN_LAST = 2,
219 	/**
220 	 * Invoke the object method handler in the last emission stage.
221 	 */
222 	RUN_CLEANUP = 4,
223 	/**
224 	 * Signals being emitted for an object while currently being in
225 	 * emission for this very object will not be emitted recursively,
226 	 * but instead cause the first emission to be restarted.
227 	 */
228 	NO_RECURSE = 8,
229 	/**
230 	 * This signal supports "::detail" appendices to the signal name
231 	 * upon handler connections and emissions.
232 	 */
233 	DETAILED = 16,
234 	/**
235 	 * Action signals are signals that may freely be emitted on alive
236 	 * objects from user code via g_signal_emit() and friends, without
237 	 * the need of being embedded into extra code that performs pre or
238 	 * post emission adjustments on the object. They can also be thought
239 	 * of as object methods which can be called generically by
240 	 * third-party code.
241 	 */
242 	ACTION = 32,
243 	/**
244 	 * No emissions hooks are supported for this signal.
245 	 */
246 	NO_HOOKS = 64,
247 	/**
248 	 * Varargs signal emission will always collect the
249 	 * arguments, even if there are no signal handlers connected.  Since 2.30.
250 	 */
251 	MUST_COLLECT = 128,
252 	/**
253 	 * The signal is deprecated and will be removed
254 	 * in a future version. A warning will be generated if it is connected while
255 	 * running with G_ENABLE_DIAGNOSTIC=1.  Since 2.32.
256 	 */
257 	DEPRECATED = 256,
258 }
259 alias GSignalFlags SignalFlags;
260 
261 /**
262  * The match types specify what g_signal_handlers_block_matched(),
263  * g_signal_handlers_unblock_matched() and g_signal_handlers_disconnect_matched()
264  * match signals by.
265  */
266 public enum GSignalMatchType
267 {
268 	/**
269 	 * The signal id must be equal.
270 	 */
271 	ID = 1,
272 	/**
273 	 * The signal detail be equal.
274 	 */
275 	DETAIL = 2,
276 	/**
277 	 * The closure must be the same.
278 	 */
279 	CLOSURE = 4,
280 	/**
281 	 * The C closure callback must be the same.
282 	 */
283 	FUNC = 8,
284 	/**
285 	 * The closure data must be the same.
286 	 */
287 	DATA = 16,
288 	/**
289 	 * Only unblocked signals may matched.
290 	 */
291 	UNBLOCKED = 32,
292 }
293 alias GSignalMatchType SignalMatchType;
294 
295 /**
296  * These flags used to be passed to g_type_init_with_debug_flags() which
297  * is now deprecated.
298  *
299  * If you need to enable debugging features, use the GOBJECT_DEBUG
300  * environment variable.
301  *
302  * Deprecated: g_type_init() is now done automatically
303  */
304 public enum GTypeDebugFlags
305 {
306 	/**
307 	 * Print no messages
308 	 */
309 	NONE = 0,
310 	/**
311 	 * Print messages about object bookkeeping
312 	 */
313 	OBJECTS = 1,
314 	/**
315 	 * Print messages about signal emissions
316 	 */
317 	SIGNALS = 2,
318 	/**
319 	 * Keep a count of instances of each type
320 	 */
321 	INSTANCE_COUNT = 4,
322 	/**
323 	 * Mask covering all debug flags
324 	 */
325 	MASK = 7,
326 }
327 alias GTypeDebugFlags TypeDebugFlags;
328 
329 /**
330  * Bit masks used to check or determine characteristics of a type.
331  */
332 public enum GTypeFlags
333 {
334 	/**
335 	 * Indicates an abstract type. No instances can be
336 	 * created for an abstract type
337 	 */
338 	ABSTRACT = 16,
339 	/**
340 	 * Indicates an abstract value type, i.e. a type
341 	 * that introduces a value table, but can't be used for
342 	 * g_value_init()
343 	 */
344 	VALUE_ABSTRACT = 32,
345 }
346 alias GTypeFlags TypeFlags;
347 
348 /**
349  * Bit masks used to check or determine specific characteristics of a
350  * fundamental type.
351  */
352 public enum GTypeFundamentalFlags
353 {
354 	/**
355 	 * Indicates a classed type
356 	 */
357 	CLASSED = 1,
358 	/**
359 	 * Indicates an instantiable type (implies classed)
360 	 */
361 	INSTANTIATABLE = 2,
362 	/**
363 	 * Indicates a flat derivable type
364 	 */
365 	DERIVABLE = 4,
366 	/**
367 	 * Indicates a deep derivable type (implies derivable)
368 	 */
369 	DEEP_DERIVABLE = 8,
370 }
371 alias GTypeFundamentalFlags TypeFundamentalFlags;
372 
373 struct GBinding;
374 
375 /**
376  * A #GCClosure is a specialization of #GClosure for C function callbacks.
377  */
378 struct GCClosure
379 {
380 	/**
381 	 * the #GClosure
382 	 */
383 	GClosure closure;
384 	/**
385 	 * the callback function
386 	 */
387 	void* callback;
388 }
389 
390 struct GClosure
391 {
392 	import std.bitmanip: bitfields;
393 	mixin(bitfields!(
394 		uint, "refCount", 15,
395 		uint, "metaMarshalNouse", 1,
396 		uint, "nGuards", 1,
397 		uint, "nFnotifiers", 2,
398 		uint, "nInotifiers", 8,
399 		uint, "inInotify", 1,
400 		uint, "floating", 1,
401 		uint, "derivativeFlag", 1,
402 		uint, "inMarshal", 1,
403 		uint, "isInvalid", 1
404 	));
405 	/** */
406 	extern(C) void function(GClosure* closure, GValue* returnValue, uint nParamValues, GValue* paramValues, void* invocationHint, void* marshalData) marshal;
407 	void* data;
408 	GClosureNotifyData* notifiers;
409 }
410 
411 struct GClosureNotifyData
412 {
413 	void* data;
414 	GClosureNotify notify;
415 }
416 
417 /**
418  * The class of an enumeration type holds information about its
419  * possible values.
420  */
421 struct GEnumClass
422 {
423 	/**
424 	 * the parent class
425 	 */
426 	GTypeClass gTypeClass;
427 	/**
428 	 * the smallest possible value.
429 	 */
430 	int minimum;
431 	/**
432 	 * the largest possible value.
433 	 */
434 	int maximum;
435 	/**
436 	 * the number of possible values.
437 	 */
438 	uint nValues;
439 	/**
440 	 * an array of #GEnumValue structs describing the
441 	 * individual values.
442 	 */
443 	GEnumValue* values;
444 }
445 
446 /**
447  * A structure which contains a single enum value, its name, and its
448  * nickname.
449  */
450 struct GEnumValue
451 {
452 	/**
453 	 * the enum value
454 	 */
455 	int value;
456 	/**
457 	 * the name of the value
458 	 */
459 	const(char)* valueName;
460 	/**
461 	 * the nickname of the value
462 	 */
463 	const(char)* valueNick;
464 }
465 
466 /**
467  * The class of a flags type holds information about its
468  * possible values.
469  */
470 struct GFlagsClass
471 {
472 	/**
473 	 * the parent class
474 	 */
475 	GTypeClass gTypeClass;
476 	/**
477 	 * a mask covering all possible values.
478 	 */
479 	uint mask;
480 	/**
481 	 * the number of possible values.
482 	 */
483 	uint nValues;
484 	/**
485 	 * an array of #GFlagsValue structs describing the
486 	 * individual values.
487 	 */
488 	GFlagsValue* values;
489 }
490 
491 /**
492  * A structure which contains a single flags value, its name, and its
493  * nickname.
494  */
495 struct GFlagsValue
496 {
497 	/**
498 	 * the flags value
499 	 */
500 	uint value;
501 	/**
502 	 * the name of the value
503 	 */
504 	const(char)* valueName;
505 	/**
506 	 * the nickname of the value
507 	 */
508 	const(char)* valueNick;
509 }
510 
511 /**
512  * A structure that provides information to the type system which is
513  * used specifically for managing interface types.
514  */
515 struct GInterfaceInfo
516 {
517 	/**
518 	 * location of the interface initialization function
519 	 */
520 	GInterfaceInitFunc interfaceInit;
521 	/**
522 	 * location of the interface finalization function
523 	 */
524 	GInterfaceFinalizeFunc interfaceFinalize;
525 	/**
526 	 * user-supplied data passed to the interface init/finalize functions
527 	 */
528 	void* interfaceData;
529 }
530 
531 struct GObject
532 {
533 	GTypeInstance gTypeInstance;
534 	uint refCount;
535 	GData* qdata;
536 }
537 
538 struct GObjectClass
539 {
540 	/**
541 	 * the parent class
542 	 */
543 	GTypeClass gTypeClass;
544 	GSList* constructProperties;
545 	/** */
546 	extern(C) GObject* function(GType type, uint nConstructProperties, GObjectConstructParam* constructProperties) constructor;
547 	/** */
548 	extern(C) void function(GObject* object, uint propertyId, GValue* value, GParamSpec* pspec) setProperty;
549 	/** */
550 	extern(C) void function(GObject* object, uint propertyId, GValue* value, GParamSpec* pspec) getProperty;
551 	/** */
552 	extern(C) void function(GObject* object) dispose;
553 	/** */
554 	extern(C) void function(GObject* object) finalize;
555 	/** */
556 	extern(C) void function(GObject* object, uint nPspecs, GParamSpec** pspecs) dispatchPropertiesChanged;
557 	/** */
558 	extern(C) void function(GObject* object, GParamSpec* pspec) notify;
559 	/** */
560 	extern(C) void function(GObject* object) constructed;
561 	size_t flags;
562 	void*[6] pdummy;
563 }
564 
565 /**
566  * The GObjectConstructParam struct is an auxiliary
567  * structure used to hand #GParamSpec/#GValue pairs to the @constructor of
568  * a #GObjectClass.
569  */
570 struct GObjectConstructParam
571 {
572 	/**
573 	 * the #GParamSpec of the construct parameter
574 	 */
575 	GParamSpec* pspec;
576 	/**
577 	 * the value to set the parameter to
578 	 */
579 	GValue* value;
580 }
581 
582 struct GParamSpec
583 {
584 	/**
585 	 * private #GTypeInstance portion
586 	 */
587 	GTypeInstance gTypeInstance;
588 	/**
589 	 * name of this parameter: always an interned string
590 	 */
591 	const(char)* name;
592 	/**
593 	 * #GParamFlags flags for this parameter
594 	 */
595 	GParamFlags flags;
596 	/**
597 	 * the #GValue type for this parameter
598 	 */
599 	GType valueType;
600 	/**
601 	 * #GType type that uses (introduces) this parameter
602 	 */
603 	GType ownerType;
604 	char* Nick;
605 	char* Blurb;
606 	GData* qdata;
607 	uint refCount;
608 	uint paramId;
609 }
610 
611 struct GParamSpecBoolean
612 {
613 	/**
614 	 * private #GParamSpec portion
615 	 */
616 	GParamSpec parentInstance;
617 	/**
618 	 * default value for the property specified
619 	 */
620 	bool defaultValue;
621 }
622 
623 struct GParamSpecBoxed
624 {
625 	/**
626 	 * private #GParamSpec portion
627 	 */
628 	GParamSpec parentInstance;
629 }
630 
631 struct GParamSpecChar
632 {
633 	/**
634 	 * private #GParamSpec portion
635 	 */
636 	GParamSpec parentInstance;
637 	/**
638 	 * minimum value for the property specified
639 	 */
640 	byte minimum;
641 	/**
642 	 * maximum value for the property specified
643 	 */
644 	byte maximum;
645 	/**
646 	 * default value for the property specified
647 	 */
648 	byte defaultValue;
649 }
650 
651 /**
652  * The class structure for the GParamSpec type.
653  * Normally, GParamSpec classes are filled by
654  * g_param_type_register_static().
655  */
656 struct GParamSpecClass
657 {
658 	/**
659 	 * the parent class
660 	 */
661 	GTypeClass gTypeClass;
662 	/**
663 	 * the #GValue type for this parameter
664 	 */
665 	GType valueType;
666 	/** */
667 	extern(C) void function(GParamSpec* pspec) finalize;
668 	/** */
669 	extern(C) void function(GParamSpec* pspec, GValue* value) valueSetDefault;
670 	/** */
671 	extern(C) int function(GParamSpec* pspec, GValue* value) valueValidate;
672 	/** */
673 	extern(C) int function(GParamSpec* pspec, GValue* value1, GValue* value2) valuesCmp;
674 	void*[4] dummy;
675 }
676 
677 struct GParamSpecDouble
678 {
679 	/**
680 	 * private #GParamSpec portion
681 	 */
682 	GParamSpec parentInstance;
683 	/**
684 	 * minimum value for the property specified
685 	 */
686 	double minimum;
687 	/**
688 	 * maximum value for the property specified
689 	 */
690 	double maximum;
691 	/**
692 	 * default value for the property specified
693 	 */
694 	double defaultValue;
695 	/**
696 	 * values closer than @epsilon will be considered identical
697 	 * by g_param_values_cmp(); the default value is 1e-90.
698 	 */
699 	double epsilon;
700 }
701 
702 struct GParamSpecEnum
703 {
704 	/**
705 	 * private #GParamSpec portion
706 	 */
707 	GParamSpec parentInstance;
708 	/**
709 	 * the #GEnumClass for the enum
710 	 */
711 	GEnumClass* enumClass;
712 	/**
713 	 * default value for the property specified
714 	 */
715 	int defaultValue;
716 }
717 
718 struct GParamSpecFlags
719 {
720 	/**
721 	 * private #GParamSpec portion
722 	 */
723 	GParamSpec parentInstance;
724 	/**
725 	 * the #GFlagsClass for the flags
726 	 */
727 	GFlagsClass* flagsClass;
728 	/**
729 	 * default value for the property specified
730 	 */
731 	uint defaultValue;
732 }
733 
734 struct GParamSpecFloat
735 {
736 	/**
737 	 * private #GParamSpec portion
738 	 */
739 	GParamSpec parentInstance;
740 	/**
741 	 * minimum value for the property specified
742 	 */
743 	float minimum;
744 	/**
745 	 * maximum value for the property specified
746 	 */
747 	float maximum;
748 	/**
749 	 * default value for the property specified
750 	 */
751 	float defaultValue;
752 	/**
753 	 * values closer than @epsilon will be considered identical
754 	 * by g_param_values_cmp(); the default value is 1e-30.
755 	 */
756 	float epsilon;
757 }
758 
759 struct GParamSpecGType
760 {
761 	/**
762 	 * private #GParamSpec portion
763 	 */
764 	GParamSpec parentInstance;
765 	/**
766 	 * a #GType whose subtypes can occur as values
767 	 */
768 	GType isAType;
769 }
770 
771 struct GParamSpecInt
772 {
773 	/**
774 	 * private #GParamSpec portion
775 	 */
776 	GParamSpec parentInstance;
777 	/**
778 	 * minimum value for the property specified
779 	 */
780 	int minimum;
781 	/**
782 	 * maximum value for the property specified
783 	 */
784 	int maximum;
785 	/**
786 	 * default value for the property specified
787 	 */
788 	int defaultValue;
789 }
790 
791 struct GParamSpecInt64
792 {
793 	/**
794 	 * private #GParamSpec portion
795 	 */
796 	GParamSpec parentInstance;
797 	/**
798 	 * minimum value for the property specified
799 	 */
800 	long minimum;
801 	/**
802 	 * maximum value for the property specified
803 	 */
804 	long maximum;
805 	/**
806 	 * default value for the property specified
807 	 */
808 	long defaultValue;
809 }
810 
811 struct GParamSpecLong
812 {
813 	/**
814 	 * private #GParamSpec portion
815 	 */
816 	GParamSpec parentInstance;
817 	/**
818 	 * minimum value for the property specified
819 	 */
820 	glong minimum;
821 	/**
822 	 * maximum value for the property specified
823 	 */
824 	glong maximum;
825 	/**
826 	 * default value for the property specified
827 	 */
828 	glong defaultValue;
829 }
830 
831 struct GParamSpecObject
832 {
833 	/**
834 	 * private #GParamSpec portion
835 	 */
836 	GParamSpec parentInstance;
837 }
838 
839 struct GParamSpecOverride
840 {
841 	GParamSpec parentInstance;
842 	GParamSpec* overridden;
843 }
844 
845 struct GParamSpecParam
846 {
847 	/**
848 	 * private #GParamSpec portion
849 	 */
850 	GParamSpec parentInstance;
851 }
852 
853 struct GParamSpecPointer
854 {
855 	/**
856 	 * private #GParamSpec portion
857 	 */
858 	GParamSpec parentInstance;
859 }
860 
861 struct GParamSpecPool;
862 
863 struct GParamSpecString
864 {
865 	/**
866 	 * private #GParamSpec portion
867 	 */
868 	GParamSpec parentInstance;
869 	/**
870 	 * default value for the property specified
871 	 */
872 	char* defaultValue;
873 	/**
874 	 * a string containing the allowed values for the first byte
875 	 */
876 	char* csetFirst;
877 	/**
878 	 * a string containing the allowed values for the subsequent bytes
879 	 */
880 	char* csetNth;
881 	/**
882 	 * the replacement byte for bytes which don't match @cset_first or @cset_nth.
883 	 */
884 	char substitutor;
885 	import std.bitmanip: bitfields;
886 	mixin(bitfields!(
887 		uint, "nullFoldIfEmpty", 1,
888 		uint, "ensureNonNull", 1,
889 		uint, "", 30
890 	));
891 }
892 
893 /**
894  * This structure is used to provide the type system with the information
895  * required to initialize and destruct (finalize) a parameter's class and
896  * instances thereof.
897  * The initialized structure is passed to the g_param_type_register_static()
898  * The type system will perform a deep copy of this structure, so its memory
899  * does not need to be persistent across invocation of
900  * g_param_type_register_static().
901  */
902 struct GParamSpecTypeInfo
903 {
904 	/**
905 	 * Size of the instance (object) structure.
906 	 */
907 	ushort instanceSize;
908 	/**
909 	 * 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, it is ignored, since instances are allocated with the [slice allocator][glib-Memory-Slices] now.
910 	 */
911 	ushort nPreallocs;
912 	/** */
913 	extern(C) void function(GParamSpec* pspec) instanceInit;
914 	/**
915 	 * The #GType of values conforming to this #GParamSpec
916 	 */
917 	GType valueType;
918 	/** */
919 	extern(C) void function(GParamSpec* pspec) finalize;
920 	/** */
921 	extern(C) void function(GParamSpec* pspec, GValue* value) valueSetDefault;
922 	/** */
923 	extern(C) int function(GParamSpec* pspec, GValue* value) valueValidate;
924 	/** */
925 	extern(C) int function(GParamSpec* pspec, GValue* value1, GValue* value2) valuesCmp;
926 }
927 
928 struct GParamSpecUChar
929 {
930 	/**
931 	 * private #GParamSpec portion
932 	 */
933 	GParamSpec parentInstance;
934 	/**
935 	 * minimum value for the property specified
936 	 */
937 	ubyte minimum;
938 	/**
939 	 * maximum value for the property specified
940 	 */
941 	ubyte maximum;
942 	/**
943 	 * default value for the property specified
944 	 */
945 	ubyte defaultValue;
946 }
947 
948 struct GParamSpecUInt
949 {
950 	/**
951 	 * private #GParamSpec portion
952 	 */
953 	GParamSpec parentInstance;
954 	/**
955 	 * minimum value for the property specified
956 	 */
957 	uint minimum;
958 	/**
959 	 * maximum value for the property specified
960 	 */
961 	uint maximum;
962 	/**
963 	 * default value for the property specified
964 	 */
965 	uint defaultValue;
966 }
967 
968 struct GParamSpecUInt64
969 {
970 	/**
971 	 * private #GParamSpec portion
972 	 */
973 	GParamSpec parentInstance;
974 	/**
975 	 * minimum value for the property specified
976 	 */
977 	ulong minimum;
978 	/**
979 	 * maximum value for the property specified
980 	 */
981 	ulong maximum;
982 	/**
983 	 * default value for the property specified
984 	 */
985 	ulong defaultValue;
986 }
987 
988 struct GParamSpecULong
989 {
990 	/**
991 	 * private #GParamSpec portion
992 	 */
993 	GParamSpec parentInstance;
994 	/**
995 	 * minimum value for the property specified
996 	 */
997 	gulong minimum;
998 	/**
999 	 * maximum value for the property specified
1000 	 */
1001 	gulong maximum;
1002 	/**
1003 	 * default value for the property specified
1004 	 */
1005 	gulong defaultValue;
1006 }
1007 
1008 struct GParamSpecUnichar
1009 {
1010 	/**
1011 	 * private #GParamSpec portion
1012 	 */
1013 	GParamSpec parentInstance;
1014 	/**
1015 	 * default value for the property specified
1016 	 */
1017 	dchar defaultValue;
1018 }
1019 
1020 struct GParamSpecValueArray
1021 {
1022 	/**
1023 	 * private #GParamSpec portion
1024 	 */
1025 	GParamSpec parentInstance;
1026 	/**
1027 	 * a #GParamSpec describing the elements contained in arrays of this property, may be %NULL
1028 	 */
1029 	GParamSpec* elementSpec;
1030 	/**
1031 	 * if greater than 0, arrays of this property will always have this many elements
1032 	 */
1033 	uint fixedNElements;
1034 }
1035 
1036 struct GParamSpecVariant
1037 {
1038 	/**
1039 	 * private #GParamSpec portion
1040 	 */
1041 	GParamSpec parentInstance;
1042 	/**
1043 	 * a #GVariantType, or %NULL
1044 	 */
1045 	GVariantType* type;
1046 	/**
1047 	 * a #GVariant, or %NULL
1048 	 */
1049 	GVariant* defaultValue;
1050 	void*[4] padding;
1051 }
1052 
1053 /**
1054  * The GParameter struct is an auxiliary structure used
1055  * to hand parameter name/value pairs to g_object_newv().
1056  */
1057 struct GParameter
1058 {
1059 	/**
1060 	 * the parameter name
1061 	 */
1062 	const(char)* name;
1063 	/**
1064 	 * the parameter value
1065 	 */
1066 	GValue value;
1067 }
1068 
1069 /**
1070  * The #GSignalInvocationHint structure is used to pass on additional information
1071  * to callbacks during a signal emission.
1072  */
1073 struct GSignalInvocationHint
1074 {
1075 	/**
1076 	 * The signal id of the signal invoking the callback
1077 	 */
1078 	uint signalId;
1079 	/**
1080 	 * The detail passed on for this emission
1081 	 */
1082 	GQuark detail;
1083 	/**
1084 	 * The stage the signal emission is currently in, this
1085 	 * field will contain one of %G_SIGNAL_RUN_FIRST,
1086 	 * %G_SIGNAL_RUN_LAST or %G_SIGNAL_RUN_CLEANUP.
1087 	 */
1088 	GSignalFlags runType;
1089 }
1090 
1091 /**
1092  * A structure holding in-depth information for a specific signal. It is
1093  * filled in by the g_signal_query() function.
1094  */
1095 struct GSignalQuery
1096 {
1097 	/**
1098 	 * The signal id of the signal being queried, or 0 if the
1099 	 * signal to be queried was unknown.
1100 	 */
1101 	uint signalId;
1102 	/**
1103 	 * The signal name.
1104 	 */
1105 	const(char)* signalName;
1106 	/**
1107 	 * The interface/instance type that this signal can be emitted for.
1108 	 */
1109 	GType itype;
1110 	/**
1111 	 * The signal flags as passed in to g_signal_new().
1112 	 */
1113 	GSignalFlags signalFlags;
1114 	/**
1115 	 * The return type for user callbacks.
1116 	 */
1117 	GType returnType;
1118 	/**
1119 	 * The number of parameters that user callbacks take.
1120 	 */
1121 	uint nParams;
1122 	/**
1123 	 * The individual parameter types for
1124 	 * user callbacks, note that the effective callback signature is:
1125 	 * |[<!-- language="C" -->
1126 	 * @return_type callback (#gpointer     data1,
1127 	 * [param_types param_names,]
1128 	 * gpointer     data2);
1129 	 * ]|
1130 	 */
1131 	GType* paramTypes;
1132 }
1133 
1134 /**
1135  * A union holding one collected value.
1136  */
1137 struct GTypeCValue
1138 {
1139 	union
1140 	{
1141 		/**
1142 		 * the field for holding integer values
1143 		 */
1144 		int vInt;
1145 		/**
1146 		 * the field for holding long integer values
1147 		 */
1148 		glong vLong;
1149 		/**
1150 		 * the field for holding 64 bit integer values
1151 		 */
1152 		long vInt64;
1153 		/**
1154 		 * the field for holding floating point values
1155 		 */
1156 		double vDouble;
1157 		/**
1158 		 * the field for holding pointers
1159 		 */
1160 		void* vPointer;
1161 	}
1162 }
1163 
1164 struct GTypeClass
1165 {
1166 	GType gType;
1167 }
1168 
1169 /**
1170  * A structure that provides information to the type system which is
1171  * used specifically for managing fundamental types.
1172  */
1173 struct GTypeFundamentalInfo
1174 {
1175 	/**
1176 	 * #GTypeFundamentalFlags describing the characteristics of the fundamental type
1177 	 */
1178 	GTypeFundamentalFlags typeFlags;
1179 }
1180 
1181 /**
1182  * This structure is used to provide the type system with the information
1183  * required to initialize and destruct (finalize) a type's class and
1184  * its instances.
1185  *
1186  * The initialized structure is passed to the g_type_register_static() function
1187  * (or is copied into the provided #GTypeInfo structure in the
1188  * g_type_plugin_complete_type_info()). The type system will perform a deep
1189  * copy of this structure, so its memory does not need to be persistent
1190  * across invocation of g_type_register_static().
1191  */
1192 struct GTypeInfo
1193 {
1194 	/**
1195 	 * Size of the class structure (required for interface, classed and instantiatable types)
1196 	 */
1197 	ushort classSize;
1198 	/**
1199 	 * Location of the base initialization function (optional)
1200 	 */
1201 	GBaseInitFunc baseInit;
1202 	/**
1203 	 * Location of the base finalization function (optional)
1204 	 */
1205 	GBaseFinalizeFunc baseFinalize;
1206 	/**
1207 	 * Location of the class initialization function for
1208 	 * classed and instantiatable types. Location of the default vtable
1209 	 * inititalization function for interface types. (optional) This function
1210 	 * is used both to fill in virtual functions in the class or default vtable,
1211 	 * and to do type-specific setup such as registering signals and object
1212 	 * properties.
1213 	 */
1214 	GClassInitFunc classInit;
1215 	/**
1216 	 * Location of the class finalization function for
1217 	 * classed and instantiatable types. Location of the default vtable
1218 	 * finalization function for interface types. (optional)
1219 	 */
1220 	GClassFinalizeFunc classFinalize;
1221 	/**
1222 	 * User-supplied data passed to the class init/finalize functions
1223 	 */
1224 	void* classData;
1225 	/**
1226 	 * Size of the instance (object) structure (required for instantiatable types only)
1227 	 */
1228 	ushort instanceSize;
1229 	/**
1230 	 * 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, it is ignored, since instances are allocated with the [slice allocator][glib-Memory-Slices] now.
1231 	 */
1232 	ushort nPreallocs;
1233 	/**
1234 	 * Location of the instance initialization function (optional, for instantiatable types only)
1235 	 */
1236 	GInstanceInitFunc instanceInit;
1237 	/**
1238 	 * A #GTypeValueTable function table for generic handling of GValues
1239 	 * of this type (usually only useful for fundamental types)
1240 	 */
1241 	GTypeValueTable* valueTable;
1242 }
1243 
1244 struct GTypeInstance
1245 {
1246 	GTypeClass* gClass;
1247 }
1248 
1249 struct GTypeInterface
1250 {
1251 	GType gType;
1252 	GType gInstanceType;
1253 }
1254 
1255 struct GTypeModule
1256 {
1257 	GObject parentInstance;
1258 	uint useCount;
1259 	GSList* typeInfos;
1260 	GSList* interfaceInfos;
1261 	/**
1262 	 * the name of the module
1263 	 */
1264 	char* name;
1265 }
1266 
1267 /**
1268  * In order to implement dynamic loading of types based on #GTypeModule,
1269  * the @load and @unload functions in #GTypeModuleClass must be implemented.
1270  */
1271 struct GTypeModuleClass
1272 {
1273 	/**
1274 	 * the parent class
1275 	 */
1276 	GObjectClass parentClass;
1277 	/** */
1278 	extern(C) int function(GTypeModule* modul) load;
1279 	/** */
1280 	extern(C) void function(GTypeModule* modul) unload;
1281 	/** */
1282 	extern(C) void function() reserved1;
1283 	/** */
1284 	extern(C) void function() reserved2;
1285 	/** */
1286 	extern(C) void function() reserved3;
1287 	/** */
1288 	extern(C) void function() reserved4;
1289 }
1290 
1291 struct GTypePlugin;
1292 
1293 /**
1294  * The #GTypePlugin interface is used by the type system in order to handle
1295  * the lifecycle of dynamically loaded types.
1296  */
1297 struct GTypePluginClass
1298 {
1299 	GTypeInterface baseIface;
1300 	/**
1301 	 * Increases the use count of the plugin.
1302 	 */
1303 	GTypePluginUse usePlugin;
1304 	/**
1305 	 * Decreases the use count of the plugin.
1306 	 */
1307 	GTypePluginUnuse unusePlugin;
1308 	/**
1309 	 * Fills in the #GTypeInfo and
1310 	 * #GTypeValueTable structs for the type. The structs are initialized
1311 	 * with `memset(s, 0, sizeof (s))` before calling this function.
1312 	 */
1313 	GTypePluginCompleteTypeInfo completeTypeInfo;
1314 	/**
1315 	 * Fills in missing parts of the #GInterfaceInfo
1316 	 * for the interface. The structs is initialized with
1317 	 * `memset(s, 0, sizeof (s))` before calling this function.
1318 	 */
1319 	GTypePluginCompleteInterfaceInfo completeInterfaceInfo;
1320 }
1321 
1322 /**
1323  * A structure holding information for a specific type.
1324  * It is filled in by the g_type_query() function.
1325  */
1326 struct GTypeQuery
1327 {
1328 	/**
1329 	 * the #GType value of the type
1330 	 */
1331 	GType type;
1332 	/**
1333 	 * the name of the type
1334 	 */
1335 	const(char)* typeName;
1336 	/**
1337 	 * the size of the class structure
1338 	 */
1339 	uint classSize;
1340 	/**
1341 	 * the size of the instance structure
1342 	 */
1343 	uint instanceSize;
1344 }
1345 
1346 /**
1347  * The #GTypeValueTable provides the functions required by the #GValue
1348  * implementation, to serve as a container for values of a type.
1349  */
1350 struct GTypeValueTable
1351 {
1352 	/** */
1353 	extern(C) void function(GValue* value) valueInit;
1354 	/** */
1355 	extern(C) void function(GValue* value) valueFree;
1356 	/** */
1357 	extern(C) void function(GValue* srcValue, GValue* destValue) valueCopy;
1358 	/** */
1359 	extern(C) void* function(GValue* value) valuePeekPointer;
1360 	/**
1361 	 * A string format describing how to collect the contents of
1362 	 * this value bit-by-bit. Each character in the format represents
1363 	 * an argument to be collected, and the characters themselves indicate
1364 	 * the type of the argument. Currently supported arguments are:
1365 	 * - 'i' - Integers. passed as collect_values[].v_int.
1366 	 * - 'l' - Longs. passed as collect_values[].v_long.
1367 	 * - 'd' - Doubles. passed as collect_values[].v_double.
1368 	 * - 'p' - Pointers. passed as collect_values[].v_pointer.
1369 	 * It should be noted that for variable argument list construction,
1370 	 * ANSI C promotes every type smaller than an integer to an int, and
1371 	 * floats to doubles. So for collection of short int or char, 'i'
1372 	 * needs to be used, and for collection of floats 'd'.
1373 	 */
1374 	const(char)* collectFormat;
1375 	/** */
1376 	extern(C) char* function(GValue* value, uint nCollectValues, GTypeCValue* collectValues, uint collectFlags) collectValue;
1377 	/**
1378 	 * Format description of the arguments to collect for @lcopy_value,
1379 	 * analogous to @collect_format. Usually, @lcopy_format string consists
1380 	 * only of 'p's to provide lcopy_value() with pointers to storage locations.
1381 	 */
1382 	const(char)* lcopyFormat;
1383 	/** */
1384 	extern(C) char* function(GValue* value, uint nCollectValues, GTypeCValue* collectValues, uint collectFlags) lcopyValue;
1385 }
1386 
1387 struct GValue
1388 {
1389 	GType gType;
1390 	ValueDataUnion[2] data;
1391 }
1392 
1393 struct GValueArray
1394 {
1395 	/**
1396 	 * number of values contained in the array
1397 	 */
1398 	uint nValues;
1399 	/**
1400 	 * array of values
1401 	 */
1402 	GValue* values;
1403 	uint nPrealloced;
1404 }
1405 
1406 struct GWeakRef
1407 {
1408 	union Priv
1409 	{
1410 		void* p;
1411 	}
1412 	Priv priv;
1413 }
1414 
1415 struct ValueDataUnion
1416 {
1417 	union
1418 	{
1419 		int vInt;
1420 		uint vUint;
1421 		glong vLong;
1422 		gulong vUlong;
1423 		long vInt64;
1424 		ulong vUint64;
1425 		float vFloat;
1426 		double vDouble;
1427 		void* vPointer;
1428 	}
1429 }
1430 
1431 /**
1432  * A callback function used by the type system to finalize those portions
1433  * of a derived types class structure that were setup from the corresponding
1434  * GBaseInitFunc() function. Class finalization basically works the inverse
1435  * way in which class initialization is performed.
1436  * See GClassInitFunc() for a discussion of the class initialization process.
1437  *
1438  * Params:
1439  *     gClass = The #GTypeClass structure to finalize
1440  */
1441 public alias extern(C) void function(void* gClass) GBaseFinalizeFunc;
1442 
1443 /**
1444  * A callback function used by the type system to do base initialization
1445  * of the class structures of derived types. It is called as part of the
1446  * initialization process of all derived classes and should reallocate
1447  * or reset all dynamic class members copied over from the parent class.
1448  * For example, class members (such as strings) that are not sufficiently
1449  * handled by a plain memory copy of the parent class into the derived class
1450  * have to be altered. See GClassInitFunc() for a discussion of the class
1451  * initialization process.
1452  *
1453  * Params:
1454  *     gClass = The #GTypeClass structure to initialize
1455  */
1456 public alias extern(C) void function(void* gClass) GBaseInitFunc;
1457 
1458 /**
1459  * A function to be called to transform @from_value to @to_value. If
1460  * this is the @transform_to function of a binding, then @from_value
1461  * is the @source_property on the @source object, and @to_value is the
1462  * @target_property on the @target object. If this is the
1463  * @transform_from function of a %G_BINDING_BIDIRECTIONAL binding,
1464  * then those roles are reversed.
1465  *
1466  * Params:
1467  *     binding = a #GBinding
1468  *     fromValue = the #GValue containing the value to transform
1469  *     toValue = the #GValue in which to store the transformed value
1470  *     userData = data passed to the transform function
1471  *
1472  * Returns: %TRUE if the transformation was successful, and %FALSE
1473  *     otherwise
1474  *
1475  * Since: 2.26
1476  */
1477 public alias extern(C) int function(GBinding* binding, GValue* fromValue, GValue* toValue, void* userData) GBindingTransformFunc;
1478 
1479 /**
1480  * This function is provided by the user and should produce a copy
1481  * of the passed in boxed structure.
1482  *
1483  * Params:
1484  *     boxed = The boxed structure to be copied.
1485  *
1486  * Returns: The newly created copy of the boxed structure.
1487  */
1488 public alias extern(C) void* function(void* boxed) GBoxedCopyFunc;
1489 
1490 /**
1491  * This function is provided by the user and should free the boxed
1492  * structure passed.
1493  *
1494  * Params:
1495  *     boxed = The boxed structure to be freed.
1496  */
1497 public alias extern(C) void function(void* boxed) GBoxedFreeFunc;
1498 
1499 /**
1500  * The type used for callback functions in structure definitions and function
1501  * signatures. This doesn't mean that all callback functions must take no
1502  * parameters and return void. The required signature of a callback function
1503  * is determined by the context in which is used (e.g. the signal to which it
1504  * is connected). Use G_CALLBACK() to cast the callback function to a #GCallback.
1505  */
1506 public alias extern(C) void function() GCallback;
1507 
1508 /**
1509  * A callback function used by the type system to finalize a class.
1510  * This function is rarely needed, as dynamically allocated class resources
1511  * should be handled by GBaseInitFunc() and GBaseFinalizeFunc().
1512  * Also, specification of a GClassFinalizeFunc() in the #GTypeInfo
1513  * structure of a static type is invalid, because classes of static types
1514  * will never be finalized (they are artificially kept alive when their
1515  * reference count drops to zero).
1516  *
1517  * Params:
1518  *     gClass = The #GTypeClass structure to finalize
1519  *     classData = The @class_data member supplied via the #GTypeInfo structure
1520  */
1521 public alias extern(C) void function(void* gClass, void* classData) GClassFinalizeFunc;
1522 
1523 /**
1524  * A callback function used by the type system to initialize the class
1525  * of a specific type. This function should initialize all static class
1526  * members.
1527  *
1528  * The initialization process of a class involves:
1529  *
1530  * - Copying common members from the parent class over to the
1531  * derived class structure.
1532  * - Zero initialization of the remaining members not copied
1533  * over from the parent class.
1534  * - Invocation of the GBaseInitFunc() initializers of all parent
1535  * types and the class' type.
1536  * - Invocation of the class' GClassInitFunc() initializer.
1537  *
1538  * Since derived classes are partially initialized through a memory copy
1539  * of the parent class, the general rule is that GBaseInitFunc() and
1540  * GBaseFinalizeFunc() should take care of necessary reinitialization
1541  * and release of those class members that were introduced by the type
1542  * that specified these GBaseInitFunc()/GBaseFinalizeFunc().
1543  * GClassInitFunc() should only care about initializing static
1544  * class members, while dynamic class members (such as allocated strings
1545  * or reference counted resources) are better handled by a GBaseInitFunc()
1546  * for this type, so proper initialization of the dynamic class members
1547  * is performed for class initialization of derived types as well.
1548  *
1549  * An example may help to correspond the intend of the different class
1550  * initializers:
1551  *
1552  * |[<!-- language="C" -->
1553  * typedef struct {
1554  * GObjectClass parent_class;
1555  * gint         static_integer;
1556  * gchar       *dynamic_string;
1557  * } TypeAClass;
1558  * static void
1559  * type_a_base_class_init (TypeAClass *class)
1560  * {
1561  * class->dynamic_string = g_strdup ("some string");
1562  * }
1563  * static void
1564  * type_a_base_class_finalize (TypeAClass *class)
1565  * {
1566  * g_free (class->dynamic_string);
1567  * }
1568  * static void
1569  * type_a_class_init (TypeAClass *class)
1570  * {
1571  * class->static_integer = 42;
1572  * }
1573  *
1574  * typedef struct {
1575  * TypeAClass   parent_class;
1576  * gfloat       static_float;
1577  * GString     *dynamic_gstring;
1578  * } TypeBClass;
1579  * static void
1580  * type_b_base_class_init (TypeBClass *class)
1581  * {
1582  * class->dynamic_gstring = g_string_new ("some other string");
1583  * }
1584  * static void
1585  * type_b_base_class_finalize (TypeBClass *class)
1586  * {
1587  * g_string_free (class->dynamic_gstring);
1588  * }
1589  * static void
1590  * type_b_class_init (TypeBClass *class)
1591  * {
1592  * class->static_float = 3.14159265358979323846;
1593  * }
1594  * ]|
1595  * Initialization of TypeBClass will first cause initialization of
1596  * TypeAClass (derived classes reference their parent classes, see
1597  * g_type_class_ref() on this).
1598  *
1599  * Initialization of TypeAClass roughly involves zero-initializing its fields,
1600  * then calling its GBaseInitFunc() type_a_base_class_init() to allocate
1601  * its dynamic members (dynamic_string), and finally calling its GClassInitFunc()
1602  * type_a_class_init() to initialize its static members (static_integer).
1603  * The first step in the initialization process of TypeBClass is then
1604  * a plain memory copy of the contents of TypeAClass into TypeBClass and
1605  * zero-initialization of the remaining fields in TypeBClass.
1606  * The dynamic members of TypeAClass within TypeBClass now need
1607  * reinitialization which is performed by calling type_a_base_class_init()
1608  * with an argument of TypeBClass.
1609  *
1610  * After that, the GBaseInitFunc() of TypeBClass, type_b_base_class_init()
1611  * is called to allocate the dynamic members of TypeBClass (dynamic_gstring),
1612  * and finally the GClassInitFunc() of TypeBClass, type_b_class_init(),
1613  * is called to complete the initialization process with the static members
1614  * (static_float).
1615  *
1616  * Corresponding finalization counter parts to the GBaseInitFunc() functions
1617  * have to be provided to release allocated resources at class finalization
1618  * time.
1619  *
1620  * Params:
1621  *     gClass = The #GTypeClass structure to initialize.
1622  *     classData = The @class_data member supplied via the #GTypeInfo structure.
1623  */
1624 public alias extern(C) void function(void* gClass, void* classData) GClassInitFunc;
1625 
1626 /**
1627  * The type used for marshaller functions.
1628  *
1629  * Params:
1630  *     closure = the #GClosure to which the marshaller belongs
1631  *     returnValue = a #GValue to store the return
1632  *         value. May be %NULL if the callback of @closure doesn't return a
1633  *         value.
1634  *     nParamValues = the length of the @param_values array
1635  *     paramValues = an array of
1636  *         #GValues holding the arguments on which to invoke the
1637  *         callback of @closure
1638  *     invocationHint = the invocation hint given as the
1639  *         last argument to g_closure_invoke()
1640  *     marshalData = additional data specified when
1641  *         registering the marshaller, see g_closure_set_marshal() and
1642  *         g_closure_set_meta_marshal()
1643  */
1644 public alias extern(C) void function(GClosure* closure, GValue* returnValue, uint nParamValues, GValue* paramValues, void* invocationHint, void* marshalData) GClosureMarshal;
1645 
1646 /**
1647  * The type used for the various notification callbacks which can be registered
1648  * on closures.
1649  *
1650  * Params:
1651  *     data = data specified when registering the notification callback
1652  *     closure = the #GClosure on which the notification is emitted
1653  */
1654 public alias extern(C) void function(void* data, GClosure* closure) GClosureNotify;
1655 
1656 /**
1657  * A callback function used by the type system to initialize a new
1658  * instance of a type. This function initializes all instance members and
1659  * allocates any resources required by it.
1660  *
1661  * Initialization of a derived instance involves calling all its parent
1662  * types instance initializers, so the class member of the instance
1663  * is altered during its initialization to always point to the class that
1664  * belongs to the type the current initializer was introduced for.
1665  *
1666  * The extended members of @instance are guaranteed to have been filled with
1667  * zeros before this function is called.
1668  *
1669  * Params:
1670  *     instanc = The instance to initialize
1671  *     gClass = The class of the type the instance is
1672  *         created for
1673  */
1674 public alias extern(C) void function(GTypeInstance* instanc, void* gClass) GInstanceInitFunc;
1675 
1676 /**
1677  * A callback function used by the type system to finalize an interface.
1678  * This function should destroy any internal data and release any resources
1679  * allocated by the corresponding GInterfaceInitFunc() function.
1680  *
1681  * Params:
1682  *     gIface = The interface structure to finalize
1683  *     ifaceData = The @interface_data supplied via the #GInterfaceInfo structure
1684  */
1685 public alias extern(C) void function(void* gIface, void* ifaceData) GInterfaceFinalizeFunc;
1686 
1687 /**
1688  * A callback function used by the type system to initialize a new
1689  * interface.  This function should initialize all internal data and
1690  * allocate any resources required by the interface.
1691  *
1692  * The members of @iface_data are guaranteed to have been filled with
1693  * zeros before this function is called.
1694  *
1695  * Params:
1696  *     gIface = The interface structure to initialize
1697  *     ifaceData = The @interface_data supplied via the #GInterfaceInfo structure
1698  */
1699 public alias extern(C) void function(void* gIface, void* ifaceData) GInterfaceInitFunc;
1700 
1701 /**
1702  * The type of the @finalize function of #GObjectClass.
1703  *
1704  * Params:
1705  *     object = the #GObject being finalized
1706  */
1707 public alias extern(C) void function(GObject* object) GObjectFinalizeFunc;
1708 
1709 /**
1710  * The type of the @get_property function of #GObjectClass.
1711  *
1712  * Params:
1713  *     object = a #GObject
1714  *     propertyId = the numeric id under which the property was registered with
1715  *         g_object_class_install_property().
1716  *     value = a #GValue to return the property value in
1717  *     pspec = the #GParamSpec describing the property
1718  */
1719 public alias extern(C) void function(GObject* object, uint propertyId, GValue* value, GParamSpec* pspec) GObjectGetPropertyFunc;
1720 
1721 /**
1722  * The type of the @set_property function of #GObjectClass.
1723  *
1724  * Params:
1725  *     object = a #GObject
1726  *     propertyId = the numeric id under which the property was registered with
1727  *         g_object_class_install_property().
1728  *     value = the new value for the property
1729  *     pspec = the #GParamSpec describing the property
1730  */
1731 public alias extern(C) void function(GObject* object, uint propertyId, GValue* value, GParamSpec* pspec) GObjectSetPropertyFunc;
1732 
1733 /**
1734  * The signal accumulator is a special callback function that can be used
1735  * to collect return values of the various callbacks that are called
1736  * during a signal emission. The signal accumulator is specified at signal
1737  * creation time, if it is left %NULL, no accumulation of callback return
1738  * values is performed. The return value of signal emissions is then the
1739  * value returned by the last callback.
1740  *
1741  * Params:
1742  *     ihint = Signal invocation hint, see #GSignalInvocationHint.
1743  *     returnAccu = Accumulator to collect callback return values in, this
1744  *         is the return value of the current signal emission.
1745  *     handlerReturn = A #GValue holding the return value of the signal handler.
1746  *     data = Callback data that was specified when creating the signal.
1747  *
1748  * Returns: The accumulator function returns whether the signal emission
1749  *     should be aborted. Returning %FALSE means to abort the
1750  *     current emission and %TRUE is returned for continuation.
1751  */
1752 public alias extern(C) int function(GSignalInvocationHint* ihint, GValue* returnAccu, GValue* handlerReturn, void* data) GSignalAccumulator;
1753 
1754 /**
1755  * A simple function pointer to get invoked when the signal is emitted. This
1756  * allows you to tie a hook to the signal type, so that it will trap all
1757  * emissions of that signal, from any object.
1758  *
1759  * You may not attach these to signals created with the #G_SIGNAL_NO_HOOKS flag.
1760  *
1761  * Params:
1762  *     ihint = Signal invocation hint, see #GSignalInvocationHint.
1763  *     nParamValues = the number of parameters to the function, including
1764  *         the instance on which the signal was emitted.
1765  *     paramValues = the instance on which
1766  *         the signal was emitted, followed by the parameters of the emission.
1767  *     data = user data associated with the hook.
1768  *
1769  * Returns: whether it wants to stay connected. If it returns %FALSE, the signal
1770  *     hook is disconnected (and destroyed).
1771  */
1772 public alias extern(C) int function(GSignalInvocationHint* ihint, uint nParamValues, GValue* paramValues, void* data) GSignalEmissionHook;
1773 
1774 /**
1775  * A callback function used for notification when the state
1776  * of a toggle reference changes. See g_object_add_toggle_ref().
1777  *
1778  * Params:
1779  *     data = Callback data passed to g_object_add_toggle_ref()
1780  *     object = The object on which g_object_add_toggle_ref() was called.
1781  *     isLastRef = %TRUE if the toggle reference is now the
1782  *         last reference to the object. %FALSE if the toggle
1783  *         reference was the last reference and there are now other
1784  *         references.
1785  */
1786 public alias extern(C) void function(void* data, GObject* object, int isLastRef) GToggleNotify;
1787 
1788 /**
1789  * A callback function which is called when the reference count of a class
1790  * drops to zero. It may use g_type_class_ref() to prevent the class from
1791  * being freed. You should not call g_type_class_unref() from a
1792  * #GTypeClassCacheFunc function to prevent infinite recursion, use
1793  * g_type_class_unref_uncached() instead.
1794  *
1795  * The functions have to check the class id passed in to figure
1796  * whether they actually want to cache the class of this type, since all
1797  * classes are routed through the same #GTypeClassCacheFunc chain.
1798  *
1799  * Params:
1800  *     cacheData = data that was given to the g_type_add_class_cache_func() call
1801  *     gClass = The #GTypeClass structure which is
1802  *         unreferenced
1803  *
1804  * Returns: %TRUE to stop further #GTypeClassCacheFuncs from being
1805  *     called, %FALSE to continue
1806  */
1807 public alias extern(C) int function(void* cacheData, GTypeClass* gClass) GTypeClassCacheFunc;
1808 
1809 /**
1810  * A callback called after an interface vtable is initialized.
1811  * See g_type_add_interface_check().
1812  *
1813  * Params:
1814  *     checkData = data passed to g_type_add_interface_check()
1815  *     gIface = the interface that has been
1816  *         initialized
1817  *
1818  * Since: 2.4
1819  */
1820 public alias extern(C) void function(void* checkData, void* gIface) GTypeInterfaceCheckFunc;
1821 
1822 /**
1823  * The type of the @complete_interface_info function of #GTypePluginClass.
1824  *
1825  * Params:
1826  *     plugin = the #GTypePlugin
1827  *     instanceType = the #GType of an instantiable type to which the interface
1828  *         is added
1829  *     interfaceType = the #GType of the interface whose info is completed
1830  *     info = the #GInterfaceInfo to fill in
1831  */
1832 public alias extern(C) void function(GTypePlugin* plugin, GType instanceType, GType interfaceType, GInterfaceInfo* info) GTypePluginCompleteInterfaceInfo;
1833 
1834 /**
1835  * The type of the @complete_type_info function of #GTypePluginClass.
1836  *
1837  * Params:
1838  *     plugin = the #GTypePlugin
1839  *     gType = the #GType whose info is completed
1840  *     info = the #GTypeInfo struct to fill in
1841  *     valueTable = the #GTypeValueTable to fill in
1842  */
1843 public alias extern(C) void function(GTypePlugin* plugin, GType gType, GTypeInfo* info, GTypeValueTable* valueTable) GTypePluginCompleteTypeInfo;
1844 
1845 /**
1846  * The type of the @unuse_plugin function of #GTypePluginClass.
1847  *
1848  * Params:
1849  *     plugin = the #GTypePlugin whose use count should be decreased
1850  */
1851 public alias extern(C) void function(GTypePlugin* plugin) GTypePluginUnuse;
1852 
1853 /**
1854  * The type of the @use_plugin function of #GTypePluginClass, which gets called
1855  * to increase the use count of @plugin.
1856  *
1857  * Params:
1858  *     plugin = the #GTypePlugin whose use count should be increased
1859  */
1860 public alias extern(C) void function(GTypePlugin* plugin) GTypePluginUse;
1861 
1862 /**
1863  * This is the signature of va_list marshaller functions, an optional
1864  * marshaller that can be used in some situations to avoid
1865  * marshalling the signal argument into GValues.
1866  *
1867  * Params:
1868  *     closure = the #GClosure to which the marshaller belongs
1869  *     returnValue = a #GValue to store the return
1870  *         value. May be %NULL if the callback of @closure doesn't return a
1871  *         value.
1872  *     instanc = the instance on which the closure is
1873  *         invoked.
1874  *     args = va_list of arguments to be passed to the closure.
1875  *     marshalData = additional data specified when
1876  *         registering the marshaller, see g_closure_set_marshal() and
1877  *         g_closure_set_meta_marshal()
1878  *     nParams = the length of the @param_types array
1879  *     paramTypes = the #GType of each argument from
1880  *         @args.
1881  */
1882 public alias extern(C) void function(GClosure* closure, GValue* returnValue, void* instanc, void* args, void* marshalData, int nParams, GType* paramTypes) GVaClosureMarshal;
1883 
1884 /**
1885  * The type of value transformation functions which can be registered with
1886  * g_value_register_transform_func().
1887  *
1888  * Params:
1889  *     srcValue = Source value.
1890  *     destValue = Target value.
1891  */
1892 public alias extern(C) void function(GValue* srcValue, GValue* destValue) GValueTransform;
1893 
1894 /**
1895  * A #GWeakNotify function can be added to an object as a callback that gets
1896  * triggered when the object is finalized. Since the object is already being
1897  * finalized when the #GWeakNotify is called, there's not much you could do
1898  * with the object, apart from e.g. using its address as hash-index or the like.
1899  *
1900  * Params:
1901  *     data = data that was provided when the weak reference was established
1902  *     whereTheObjectWas = the object being finalized
1903  */
1904 public alias extern(C) void function(void* data, GObject* whereTheObjectWas) GWeakNotify;