source: appstream-generator/build/girepo/gobject/CClosure.d @ 4841

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

Initial release

File size: 55.2 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 gobject.CClosure;
22
23private import gi.gobject;
24public  import gi.gobjecttypes;
25private import glib.ConstructionException;
26private import gobject.Closure;
27private import gobject.ObjectG;
28private import gobject.Value;
29
30
31/**
32 * A #GCClosure is a specialization of #GClosure for C function callbacks.
33 */
34public class CClosure
35{
36        /** the main Gtk struct */
37        protected GCClosure* gCClosure;
38        protected bool ownedRef;
39
40        /** Get the main Gtk struct */
41        public GCClosure* getCClosureStruct()
42        {
43                return gCClosure;
44        }
45
46        /** the main Gtk struct as a void* */
47        protected void* getStruct()
48        {
49                return cast(void*)gCClosure;
50        }
51
52        /**
53         * Sets our main struct and passes it to the parent class.
54         */
55        public this (GCClosure* gCClosure, bool ownedRef = false)
56        {
57                this.gCClosure = gCClosure;
58                this.ownedRef = ownedRef;
59        }
60
61        /**
62         * Creates a new closure which invokes callbackFunc with userData as
63         * the last parameter.
64         *
65         * Params:
66         *     callbackFunc = the function to invoke
67         *     userData = user data to pass to callbackFunc
68         *     destroyData = destroy notify to be called when userData is no longer used
69         *     swap = if true invoce with usrData as the first parameter
70         *
71         * Throws: ConstructionException GTK+ fails to create the object.
72         */
73        public this(GCallback callbackFunc, void* userData, GClosureNotify destroyData, bool swap)
74        {
75                GClosure* p;
76               
77                if ( swap )
78                        p = g_cclosure_new_swap(callbackFunc, userData, destroyData);
79                else
80                        p = g_cclosure_new(callbackFunc, userData, destroyData);
81               
82                if(p is null)
83                {
84                        throw new ConstructionException("null returned by new");
85                }
86               
87                this(cast(GCClosure*) p);
88        }
89       
90        /**
91         * A variant of this() which uses object as userData and
92         * calls ObjectG.watchClosure() on object and the created
93         * closure. This function is useful when you have a callback closely
94         * associated with a gobject.ObjectG, and want the callback to no longer run
95         * after the object is is freed.
96         *
97         * Params:
98         *     callbackFunc = the function to invoke
99         *     object = a gobject.ObjectG.ObjectG to pass to callbackFunc
100         *     swap = if true invoce with usrData as the first parameter
101         *
102         * Throws: ConstructionException GTK+ fails to create the object.
103         */
104        public this(GCallback callbackFunc, ObjectG object, bool swap)
105        {
106                GClosure* p;
107               
108                if ( swap )
109                        p = g_cclosure_new_object_swap(callbackFunc, (object is null) ? null : object.getObjectGStruct());
110                else
111                        p = g_cclosure_new_object(callbackFunc, (object is null) ? null : object.getObjectGStruct());
112               
113                if(p is null)
114                {
115                        throw new ConstructionException("null returned by new_object");
116                }
117               
118                this(cast(GCClosure*) p);
119        }
120
121        /**
122         */
123
124        /**
125         * A #GClosureMarshal function for use with signals with handlers that
126         * take two boxed pointers as arguments and return a boolean.  If you
127         * have such a signal, you will probably also need to use an
128         * accumulator, such as g_signal_accumulator_true_handled().
129         *
130         * Params:
131         *     closure = A #GClosure.
132         *     returnValue = A #GValue to store the return value. May be %NULL
133         *         if the callback of closure doesn't return a value.
134         *     nParamValues = The length of the @param_values array.
135         *     paramValues = An array of #GValues holding the arguments
136         *         on which to invoke the callback of closure.
137         *     invocationHint = The invocation hint given as the last argument to
138         *         g_closure_invoke().
139         *     marshalData = Additional data specified when registering the
140         *         marshaller, see g_closure_set_marshal() and
141         *         g_closure_set_meta_marshal()
142         */
143        public static void marshalBOOLEANBOXEDBOXED(Closure closure, Value returnValue, uint nParamValues, Value paramValues, void* invocationHint, void* marshalData)
144        {
145                g_cclosure_marshal_BOOLEAN__BOXED_BOXED((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), nParamValues, (paramValues is null) ? null : paramValues.getValueStruct(), invocationHint, marshalData);
146        }
147
148        /**
149         * The #GVaClosureMarshal equivalent to g_cclosure_marshal_BOOLEAN__BOXED_BOXED().
150         *
151         * Params:
152         *     closure = the #GClosure to which the marshaller belongs
153         *     returnValue = a #GValue to store the return
154         *         value. May be %NULL if the callback of @closure doesn't return a
155         *         value.
156         *     instanc = the instance on which the closure is invoked.
157         *     args = va_list of arguments to be passed to the closure.
158         *     marshalData = additional data specified when
159         *         registering the marshaller, see g_closure_set_marshal() and
160         *         g_closure_set_meta_marshal()
161         *     nParams = the length of the @param_types array
162         *     paramTypes = the #GType of each argument from
163         *         @args.
164         */
165        public static void marshalBOOLEANBOXEDBOXEDv(Closure closure, Value returnValue, void* instanc, void* args, void* marshalData, GType[] paramTypes)
166        {
167                g_cclosure_marshal_BOOLEAN__BOXED_BOXEDv((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), instanc, args, marshalData, cast(int)paramTypes.length, paramTypes.ptr);
168        }
169
170        /**
171         * A #GClosureMarshal function for use with signals with handlers that
172         * take a flags type as an argument and return a boolean.  If you have
173         * such a signal, you will probably also need to use an accumulator,
174         * such as g_signal_accumulator_true_handled().
175         *
176         * Params:
177         *     closure = A #GClosure.
178         *     returnValue = A #GValue to store the return value. May be %NULL
179         *         if the callback of closure doesn't return a value.
180         *     nParamValues = The length of the @param_values array.
181         *     paramValues = An array of #GValues holding the arguments
182         *         on which to invoke the callback of closure.
183         *     invocationHint = The invocation hint given as the last argument to
184         *         g_closure_invoke().
185         *     marshalData = Additional data specified when registering the
186         *         marshaller, see g_closure_set_marshal() and
187         *         g_closure_set_meta_marshal()
188         */
189        public static void marshalBOOLEANFLAGS(Closure closure, Value returnValue, uint nParamValues, Value paramValues, void* invocationHint, void* marshalData)
190        {
191                g_cclosure_marshal_BOOLEAN__FLAGS((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), nParamValues, (paramValues is null) ? null : paramValues.getValueStruct(), invocationHint, marshalData);
192        }
193
194        /**
195         * The #GVaClosureMarshal equivalent to g_cclosure_marshal_BOOLEAN__FLAGS().
196         *
197         * Params:
198         *     closure = the #GClosure to which the marshaller belongs
199         *     returnValue = a #GValue to store the return
200         *         value. May be %NULL if the callback of @closure doesn't return a
201         *         value.
202         *     instanc = the instance on which the closure is invoked.
203         *     args = va_list of arguments to be passed to the closure.
204         *     marshalData = additional data specified when
205         *         registering the marshaller, see g_closure_set_marshal() and
206         *         g_closure_set_meta_marshal()
207         *     nParams = the length of the @param_types array
208         *     paramTypes = the #GType of each argument from
209         *         @args.
210         */
211        public static void marshalBOOLEANFLAGSv(Closure closure, Value returnValue, void* instanc, void* args, void* marshalData, GType[] paramTypes)
212        {
213                g_cclosure_marshal_BOOLEAN__FLAGSv((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), instanc, args, marshalData, cast(int)paramTypes.length, paramTypes.ptr);
214        }
215
216        /**
217         * A #GClosureMarshal function for use with signals with handlers that
218         * take a #GObject and a pointer and produce a string.  It is highly
219         * unlikely that your signal handler fits this description.
220         *
221         * Params:
222         *     closure = A #GClosure.
223         *     returnValue = A #GValue to store the return value. May be %NULL
224         *         if the callback of closure doesn't return a value.
225         *     nParamValues = The length of the @param_values array.
226         *     paramValues = An array of #GValues holding the arguments
227         *         on which to invoke the callback of closure.
228         *     invocationHint = The invocation hint given as the last argument to
229         *         g_closure_invoke().
230         *     marshalData = Additional data specified when registering the
231         *         marshaller, see g_closure_set_marshal() and
232         *         g_closure_set_meta_marshal()
233         */
234        public static void marshalSTRINGOBJECTPOINTER(Closure closure, Value returnValue, uint nParamValues, Value paramValues, void* invocationHint, void* marshalData)
235        {
236                g_cclosure_marshal_STRING__OBJECT_POINTER((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), nParamValues, (paramValues is null) ? null : paramValues.getValueStruct(), invocationHint, marshalData);
237        }
238
239        /**
240         * The #GVaClosureMarshal equivalent to g_cclosure_marshal_STRING__OBJECT_POINTER().
241         *
242         * Params:
243         *     closure = the #GClosure to which the marshaller belongs
244         *     returnValue = a #GValue to store the return
245         *         value. May be %NULL if the callback of @closure doesn't return a
246         *         value.
247         *     instanc = the instance on which the closure is invoked.
248         *     args = va_list of arguments to be passed to the closure.
249         *     marshalData = additional data specified when
250         *         registering the marshaller, see g_closure_set_marshal() and
251         *         g_closure_set_meta_marshal()
252         *     nParams = the length of the @param_types array
253         *     paramTypes = the #GType of each argument from
254         *         @args.
255         */
256        public static void marshalSTRINGOBJECTPOINTERv(Closure closure, Value returnValue, void* instanc, void* args, void* marshalData, GType[] paramTypes)
257        {
258                g_cclosure_marshal_STRING__OBJECT_POINTERv((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), instanc, args, marshalData, cast(int)paramTypes.length, paramTypes.ptr);
259        }
260
261        /**
262         * A #GClosureMarshal function for use with signals with a single
263         * boolean argument.
264         *
265         * Params:
266         *     closure = A #GClosure.
267         *     returnValue = A #GValue to store the return value. May be %NULL
268         *         if the callback of closure doesn't return a value.
269         *     nParamValues = The length of the @param_values array.
270         *     paramValues = An array of #GValues holding the arguments
271         *         on which to invoke the callback of closure.
272         *     invocationHint = The invocation hint given as the last argument to
273         *         g_closure_invoke().
274         *     marshalData = Additional data specified when registering the
275         *         marshaller, see g_closure_set_marshal() and
276         *         g_closure_set_meta_marshal()
277         */
278        public static void marshalVOIDBOOLEAN(Closure closure, Value returnValue, uint nParamValues, Value paramValues, void* invocationHint, void* marshalData)
279        {
280                g_cclosure_marshal_VOID__BOOLEAN((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), nParamValues, (paramValues is null) ? null : paramValues.getValueStruct(), invocationHint, marshalData);
281        }
282
283        /**
284         * The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__BOOLEAN().
285         *
286         * Params:
287         *     closure = the #GClosure to which the marshaller belongs
288         *     returnValue = a #GValue to store the return
289         *         value. May be %NULL if the callback of @closure doesn't return a
290         *         value.
291         *     instanc = the instance on which the closure is invoked.
292         *     args = va_list of arguments to be passed to the closure.
293         *     marshalData = additional data specified when
294         *         registering the marshaller, see g_closure_set_marshal() and
295         *         g_closure_set_meta_marshal()
296         *     nParams = the length of the @param_types array
297         *     paramTypes = the #GType of each argument from
298         *         @args.
299         */
300        public static void marshalVOIDBOOLEANv(Closure closure, Value returnValue, void* instanc, void* args, void* marshalData, GType[] paramTypes)
301        {
302                g_cclosure_marshal_VOID__BOOLEANv((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), instanc, args, marshalData, cast(int)paramTypes.length, paramTypes.ptr);
303        }
304
305        /**
306         * A #GClosureMarshal function for use with signals with a single
307         * argument which is any boxed pointer type.
308         *
309         * Params:
310         *     closure = A #GClosure.
311         *     returnValue = A #GValue to store the return value. May be %NULL
312         *         if the callback of closure doesn't return a value.
313         *     nParamValues = The length of the @param_values array.
314         *     paramValues = An array of #GValues holding the arguments
315         *         on which to invoke the callback of closure.
316         *     invocationHint = The invocation hint given as the last argument to
317         *         g_closure_invoke().
318         *     marshalData = Additional data specified when registering the
319         *         marshaller, see g_closure_set_marshal() and
320         *         g_closure_set_meta_marshal()
321         */
322        public static void marshalVOIDBOXED(Closure closure, Value returnValue, uint nParamValues, Value paramValues, void* invocationHint, void* marshalData)
323        {
324                g_cclosure_marshal_VOID__BOXED((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), nParamValues, (paramValues is null) ? null : paramValues.getValueStruct(), invocationHint, marshalData);
325        }
326
327        /**
328         * The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__BOXED().
329         *
330         * Params:
331         *     closure = the #GClosure to which the marshaller belongs
332         *     returnValue = a #GValue to store the return
333         *         value. May be %NULL if the callback of @closure doesn't return a
334         *         value.
335         *     instanc = the instance on which the closure is invoked.
336         *     args = va_list of arguments to be passed to the closure.
337         *     marshalData = additional data specified when
338         *         registering the marshaller, see g_closure_set_marshal() and
339         *         g_closure_set_meta_marshal()
340         *     nParams = the length of the @param_types array
341         *     paramTypes = the #GType of each argument from
342         *         @args.
343         */
344        public static void marshalVOIDBOXEDv(Closure closure, Value returnValue, void* instanc, void* args, void* marshalData, GType[] paramTypes)
345        {
346                g_cclosure_marshal_VOID__BOXEDv((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), instanc, args, marshalData, cast(int)paramTypes.length, paramTypes.ptr);
347        }
348
349        /**
350         * A #GClosureMarshal function for use with signals with a single
351         * character argument.
352         *
353         * Params:
354         *     closure = A #GClosure.
355         *     returnValue = A #GValue to store the return value. May be %NULL
356         *         if the callback of closure doesn't return a value.
357         *     nParamValues = The length of the @param_values array.
358         *     paramValues = An array of #GValues holding the arguments
359         *         on which to invoke the callback of closure.
360         *     invocationHint = The invocation hint given as the last argument to
361         *         g_closure_invoke().
362         *     marshalData = Additional data specified when registering the
363         *         marshaller, see g_closure_set_marshal() and
364         *         g_closure_set_meta_marshal()
365         */
366        public static void marshalVOIDCHAR(Closure closure, Value returnValue, uint nParamValues, Value paramValues, void* invocationHint, void* marshalData)
367        {
368                g_cclosure_marshal_VOID__CHAR((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), nParamValues, (paramValues is null) ? null : paramValues.getValueStruct(), invocationHint, marshalData);
369        }
370
371        /**
372         * The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__CHAR().
373         *
374         * Params:
375         *     closure = the #GClosure to which the marshaller belongs
376         *     returnValue = a #GValue to store the return
377         *         value. May be %NULL if the callback of @closure doesn't return a
378         *         value.
379         *     instanc = the instance on which the closure is invoked.
380         *     args = va_list of arguments to be passed to the closure.
381         *     marshalData = additional data specified when
382         *         registering the marshaller, see g_closure_set_marshal() and
383         *         g_closure_set_meta_marshal()
384         *     nParams = the length of the @param_types array
385         *     paramTypes = the #GType of each argument from
386         *         @args.
387         */
388        public static void marshalVOIDCHARv(Closure closure, Value returnValue, void* instanc, void* args, void* marshalData, GType[] paramTypes)
389        {
390                g_cclosure_marshal_VOID__CHARv((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), instanc, args, marshalData, cast(int)paramTypes.length, paramTypes.ptr);
391        }
392
393        /**
394         * A #GClosureMarshal function for use with signals with one
395         * double-precision floating point argument.
396         *
397         * Params:
398         *     closure = A #GClosure.
399         *     returnValue = A #GValue to store the return value. May be %NULL
400         *         if the callback of closure doesn't return a value.
401         *     nParamValues = The length of the @param_values array.
402         *     paramValues = An array of #GValues holding the arguments
403         *         on which to invoke the callback of closure.
404         *     invocationHint = The invocation hint given as the last argument to
405         *         g_closure_invoke().
406         *     marshalData = Additional data specified when registering the
407         *         marshaller, see g_closure_set_marshal() and
408         *         g_closure_set_meta_marshal()
409         */
410        public static void marshalVOIDDOUBLE(Closure closure, Value returnValue, uint nParamValues, Value paramValues, void* invocationHint, void* marshalData)
411        {
412                g_cclosure_marshal_VOID__DOUBLE((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), nParamValues, (paramValues is null) ? null : paramValues.getValueStruct(), invocationHint, marshalData);
413        }
414
415        /**
416         * The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__DOUBLE().
417         *
418         * Params:
419         *     closure = the #GClosure to which the marshaller belongs
420         *     returnValue = a #GValue to store the return
421         *         value. May be %NULL if the callback of @closure doesn't return a
422         *         value.
423         *     instanc = the instance on which the closure is invoked.
424         *     args = va_list of arguments to be passed to the closure.
425         *     marshalData = additional data specified when
426         *         registering the marshaller, see g_closure_set_marshal() and
427         *         g_closure_set_meta_marshal()
428         *     nParams = the length of the @param_types array
429         *     paramTypes = the #GType of each argument from
430         *         @args.
431         */
432        public static void marshalVOIDDOUBLEv(Closure closure, Value returnValue, void* instanc, void* args, void* marshalData, GType[] paramTypes)
433        {
434                g_cclosure_marshal_VOID__DOUBLEv((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), instanc, args, marshalData, cast(int)paramTypes.length, paramTypes.ptr);
435        }
436
437        /**
438         * A #GClosureMarshal function for use with signals with a single
439         * argument with an enumerated type.
440         *
441         * Params:
442         *     closure = A #GClosure.
443         *     returnValue = A #GValue to store the return value. May be %NULL
444         *         if the callback of closure doesn't return a value.
445         *     nParamValues = The length of the @param_values array.
446         *     paramValues = An array of #GValues holding the arguments
447         *         on which to invoke the callback of closure.
448         *     invocationHint = The invocation hint given as the last argument to
449         *         g_closure_invoke().
450         *     marshalData = Additional data specified when registering the
451         *         marshaller, see g_closure_set_marshal() and
452         *         g_closure_set_meta_marshal()
453         */
454        public static void marshalVOIDENUM(Closure closure, Value returnValue, uint nParamValues, Value paramValues, void* invocationHint, void* marshalData)
455        {
456                g_cclosure_marshal_VOID__ENUM((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), nParamValues, (paramValues is null) ? null : paramValues.getValueStruct(), invocationHint, marshalData);
457        }
458
459        /**
460         * The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__ENUM().
461         *
462         * Params:
463         *     closure = the #GClosure to which the marshaller belongs
464         *     returnValue = a #GValue to store the return
465         *         value. May be %NULL if the callback of @closure doesn't return a
466         *         value.
467         *     instanc = the instance on which the closure is invoked.
468         *     args = va_list of arguments to be passed to the closure.
469         *     marshalData = additional data specified when
470         *         registering the marshaller, see g_closure_set_marshal() and
471         *         g_closure_set_meta_marshal()
472         *     nParams = the length of the @param_types array
473         *     paramTypes = the #GType of each argument from
474         *         @args.
475         */
476        public static void marshalVOIDENUMv(Closure closure, Value returnValue, void* instanc, void* args, void* marshalData, GType[] paramTypes)
477        {
478                g_cclosure_marshal_VOID__ENUMv((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), instanc, args, marshalData, cast(int)paramTypes.length, paramTypes.ptr);
479        }
480
481        /**
482         * A #GClosureMarshal function for use with signals with a single
483         * argument with a flags types.
484         *
485         * Params:
486         *     closure = A #GClosure.
487         *     returnValue = A #GValue to store the return value. May be %NULL
488         *         if the callback of closure doesn't return a value.
489         *     nParamValues = The length of the @param_values array.
490         *     paramValues = An array of #GValues holding the arguments
491         *         on which to invoke the callback of closure.
492         *     invocationHint = The invocation hint given as the last argument to
493         *         g_closure_invoke().
494         *     marshalData = Additional data specified when registering the
495         *         marshaller, see g_closure_set_marshal() and
496         *         g_closure_set_meta_marshal()
497         */
498        public static void marshalVOIDFLAGS(Closure closure, Value returnValue, uint nParamValues, Value paramValues, void* invocationHint, void* marshalData)
499        {
500                g_cclosure_marshal_VOID__FLAGS((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), nParamValues, (paramValues is null) ? null : paramValues.getValueStruct(), invocationHint, marshalData);
501        }
502
503        /**
504         * The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__FLAGS().
505         *
506         * Params:
507         *     closure = the #GClosure to which the marshaller belongs
508         *     returnValue = a #GValue to store the return
509         *         value. May be %NULL if the callback of @closure doesn't return a
510         *         value.
511         *     instanc = the instance on which the closure is invoked.
512         *     args = va_list of arguments to be passed to the closure.
513         *     marshalData = additional data specified when
514         *         registering the marshaller, see g_closure_set_marshal() and
515         *         g_closure_set_meta_marshal()
516         *     nParams = the length of the @param_types array
517         *     paramTypes = the #GType of each argument from
518         *         @args.
519         */
520        public static void marshalVOIDFLAGSv(Closure closure, Value returnValue, void* instanc, void* args, void* marshalData, GType[] paramTypes)
521        {
522                g_cclosure_marshal_VOID__FLAGSv((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), instanc, args, marshalData, cast(int)paramTypes.length, paramTypes.ptr);
523        }
524
525        /**
526         * A #GClosureMarshal function for use with signals with one
527         * single-precision floating point argument.
528         *
529         * Params:
530         *     closure = A #GClosure.
531         *     returnValue = A #GValue to store the return value. May be %NULL
532         *         if the callback of closure doesn't return a value.
533         *     nParamValues = The length of the @param_values array.
534         *     paramValues = An array of #GValues holding the arguments
535         *         on which to invoke the callback of closure.
536         *     invocationHint = The invocation hint given as the last argument to
537         *         g_closure_invoke().
538         *     marshalData = Additional data specified when registering the
539         *         marshaller, see g_closure_set_marshal() and
540         *         g_closure_set_meta_marshal()
541         */
542        public static void marshalVOIDFLOAT(Closure closure, Value returnValue, uint nParamValues, Value paramValues, void* invocationHint, void* marshalData)
543        {
544                g_cclosure_marshal_VOID__FLOAT((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), nParamValues, (paramValues is null) ? null : paramValues.getValueStruct(), invocationHint, marshalData);
545        }
546
547        /**
548         * The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__FLOAT().
549         *
550         * Params:
551         *     closure = the #GClosure to which the marshaller belongs
552         *     returnValue = a #GValue to store the return
553         *         value. May be %NULL if the callback of @closure doesn't return a
554         *         value.
555         *     instanc = the instance on which the closure is invoked.
556         *     args = va_list of arguments to be passed to the closure.
557         *     marshalData = additional data specified when
558         *         registering the marshaller, see g_closure_set_marshal() and
559         *         g_closure_set_meta_marshal()
560         *     nParams = the length of the @param_types array
561         *     paramTypes = the #GType of each argument from
562         *         @args.
563         */
564        public static void marshalVOIDFLOATv(Closure closure, Value returnValue, void* instanc, void* args, void* marshalData, GType[] paramTypes)
565        {
566                g_cclosure_marshal_VOID__FLOATv((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), instanc, args, marshalData, cast(int)paramTypes.length, paramTypes.ptr);
567        }
568
569        /**
570         * A #GClosureMarshal function for use with signals with a single
571         * integer argument.
572         *
573         * Params:
574         *     closure = A #GClosure.
575         *     returnValue = A #GValue to store the return value. May be %NULL
576         *         if the callback of closure doesn't return a value.
577         *     nParamValues = The length of the @param_values array.
578         *     paramValues = An array of #GValues holding the arguments
579         *         on which to invoke the callback of closure.
580         *     invocationHint = The invocation hint given as the last argument to
581         *         g_closure_invoke().
582         *     marshalData = Additional data specified when registering the
583         *         marshaller, see g_closure_set_marshal() and
584         *         g_closure_set_meta_marshal()
585         */
586        public static void marshalVOIDINT(Closure closure, Value returnValue, uint nParamValues, Value paramValues, void* invocationHint, void* marshalData)
587        {
588                g_cclosure_marshal_VOID__INT((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), nParamValues, (paramValues is null) ? null : paramValues.getValueStruct(), invocationHint, marshalData);
589        }
590
591        /**
592         * The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__INT().
593         *
594         * Params:
595         *     closure = the #GClosure to which the marshaller belongs
596         *     returnValue = a #GValue to store the return
597         *         value. May be %NULL if the callback of @closure doesn't return a
598         *         value.
599         *     instanc = the instance on which the closure is invoked.
600         *     args = va_list of arguments to be passed to the closure.
601         *     marshalData = additional data specified when
602         *         registering the marshaller, see g_closure_set_marshal() and
603         *         g_closure_set_meta_marshal()
604         *     nParams = the length of the @param_types array
605         *     paramTypes = the #GType of each argument from
606         *         @args.
607         */
608        public static void marshalVOIDINTv(Closure closure, Value returnValue, void* instanc, void* args, void* marshalData, GType[] paramTypes)
609        {
610                g_cclosure_marshal_VOID__INTv((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), instanc, args, marshalData, cast(int)paramTypes.length, paramTypes.ptr);
611        }
612
613        /**
614         * A #GClosureMarshal function for use with signals with with a single
615         * long integer argument.
616         *
617         * Params:
618         *     closure = A #GClosure.
619         *     returnValue = A #GValue to store the return value. May be %NULL
620         *         if the callback of closure doesn't return a value.
621         *     nParamValues = The length of the @param_values array.
622         *     paramValues = An array of #GValues holding the arguments
623         *         on which to invoke the callback of closure.
624         *     invocationHint = The invocation hint given as the last argument to
625         *         g_closure_invoke().
626         *     marshalData = Additional data specified when registering the
627         *         marshaller, see g_closure_set_marshal() and
628         *         g_closure_set_meta_marshal()
629         */
630        public static void marshalVOIDLONG(Closure closure, Value returnValue, uint nParamValues, Value paramValues, void* invocationHint, void* marshalData)
631        {
632                g_cclosure_marshal_VOID__LONG((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), nParamValues, (paramValues is null) ? null : paramValues.getValueStruct(), invocationHint, marshalData);
633        }
634
635        /**
636         * The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__LONG().
637         *
638         * Params:
639         *     closure = the #GClosure to which the marshaller belongs
640         *     returnValue = a #GValue to store the return
641         *         value. May be %NULL if the callback of @closure doesn't return a
642         *         value.
643         *     instanc = the instance on which the closure is invoked.
644         *     args = va_list of arguments to be passed to the closure.
645         *     marshalData = additional data specified when
646         *         registering the marshaller, see g_closure_set_marshal() and
647         *         g_closure_set_meta_marshal()
648         *     nParams = the length of the @param_types array
649         *     paramTypes = the #GType of each argument from
650         *         @args.
651         */
652        public static void marshalVOIDLONGv(Closure closure, Value returnValue, void* instanc, void* args, void* marshalData, GType[] paramTypes)
653        {
654                g_cclosure_marshal_VOID__LONGv((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), instanc, args, marshalData, cast(int)paramTypes.length, paramTypes.ptr);
655        }
656
657        /**
658         * A #GClosureMarshal function for use with signals with a single
659         * #GObject argument.
660         *
661         * Params:
662         *     closure = A #GClosure.
663         *     returnValue = A #GValue to store the return value. May be %NULL
664         *         if the callback of closure doesn't return a value.
665         *     nParamValues = The length of the @param_values array.
666         *     paramValues = An array of #GValues holding the arguments
667         *         on which to invoke the callback of closure.
668         *     invocationHint = The invocation hint given as the last argument to
669         *         g_closure_invoke().
670         *     marshalData = Additional data specified when registering the
671         *         marshaller, see g_closure_set_marshal() and
672         *         g_closure_set_meta_marshal()
673         */
674        public static void marshalVOIDOBJECT(Closure closure, Value returnValue, uint nParamValues, Value paramValues, void* invocationHint, void* marshalData)
675        {
676                g_cclosure_marshal_VOID__OBJECT((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), nParamValues, (paramValues is null) ? null : paramValues.getValueStruct(), invocationHint, marshalData);
677        }
678
679        /**
680         * The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__OBJECT().
681         *
682         * Params:
683         *     closure = the #GClosure to which the marshaller belongs
684         *     returnValue = a #GValue to store the return
685         *         value. May be %NULL if the callback of @closure doesn't return a
686         *         value.
687         *     instanc = the instance on which the closure is invoked.
688         *     args = va_list of arguments to be passed to the closure.
689         *     marshalData = additional data specified when
690         *         registering the marshaller, see g_closure_set_marshal() and
691         *         g_closure_set_meta_marshal()
692         *     nParams = the length of the @param_types array
693         *     paramTypes = the #GType of each argument from
694         *         @args.
695         */
696        public static void marshalVOIDOBJECTv(Closure closure, Value returnValue, void* instanc, void* args, void* marshalData, GType[] paramTypes)
697        {
698                g_cclosure_marshal_VOID__OBJECTv((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), instanc, args, marshalData, cast(int)paramTypes.length, paramTypes.ptr);
699        }
700
701        /**
702         * A #GClosureMarshal function for use with signals with a single
703         * argument of type #GParamSpec.
704         *
705         * Params:
706         *     closure = A #GClosure.
707         *     returnValue = A #GValue to store the return value. May be %NULL
708         *         if the callback of closure doesn't return a value.
709         *     nParamValues = The length of the @param_values array.
710         *     paramValues = An array of #GValues holding the arguments
711         *         on which to invoke the callback of closure.
712         *     invocationHint = The invocation hint given as the last argument to
713         *         g_closure_invoke().
714         *     marshalData = Additional data specified when registering the
715         *         marshaller, see g_closure_set_marshal() and
716         *         g_closure_set_meta_marshal()
717         */
718        public static void marshalVOIDPARAM(Closure closure, Value returnValue, uint nParamValues, Value paramValues, void* invocationHint, void* marshalData)
719        {
720                g_cclosure_marshal_VOID__PARAM((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), nParamValues, (paramValues is null) ? null : paramValues.getValueStruct(), invocationHint, marshalData);
721        }
722
723        /**
724         * The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__PARAM().
725         *
726         * Params:
727         *     closure = the #GClosure to which the marshaller belongs
728         *     returnValue = a #GValue to store the return
729         *         value. May be %NULL if the callback of @closure doesn't return a
730         *         value.
731         *     instanc = the instance on which the closure is invoked.
732         *     args = va_list of arguments to be passed to the closure.
733         *     marshalData = additional data specified when
734         *         registering the marshaller, see g_closure_set_marshal() and
735         *         g_closure_set_meta_marshal()
736         *     nParams = the length of the @param_types array
737         *     paramTypes = the #GType of each argument from
738         *         @args.
739         */
740        public static void marshalVOIDPARAMv(Closure closure, Value returnValue, void* instanc, void* args, void* marshalData, GType[] paramTypes)
741        {
742                g_cclosure_marshal_VOID__PARAMv((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), instanc, args, marshalData, cast(int)paramTypes.length, paramTypes.ptr);
743        }
744
745        /**
746         * A #GClosureMarshal function for use with signals with a single raw
747         * pointer argument type.
748         *
749         * If it is possible, it is better to use one of the more specific
750         * functions such as g_cclosure_marshal_VOID__OBJECT() or
751         * g_cclosure_marshal_VOID__OBJECT().
752         *
753         * Params:
754         *     closure = A #GClosure.
755         *     returnValue = A #GValue to store the return value. May be %NULL
756         *         if the callback of closure doesn't return a value.
757         *     nParamValues = The length of the @param_values array.
758         *     paramValues = An array of #GValues holding the arguments
759         *         on which to invoke the callback of closure.
760         *     invocationHint = The invocation hint given as the last argument to
761         *         g_closure_invoke().
762         *     marshalData = Additional data specified when registering the
763         *         marshaller, see g_closure_set_marshal() and
764         *         g_closure_set_meta_marshal()
765         */
766        public static void marshalVOIDPOINTER(Closure closure, Value returnValue, uint nParamValues, Value paramValues, void* invocationHint, void* marshalData)
767        {
768                g_cclosure_marshal_VOID__POINTER((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), nParamValues, (paramValues is null) ? null : paramValues.getValueStruct(), invocationHint, marshalData);
769        }
770
771        /**
772         * The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__POINTER().
773         *
774         * Params:
775         *     closure = the #GClosure to which the marshaller belongs
776         *     returnValue = a #GValue to store the return
777         *         value. May be %NULL if the callback of @closure doesn't return a
778         *         value.
779         *     instanc = the instance on which the closure is invoked.
780         *     args = va_list of arguments to be passed to the closure.
781         *     marshalData = additional data specified when
782         *         registering the marshaller, see g_closure_set_marshal() and
783         *         g_closure_set_meta_marshal()
784         *     nParams = the length of the @param_types array
785         *     paramTypes = the #GType of each argument from
786         *         @args.
787         */
788        public static void marshalVOIDPOINTERv(Closure closure, Value returnValue, void* instanc, void* args, void* marshalData, GType[] paramTypes)
789        {
790                g_cclosure_marshal_VOID__POINTERv((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), instanc, args, marshalData, cast(int)paramTypes.length, paramTypes.ptr);
791        }
792
793        /**
794         * A #GClosureMarshal function for use with signals with a single string
795         * argument.
796         *
797         * Params:
798         *     closure = A #GClosure.
799         *     returnValue = A #GValue to store the return value. May be %NULL
800         *         if the callback of closure doesn't return a value.
801         *     nParamValues = The length of the @param_values array.
802         *     paramValues = An array of #GValues holding the arguments
803         *         on which to invoke the callback of closure.
804         *     invocationHint = The invocation hint given as the last argument to
805         *         g_closure_invoke().
806         *     marshalData = Additional data specified when registering the
807         *         marshaller, see g_closure_set_marshal() and
808         *         g_closure_set_meta_marshal()
809         */
810        public static void marshalVOIDSTRING(Closure closure, Value returnValue, uint nParamValues, Value paramValues, void* invocationHint, void* marshalData)
811        {
812                g_cclosure_marshal_VOID__STRING((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), nParamValues, (paramValues is null) ? null : paramValues.getValueStruct(), invocationHint, marshalData);
813        }
814
815        /**
816         * The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__STRING().
817         *
818         * Params:
819         *     closure = the #GClosure to which the marshaller belongs
820         *     returnValue = a #GValue to store the return
821         *         value. May be %NULL if the callback of @closure doesn't return a
822         *         value.
823         *     instanc = the instance on which the closure is invoked.
824         *     args = va_list of arguments to be passed to the closure.
825         *     marshalData = additional data specified when
826         *         registering the marshaller, see g_closure_set_marshal() and
827         *         g_closure_set_meta_marshal()
828         *     nParams = the length of the @param_types array
829         *     paramTypes = the #GType of each argument from
830         *         @args.
831         */
832        public static void marshalVOIDSTRINGv(Closure closure, Value returnValue, void* instanc, void* args, void* marshalData, GType[] paramTypes)
833        {
834                g_cclosure_marshal_VOID__STRINGv((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), instanc, args, marshalData, cast(int)paramTypes.length, paramTypes.ptr);
835        }
836
837        /**
838         * A #GClosureMarshal function for use with signals with a single
839         * unsigned character argument.
840         *
841         * Params:
842         *     closure = A #GClosure.
843         *     returnValue = A #GValue to store the return value. May be %NULL
844         *         if the callback of closure doesn't return a value.
845         *     nParamValues = The length of the @param_values array.
846         *     paramValues = An array of #GValues holding the arguments
847         *         on which to invoke the callback of closure.
848         *     invocationHint = The invocation hint given as the last argument to
849         *         g_closure_invoke().
850         *     marshalData = Additional data specified when registering the
851         *         marshaller, see g_closure_set_marshal() and
852         *         g_closure_set_meta_marshal()
853         */
854        public static void marshalVOIDUCHAR(Closure closure, Value returnValue, uint nParamValues, Value paramValues, void* invocationHint, void* marshalData)
855        {
856                g_cclosure_marshal_VOID__UCHAR((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), nParamValues, (paramValues is null) ? null : paramValues.getValueStruct(), invocationHint, marshalData);
857        }
858
859        /**
860         * The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__UCHAR().
861         *
862         * Params:
863         *     closure = the #GClosure to which the marshaller belongs
864         *     returnValue = a #GValue to store the return
865         *         value. May be %NULL if the callback of @closure doesn't return a
866         *         value.
867         *     instanc = the instance on which the closure is invoked.
868         *     args = va_list of arguments to be passed to the closure.
869         *     marshalData = additional data specified when
870         *         registering the marshaller, see g_closure_set_marshal() and
871         *         g_closure_set_meta_marshal()
872         *     nParams = the length of the @param_types array
873         *     paramTypes = the #GType of each argument from
874         *         @args.
875         */
876        public static void marshalVOIDUCHARv(Closure closure, Value returnValue, void* instanc, void* args, void* marshalData, GType[] paramTypes)
877        {
878                g_cclosure_marshal_VOID__UCHARv((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), instanc, args, marshalData, cast(int)paramTypes.length, paramTypes.ptr);
879        }
880
881        /**
882         * A #GClosureMarshal function for use with signals with with a single
883         * unsigned integer argument.
884         *
885         * Params:
886         *     closure = A #GClosure.
887         *     returnValue = A #GValue to store the return value. May be %NULL
888         *         if the callback of closure doesn't return a value.
889         *     nParamValues = The length of the @param_values array.
890         *     paramValues = An array of #GValues holding the arguments
891         *         on which to invoke the callback of closure.
892         *     invocationHint = The invocation hint given as the last argument to
893         *         g_closure_invoke().
894         *     marshalData = Additional data specified when registering the
895         *         marshaller, see g_closure_set_marshal() and
896         *         g_closure_set_meta_marshal()
897         */
898        public static void marshalVOIDUINT(Closure closure, Value returnValue, uint nParamValues, Value paramValues, void* invocationHint, void* marshalData)
899        {
900                g_cclosure_marshal_VOID__UINT((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), nParamValues, (paramValues is null) ? null : paramValues.getValueStruct(), invocationHint, marshalData);
901        }
902
903        /**
904         * A #GClosureMarshal function for use with signals with a unsigned int
905         * and a pointer as arguments.
906         *
907         * Params:
908         *     closure = A #GClosure.
909         *     returnValue = A #GValue to store the return value. May be %NULL
910         *         if the callback of closure doesn't return a value.
911         *     nParamValues = The length of the @param_values array.
912         *     paramValues = An array of #GValues holding the arguments
913         *         on which to invoke the callback of closure.
914         *     invocationHint = The invocation hint given as the last argument to
915         *         g_closure_invoke().
916         *     marshalData = Additional data specified when registering the
917         *         marshaller, see g_closure_set_marshal() and
918         *         g_closure_set_meta_marshal()
919         */
920        public static void marshalVOIDUINTPOINTER(Closure closure, Value returnValue, uint nParamValues, Value paramValues, void* invocationHint, void* marshalData)
921        {
922                g_cclosure_marshal_VOID__UINT_POINTER((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), nParamValues, (paramValues is null) ? null : paramValues.getValueStruct(), invocationHint, marshalData);
923        }
924
925        /**
926         * The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__UINT_POINTER().
927         *
928         * Params:
929         *     closure = the #GClosure to which the marshaller belongs
930         *     returnValue = a #GValue to store the return
931         *         value. May be %NULL if the callback of @closure doesn't return a
932         *         value.
933         *     instanc = the instance on which the closure is invoked.
934         *     args = va_list of arguments to be passed to the closure.
935         *     marshalData = additional data specified when
936         *         registering the marshaller, see g_closure_set_marshal() and
937         *         g_closure_set_meta_marshal()
938         *     nParams = the length of the @param_types array
939         *     paramTypes = the #GType of each argument from
940         *         @args.
941         */
942        public static void marshalVOIDUINTPOINTERv(Closure closure, Value returnValue, void* instanc, void* args, void* marshalData, GType[] paramTypes)
943        {
944                g_cclosure_marshal_VOID__UINT_POINTERv((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), instanc, args, marshalData, cast(int)paramTypes.length, paramTypes.ptr);
945        }
946
947        /**
948         * The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__UINT().
949         *
950         * Params:
951         *     closure = the #GClosure to which the marshaller belongs
952         *     returnValue = a #GValue to store the return
953         *         value. May be %NULL if the callback of @closure doesn't return a
954         *         value.
955         *     instanc = the instance on which the closure is invoked.
956         *     args = va_list of arguments to be passed to the closure.
957         *     marshalData = additional data specified when
958         *         registering the marshaller, see g_closure_set_marshal() and
959         *         g_closure_set_meta_marshal()
960         *     nParams = the length of the @param_types array
961         *     paramTypes = the #GType of each argument from
962         *         @args.
963         */
964        public static void marshalVOIDUINTv(Closure closure, Value returnValue, void* instanc, void* args, void* marshalData, GType[] paramTypes)
965        {
966                g_cclosure_marshal_VOID__UINTv((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), instanc, args, marshalData, cast(int)paramTypes.length, paramTypes.ptr);
967        }
968
969        /**
970         * A #GClosureMarshal function for use with signals with a single
971         * unsigned long integer argument.
972         *
973         * Params:
974         *     closure = A #GClosure.
975         *     returnValue = A #GValue to store the return value. May be %NULL
976         *         if the callback of closure doesn't return a value.
977         *     nParamValues = The length of the @param_values array.
978         *     paramValues = An array of #GValues holding the arguments
979         *         on which to invoke the callback of closure.
980         *     invocationHint = The invocation hint given as the last argument to
981         *         g_closure_invoke().
982         *     marshalData = Additional data specified when registering the
983         *         marshaller, see g_closure_set_marshal() and
984         *         g_closure_set_meta_marshal()
985         */
986        public static void marshalVOIDULONG(Closure closure, Value returnValue, uint nParamValues, Value paramValues, void* invocationHint, void* marshalData)
987        {
988                g_cclosure_marshal_VOID__ULONG((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), nParamValues, (paramValues is null) ? null : paramValues.getValueStruct(), invocationHint, marshalData);
989        }
990
991        /**
992         * The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__ULONG().
993         *
994         * Params:
995         *     closure = the #GClosure to which the marshaller belongs
996         *     returnValue = a #GValue to store the return
997         *         value. May be %NULL if the callback of @closure doesn't return a
998         *         value.
999         *     instanc = the instance on which the closure is invoked.
1000         *     args = va_list of arguments to be passed to the closure.
1001         *     marshalData = additional data specified when
1002         *         registering the marshaller, see g_closure_set_marshal() and
1003         *         g_closure_set_meta_marshal()
1004         *     nParams = the length of the @param_types array
1005         *     paramTypes = the #GType of each argument from
1006         *         @args.
1007         */
1008        public static void marshalVOIDULONGv(Closure closure, Value returnValue, void* instanc, void* args, void* marshalData, GType[] paramTypes)
1009        {
1010                g_cclosure_marshal_VOID__ULONGv((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), instanc, args, marshalData, cast(int)paramTypes.length, paramTypes.ptr);
1011        }
1012
1013        /**
1014         * A #GClosureMarshal function for use with signals with a single
1015         * #GVariant argument.
1016         *
1017         * Params:
1018         *     closure = A #GClosure.
1019         *     returnValue = A #GValue to store the return value. May be %NULL
1020         *         if the callback of closure doesn't return a value.
1021         *     nParamValues = The length of the @param_values array.
1022         *     paramValues = An array of #GValues holding the arguments
1023         *         on which to invoke the callback of closure.
1024         *     invocationHint = The invocation hint given as the last argument to
1025         *         g_closure_invoke().
1026         *     marshalData = Additional data specified when registering the
1027         *         marshaller, see g_closure_set_marshal() and
1028         *         g_closure_set_meta_marshal()
1029         */
1030        public static void marshalVOIDVARIANT(Closure closure, Value returnValue, uint nParamValues, Value paramValues, void* invocationHint, void* marshalData)
1031        {
1032                g_cclosure_marshal_VOID__VARIANT((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), nParamValues, (paramValues is null) ? null : paramValues.getValueStruct(), invocationHint, marshalData);
1033        }
1034
1035        /**
1036         * The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__VARIANT().
1037         *
1038         * Params:
1039         *     closure = the #GClosure to which the marshaller belongs
1040         *     returnValue = a #GValue to store the return
1041         *         value. May be %NULL if the callback of @closure doesn't return a
1042         *         value.
1043         *     instanc = the instance on which the closure is invoked.
1044         *     args = va_list of arguments to be passed to the closure.
1045         *     marshalData = additional data specified when
1046         *         registering the marshaller, see g_closure_set_marshal() and
1047         *         g_closure_set_meta_marshal()
1048         *     nParams = the length of the @param_types array
1049         *     paramTypes = the #GType of each argument from
1050         *         @args.
1051         */
1052        public static void marshalVOIDVARIANTv(Closure closure, Value returnValue, void* instanc, void* args, void* marshalData, GType[] paramTypes)
1053        {
1054                g_cclosure_marshal_VOID__VARIANTv((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), instanc, args, marshalData, cast(int)paramTypes.length, paramTypes.ptr);
1055        }
1056
1057        /**
1058         * A #GClosureMarshal function for use with signals with no arguments.
1059         *
1060         * Params:
1061         *     closure = A #GClosure.
1062         *     returnValue = A #GValue to store the return value. May be %NULL
1063         *         if the callback of closure doesn't return a value.
1064         *     nParamValues = The length of the @param_values array.
1065         *     paramValues = An array of #GValues holding the arguments
1066         *         on which to invoke the callback of closure.
1067         *     invocationHint = The invocation hint given as the last argument to
1068         *         g_closure_invoke().
1069         *     marshalData = Additional data specified when registering the
1070         *         marshaller, see g_closure_set_marshal() and
1071         *         g_closure_set_meta_marshal()
1072         */
1073        public static void marshalVOIDVOID(Closure closure, Value returnValue, uint nParamValues, Value paramValues, void* invocationHint, void* marshalData)
1074        {
1075                g_cclosure_marshal_VOID__VOID((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), nParamValues, (paramValues is null) ? null : paramValues.getValueStruct(), invocationHint, marshalData);
1076        }
1077
1078        /**
1079         * The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__VOID().
1080         *
1081         * Params:
1082         *     closure = the #GClosure to which the marshaller belongs
1083         *     returnValue = a #GValue to store the return
1084         *         value. May be %NULL if the callback of @closure doesn't return a
1085         *         value.
1086         *     instanc = the instance on which the closure is invoked.
1087         *     args = va_list of arguments to be passed to the closure.
1088         *     marshalData = additional data specified when
1089         *         registering the marshaller, see g_closure_set_marshal() and
1090         *         g_closure_set_meta_marshal()
1091         *     nParams = the length of the @param_types array
1092         *     paramTypes = the #GType of each argument from
1093         *         @args.
1094         */
1095        public static void marshalVOIDVOIDv(Closure closure, Value returnValue, void* instanc, void* args, void* marshalData, GType[] paramTypes)
1096        {
1097                g_cclosure_marshal_VOID__VOIDv((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), instanc, args, marshalData, cast(int)paramTypes.length, paramTypes.ptr);
1098        }
1099
1100        /**
1101         * A generic marshaller function implemented via
1102         * [libffi](http://sourceware.org/libffi/).
1103         *
1104         * Normally this function is not passed explicitly to g_signal_new(),
1105         * but used automatically by GLib when specifying a %NULL marshaller.
1106         *
1107         * Params:
1108         *     closure = A #GClosure.
1109         *     returnGvalue = A #GValue to store the return value. May be %NULL
1110         *         if the callback of closure doesn't return a value.
1111         *     nParamValues = The length of the @param_values array.
1112         *     paramValues = An array of #GValues holding the arguments
1113         *         on which to invoke the callback of closure.
1114         *     invocationHint = The invocation hint given as the last argument to
1115         *         g_closure_invoke().
1116         *     marshalData = Additional data specified when registering the
1117         *         marshaller, see g_closure_set_marshal() and
1118         *         g_closure_set_meta_marshal()
1119         *
1120         * Since: 2.30
1121         */
1122        public static void marshalGeneric(Closure closure, Value returnGvalue, uint nParamValues, Value paramValues, void* invocationHint, void* marshalData)
1123        {
1124                g_cclosure_marshal_generic((closure is null) ? null : closure.getClosureStruct(), (returnGvalue is null) ? null : returnGvalue.getValueStruct(), nParamValues, (paramValues is null) ? null : paramValues.getValueStruct(), invocationHint, marshalData);
1125        }
1126
1127        /**
1128         * A generic #GVaClosureMarshal function implemented via
1129         * [libffi](http://sourceware.org/libffi/).
1130         *
1131         * Params:
1132         *     closure = the #GClosure to which the marshaller belongs
1133         *     returnValue = a #GValue to store the return
1134         *         value. May be %NULL if the callback of @closure doesn't return a
1135         *         value.
1136         *     instanc = the instance on which the closure is invoked.
1137         *     argsList = va_list of arguments to be passed to the closure.
1138         *     marshalData = additional data specified when
1139         *         registering the marshaller, see g_closure_set_marshal() and
1140         *         g_closure_set_meta_marshal()
1141         *     nParams = the length of the @param_types array
1142         *     paramTypes = the #GType of each argument from
1143         *         @args_list.
1144         *
1145         * Since: 2.30
1146         */
1147        public static void marshalGenericVa(Closure closure, Value returnValue, void* instanc, void* argsList, void* marshalData, GType[] paramTypes)
1148        {
1149                g_cclosure_marshal_generic_va((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), instanc, argsList, marshalData, cast(int)paramTypes.length, paramTypes.ptr);
1150        }
1151}
Note: See TracBrowser for help on using the repository browser.