source: appstream-generator/build/girepo/gi/gobjecttypes.d @ 4841

Last change on this file since 4841 was 4841, checked in by Juanma, 2 years ago

Initial release

File size: 48.5 KB
Line 
1/*
2 * Licensed under the GNU Lesser General Public License Version 3
3 *
4 * This library is free software: you can redistribute it and/or modify
5 * it under the terms of the GNU Lesser General Public License as published by
6 * the Free Software Foundation, either version 3 of the license, or
7 * (at your option) any later version.
8 *
9 * This software is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 * GNU Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public License
15 * along with this library.  If not, see <http://www.gnu.org/licenses/>.
16 */
17
18// generated automatically - do not change
19
20
21module gi.gobjecttypes;
22
23public import gi.glibtypes;
24
25public alias void* GInitiallyUnownedAutoptr;
26
27public alias void* GObjectAutoptr;
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 */
36public 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 */
43public alias GVaClosureMarshal GSignalCVaMarshaller;
44
45/**
46 * A value which represents the unique identifier of a registered type.
47 */
48enum 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 */
82public 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}
110alias GBindingFlags BindingFlags;
111
112/**
113 * The connection flags are used to specify the behaviour of a signal's
114 * connection.
115 */
116public 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}
129alias 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 */
135public 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}
202alias 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 */
209public 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}
259alias 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 */
266public 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}
293alias 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 */
304public 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}
327alias GTypeDebugFlags TypeDebugFlags;
328
329/**
330 * Bit masks used to check or determine characteristics of a type.
331 */
332public 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}
346alias GTypeFlags TypeFlags;
347
348/**
349 * Bit masks used to check or determine specific characteristics of a
350 * fundamental type.
351 */
352public 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}
371alias GTypeFundamentalFlags TypeFundamentalFlags;
372
373struct GBinding;
374
375/**
376 * A #GCClosure is a specialization of #GClosure for C function callbacks.
377 */
378struct GCClosure
379{
380        /**
381         * the #GClosure
382         */
383        GClosure closure;
384        /**
385         * the callback function
386         */
387        void* callback;
388}
389
390struct 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
411struct 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 */
421struct 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 */
450struct 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 */
470struct 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 */
495struct 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 */
515struct 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
531struct GObject
532{
533        GTypeInstance gTypeInstance;
534        uint refCount;
535        GData* qdata;
536}
537
538struct 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 */
570struct 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
582struct 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
611struct 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
623struct GParamSpecBoxed
624{
625        /**
626         * private #GParamSpec portion
627         */
628        GParamSpec parentInstance;
629}
630
631struct 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 */
656struct 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
677struct 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
702struct 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
718struct 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
734struct 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
759struct 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
771struct 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
791struct 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
811struct 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
831struct GParamSpecObject
832{
833        /**
834         * private #GParamSpec portion
835         */
836        GParamSpec parentInstance;
837}
838
839struct GParamSpecOverride
840{
841        GParamSpec parentInstance;
842        GParamSpec* overridden;
843}
844
845struct GParamSpecParam
846{
847        /**
848         * private #GParamSpec portion
849         */
850        GParamSpec parentInstance;
851}
852
853struct GParamSpecPointer
854{
855        /**
856         * private #GParamSpec portion
857         */
858        GParamSpec parentInstance;
859}
860
861struct GParamSpecPool;
862
863struct 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 */
902struct 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
928struct 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
948struct 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
968struct 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
988struct 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
1008struct 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
1020struct 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
1036struct 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 */
1057struct 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 */
1073struct 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 */
1095struct 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 */
1137struct 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
1164struct 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 */
1173struct 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 */
1192struct 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
1244struct GTypeInstance
1245{
1246        GTypeClass* gClass;
1247}
1248
1249struct GTypeInterface
1250{
1251        GType gType;
1252        GType gInstanceType;
1253}
1254
1255struct 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 */
1271struct 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
1291struct 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 */
1297struct 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 */
1326struct 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 */
1350struct 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
1387struct GValue
1388{
1389        GType gType;
1390        ValueDataUnion[2] data;
1391}
1392
1393struct 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
1406struct GWeakRef
1407{
1408        union Priv
1409        {
1410                void* p;
1411        }
1412        Priv priv;
1413}
1414
1415struct 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 */
1441public 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 */
1456public 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 */
1477public 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 */
1488public 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 */
1497public 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 */
1506public 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 */
1521public 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 */
1624public 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 */
1644public 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 */
1654public 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 */
1674public 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 */
1685public 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 */
1699public 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 */
1707public 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 */
1719public 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 */
1731public 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 */
1752public 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 */
1772public 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 */
1786public 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 */
1807public 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 */
1820public 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 */
1832public 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 */
1843public 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 */
1851public 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 */
1860public 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 */
1882public 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 */
1892public 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 */
1904public alias extern(C) void function(void* data, GObject* whereTheObjectWas) GWeakNotify;
Note: See TracBrowser for help on using the repository browser.