1 /* GObject - GLib Type, Object, Parameter and Signal Library
2 *
3 * This library is free software; you can redistribute it and/or
4 * modify it under the terms of the GNU Lesser General Public
5 * License as published by the Free Software Foundation; either
6 * version 2.1 of the License, or (at your option) any later version.
7 *
8 * This library is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 * Lesser General Public License for more details.
12 *
13 * You should have received a copy of the GNU Lesser General
14 * Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
15 */
16
17 #include "config.h"
18
19 #include "gobject.h"
20 #include "genums.h"
21 #include "gboxed.h"
22 #include "gvaluetypes.h"
23
24
25 #ifdef G_ENABLE_DEBUG
26 #define g_marshal_value_peek_boolean(v) g_value_get_boolean (v)
27 #define g_marshal_value_peek_char(v) g_value_get_schar (v)
28 #define g_marshal_value_peek_uchar(v) g_value_get_uchar (v)
29 #define g_marshal_value_peek_int(v) g_value_get_int (v)
30 #define g_marshal_value_peek_uint(v) g_value_get_uint (v)
31 #define g_marshal_value_peek_long(v) g_value_get_long (v)
32 #define g_marshal_value_peek_ulong(v) g_value_get_ulong (v)
33 #define g_marshal_value_peek_int64(v) g_value_get_int64 (v)
34 #define g_marshal_value_peek_uint64(v) g_value_get_uint64 (v)
35 #define g_marshal_value_peek_enum(v) g_value_get_enum (v)
36 #define g_marshal_value_peek_flags(v) g_value_get_flags (v)
37 #define g_marshal_value_peek_float(v) g_value_get_float (v)
38 #define g_marshal_value_peek_double(v) g_value_get_double (v)
39 #define g_marshal_value_peek_string(v) (char*) g_value_get_string (v)
40 #define g_marshal_value_peek_param(v) g_value_get_param (v)
41 #define g_marshal_value_peek_boxed(v) g_value_get_boxed (v)
42 #define g_marshal_value_peek_pointer(v) g_value_get_pointer (v)
43 #define g_marshal_value_peek_object(v) g_value_get_object (v)
44 #define g_marshal_value_peek_variant(v) g_value_get_variant (v)
45 #else /* !G_ENABLE_DEBUG */
46 /* WARNING: This code accesses GValues directly, which is UNSUPPORTED API.
47 * Do not access GValues directly in your code. Instead, use the
48 * g_value_get_*() functions
49 */
50 #define g_marshal_value_peek_boolean(v) (v)->data[0].v_int
51 #define g_marshal_value_peek_char(v) (v)->data[0].v_int
52 #define g_marshal_value_peek_uchar(v) (v)->data[0].v_uint
53 #define g_marshal_value_peek_int(v) (v)->data[0].v_int
54 #define g_marshal_value_peek_uint(v) (v)->data[0].v_uint
55 #define g_marshal_value_peek_long(v) (v)->data[0].v_long
56 #define g_marshal_value_peek_ulong(v) (v)->data[0].v_ulong
57 #define g_marshal_value_peek_int64(v) (v)->data[0].v_int64
58 #define g_marshal_value_peek_uint64(v) (v)->data[0].v_uint64
59 #define g_marshal_value_peek_enum(v) (v)->data[0].v_long
60 #define g_marshal_value_peek_flags(v) (v)->data[0].v_ulong
61 #define g_marshal_value_peek_float(v) (v)->data[0].v_float
62 #define g_marshal_value_peek_double(v) (v)->data[0].v_double
63 #define g_marshal_value_peek_string(v) (v)->data[0].v_pointer
64 #define g_marshal_value_peek_param(v) (v)->data[0].v_pointer
65 #define g_marshal_value_peek_boxed(v) (v)->data[0].v_pointer
66 #define g_marshal_value_peek_pointer(v) (v)->data[0].v_pointer
67 #define g_marshal_value_peek_object(v) (v)->data[0].v_pointer
68 #define g_marshal_value_peek_variant(v) (v)->data[0].v_pointer
69 #endif /* !G_ENABLE_DEBUG */
70
71
72 /**
73 * g_cclosure_marshal_VOID__VOID:
74 * @closure: A #GClosure.
75 * @return_value: A #GValue to store the return value. May be %NULL
76 * if the callback of closure doesn't return a value.
77 * @n_param_values: The length of the @param_values array.
78 * @param_values: An array of #GValues holding the arguments
79 * on which to invoke the callback of closure.
80 * @invocation_hint: The invocation hint given as the last argument to
81 * g_closure_invoke().
82 * @marshal_data: Additional data specified when registering the
83 * marshaller, see g_closure_set_marshal() and
84 * g_closure_set_meta_marshal()
85 *
86 * A #GClosureMarshal function for use with signals with no arguments.
87 */
88 /* VOID:VOID */
89 void
g_cclosure_marshal_VOID__VOID(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)90 g_cclosure_marshal_VOID__VOID (GClosure *closure,
91 GValue *return_value G_GNUC_UNUSED,
92 guint n_param_values,
93 const GValue *param_values,
94 gpointer invocation_hint G_GNUC_UNUSED,
95 gpointer marshal_data)
96 {
97 typedef void (*GMarshalFunc_VOID__VOID) (gpointer data1,
98 gpointer data2);
99 GMarshalFunc_VOID__VOID callback;
100 GCClosure *cc = (GCClosure*) closure;
101 gpointer data1, data2;
102
103 g_return_if_fail (n_param_values == 1);
104
105 if (G_CCLOSURE_SWAP_DATA (closure))
106 {
107 data1 = closure->data;
108 data2 = g_value_peek_pointer (param_values + 0);
109 }
110 else
111 {
112 data1 = g_value_peek_pointer (param_values + 0);
113 data2 = closure->data;
114 }
115 callback = (GMarshalFunc_VOID__VOID) (marshal_data ? marshal_data : cc->callback);
116
117 callback (data1,
118 data2);
119 }
120
121 /**
122 * g_cclosure_marshal_VOID__VOIDv:
123 * @closure: the #GClosure to which the marshaller belongs
124 * @return_value: (nullable): a #GValue to store the return
125 * value. May be %NULL if the callback of @closure doesn't return a
126 * value.
127 * @instance: (type GObject.TypeInstance): the instance on which the closure is invoked.
128 * @args: va_list of arguments to be passed to the closure.
129 * @marshal_data: (nullable): additional data specified when
130 * registering the marshaller, see g_closure_set_marshal() and
131 * g_closure_set_meta_marshal()
132 * @n_params: the length of the @param_types array
133 * @param_types: (array length=n_params): the #GType of each argument from
134 * @args.
135 *
136 * The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__VOID().
137 */
138 void
g_cclosure_marshal_VOID__VOIDv(GClosure * closure,GValue * return_value,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)139 g_cclosure_marshal_VOID__VOIDv (GClosure *closure,
140 GValue *return_value,
141 gpointer instance,
142 va_list args,
143 gpointer marshal_data,
144 int n_params,
145 GType *param_types)
146 {
147 typedef void (*GMarshalFunc_VOID__VOID) (gpointer instance,
148 gpointer data);
149 GCClosure *cc = (GCClosure*) closure;
150 gpointer data1, data2;
151 GMarshalFunc_VOID__VOID callback;
152
153 if (G_CCLOSURE_SWAP_DATA (closure))
154 {
155 data1 = closure->data;
156 data2 = instance;
157 }
158 else
159 {
160 data1 = instance;
161 data2 = closure->data;
162 }
163 callback = (GMarshalFunc_VOID__VOID) (marshal_data ? marshal_data : cc->callback);
164
165 callback (data1,
166 data2);
167 }
168
169 /**
170 * g_cclosure_marshal_VOID__BOOLEAN:
171 * @closure: A #GClosure.
172 * @return_value: A #GValue to store the return value. May be %NULL
173 * if the callback of closure doesn't return a value.
174 * @n_param_values: The length of the @param_values array.
175 * @param_values: An array of #GValues holding the arguments
176 * on which to invoke the callback of closure.
177 * @invocation_hint: The invocation hint given as the last argument to
178 * g_closure_invoke().
179 * @marshal_data: Additional data specified when registering the
180 * marshaller, see g_closure_set_marshal() and
181 * g_closure_set_meta_marshal()
182 *
183 * A #GClosureMarshal function for use with signals with a single
184 * boolean argument.
185 */
186 /* VOID:BOOLEAN */
187 void
g_cclosure_marshal_VOID__BOOLEAN(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)188 g_cclosure_marshal_VOID__BOOLEAN (GClosure *closure,
189 GValue *return_value G_GNUC_UNUSED,
190 guint n_param_values,
191 const GValue *param_values,
192 gpointer invocation_hint G_GNUC_UNUSED,
193 gpointer marshal_data)
194 {
195 typedef void (*GMarshalFunc_VOID__BOOLEAN) (gpointer data1,
196 gboolean arg_1,
197 gpointer data2);
198 GMarshalFunc_VOID__BOOLEAN callback;
199 GCClosure *cc = (GCClosure*) closure;
200 gpointer data1, data2;
201
202 g_return_if_fail (n_param_values == 2);
203
204 if (G_CCLOSURE_SWAP_DATA (closure))
205 {
206 data1 = closure->data;
207 data2 = g_value_peek_pointer (param_values + 0);
208 }
209 else
210 {
211 data1 = g_value_peek_pointer (param_values + 0);
212 data2 = closure->data;
213 }
214 callback = (GMarshalFunc_VOID__BOOLEAN) (marshal_data ? marshal_data : cc->callback);
215
216 callback (data1,
217 g_marshal_value_peek_boolean (param_values + 1),
218 data2);
219 }
220
221 /**
222 * g_cclosure_marshal_VOID__BOOLEANv:
223 * @closure: the #GClosure to which the marshaller belongs
224 * @return_value: (nullable): a #GValue to store the return
225 * value. May be %NULL if the callback of @closure doesn't return a
226 * value.
227 * @instance: (type GObject.TypeInstance): the instance on which the closure is invoked.
228 * @args: va_list of arguments to be passed to the closure.
229 * @marshal_data: (nullable): additional data specified when
230 * registering the marshaller, see g_closure_set_marshal() and
231 * g_closure_set_meta_marshal()
232 * @n_params: the length of the @param_types array
233 * @param_types: (array length=n_params): the #GType of each argument from
234 * @args.
235 *
236 * The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__BOOLEAN().
237 */
238 void
g_cclosure_marshal_VOID__BOOLEANv(GClosure * closure,GValue * return_value,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)239 g_cclosure_marshal_VOID__BOOLEANv (GClosure *closure,
240 GValue *return_value,
241 gpointer instance,
242 va_list args,
243 gpointer marshal_data,
244 int n_params,
245 GType *param_types)
246 {
247 typedef void (*GMarshalFunc_VOID__BOOLEAN) (gpointer instance,
248 gboolean arg_0,
249 gpointer data);
250 GCClosure *cc = (GCClosure*) closure;
251 gpointer data1, data2;
252 GMarshalFunc_VOID__BOOLEAN callback;
253 gboolean arg0;
254 va_list args_copy;
255
256 G_VA_COPY (args_copy, args);
257 arg0 = (gboolean) va_arg (args_copy, gboolean);
258 va_end (args_copy);
259
260 if (G_CCLOSURE_SWAP_DATA (closure))
261 {
262 data1 = closure->data;
263 data2 = instance;
264 }
265 else
266 {
267 data1 = instance;
268 data2 = closure->data;
269 }
270 callback = (GMarshalFunc_VOID__BOOLEAN) (marshal_data ? marshal_data : cc->callback);
271
272 callback (data1,
273 arg0,
274 data2);
275 }
276
277 /**
278 * g_cclosure_marshal_VOID__CHAR:
279 * @closure: A #GClosure.
280 * @return_value: A #GValue to store the return value. May be %NULL
281 * if the callback of closure doesn't return a value.
282 * @n_param_values: The length of the @param_values array.
283 * @param_values: An array of #GValues holding the arguments
284 * on which to invoke the callback of closure.
285 * @invocation_hint: The invocation hint given as the last argument to
286 * g_closure_invoke().
287 * @marshal_data: Additional data specified when registering the
288 * marshaller, see g_closure_set_marshal() and
289 * g_closure_set_meta_marshal()
290 *
291 * A #GClosureMarshal function for use with signals with a single
292 * character argument.
293 */
294 /* VOID:CHAR */
295 void
g_cclosure_marshal_VOID__CHAR(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)296 g_cclosure_marshal_VOID__CHAR (GClosure *closure,
297 GValue *return_value G_GNUC_UNUSED,
298 guint n_param_values,
299 const GValue *param_values,
300 gpointer invocation_hint G_GNUC_UNUSED,
301 gpointer marshal_data)
302 {
303 typedef void (*GMarshalFunc_VOID__CHAR) (gpointer data1,
304 gchar arg_1,
305 gpointer data2);
306 GMarshalFunc_VOID__CHAR callback;
307 GCClosure *cc = (GCClosure*) closure;
308 gpointer data1, data2;
309
310 g_return_if_fail (n_param_values == 2);
311
312 if (G_CCLOSURE_SWAP_DATA (closure))
313 {
314 data1 = closure->data;
315 data2 = g_value_peek_pointer (param_values + 0);
316 }
317 else
318 {
319 data1 = g_value_peek_pointer (param_values + 0);
320 data2 = closure->data;
321 }
322 callback = (GMarshalFunc_VOID__CHAR) (marshal_data ? marshal_data : cc->callback);
323
324 callback (data1,
325 g_marshal_value_peek_char (param_values + 1),
326 data2);
327 }
328
329 /**
330 * g_cclosure_marshal_VOID__CHARv:
331 * @closure: the #GClosure to which the marshaller belongs
332 * @return_value: (nullable): a #GValue to store the return
333 * value. May be %NULL if the callback of @closure doesn't return a
334 * value.
335 * @instance: (type GObject.TypeInstance): the instance on which the closure is invoked.
336 * @args: va_list of arguments to be passed to the closure.
337 * @marshal_data: (nullable): additional data specified when
338 * registering the marshaller, see g_closure_set_marshal() and
339 * g_closure_set_meta_marshal()
340 * @n_params: the length of the @param_types array
341 * @param_types: (array length=n_params): the #GType of each argument from
342 * @args.
343 *
344 * The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__CHAR().
345 */
346 void
g_cclosure_marshal_VOID__CHARv(GClosure * closure,GValue * return_value,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)347 g_cclosure_marshal_VOID__CHARv (GClosure *closure,
348 GValue *return_value,
349 gpointer instance,
350 va_list args,
351 gpointer marshal_data,
352 int n_params,
353 GType *param_types)
354 {
355 typedef void (*GMarshalFunc_VOID__CHAR) (gpointer instance,
356 gchar arg_0,
357 gpointer data);
358 GCClosure *cc = (GCClosure*) closure;
359 gpointer data1, data2;
360 GMarshalFunc_VOID__CHAR callback;
361 gchar arg0;
362 va_list args_copy;
363
364 G_VA_COPY (args_copy, args);
365 arg0 = (gchar) va_arg (args_copy, gint);
366 va_end (args_copy);
367
368 if (G_CCLOSURE_SWAP_DATA (closure))
369 {
370 data1 = closure->data;
371 data2 = instance;
372 }
373 else
374 {
375 data1 = instance;
376 data2 = closure->data;
377 }
378 callback = (GMarshalFunc_VOID__CHAR) (marshal_data ? marshal_data : cc->callback);
379
380 callback (data1,
381 arg0,
382 data2);
383 }
384
385 /**
386 * g_cclosure_marshal_VOID__UCHAR:
387 * @closure: A #GClosure.
388 * @return_value: A #GValue to store the return value. May be %NULL
389 * if the callback of closure doesn't return a value.
390 * @n_param_values: The length of the @param_values array.
391 * @param_values: An array of #GValues holding the arguments
392 * on which to invoke the callback of closure.
393 * @invocation_hint: The invocation hint given as the last argument to
394 * g_closure_invoke().
395 * @marshal_data: Additional data specified when registering the
396 * marshaller, see g_closure_set_marshal() and
397 * g_closure_set_meta_marshal()
398 *
399 * A #GClosureMarshal function for use with signals with a single
400 * unsigned character argument.
401 */
402 /* VOID:UCHAR */
403 void
g_cclosure_marshal_VOID__UCHAR(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)404 g_cclosure_marshal_VOID__UCHAR (GClosure *closure,
405 GValue *return_value G_GNUC_UNUSED,
406 guint n_param_values,
407 const GValue *param_values,
408 gpointer invocation_hint G_GNUC_UNUSED,
409 gpointer marshal_data)
410 {
411 typedef void (*GMarshalFunc_VOID__UCHAR) (gpointer data1,
412 guchar arg_1,
413 gpointer data2);
414 GMarshalFunc_VOID__UCHAR callback;
415 GCClosure *cc = (GCClosure*) closure;
416 gpointer data1, data2;
417
418 g_return_if_fail (n_param_values == 2);
419
420 if (G_CCLOSURE_SWAP_DATA (closure))
421 {
422 data1 = closure->data;
423 data2 = g_value_peek_pointer (param_values + 0);
424 }
425 else
426 {
427 data1 = g_value_peek_pointer (param_values + 0);
428 data2 = closure->data;
429 }
430 callback = (GMarshalFunc_VOID__UCHAR) (marshal_data ? marshal_data : cc->callback);
431
432 callback (data1,
433 g_marshal_value_peek_uchar (param_values + 1),
434 data2);
435 }
436
437 /**
438 * g_cclosure_marshal_VOID__UCHARv:
439 * @closure: the #GClosure to which the marshaller belongs
440 * @return_value: (nullable): a #GValue to store the return
441 * value. May be %NULL if the callback of @closure doesn't return a
442 * value.
443 * @instance: (type GObject.TypeInstance): the instance on which the closure is invoked.
444 * @args: va_list of arguments to be passed to the closure.
445 * @marshal_data: (nullable): additional data specified when
446 * registering the marshaller, see g_closure_set_marshal() and
447 * g_closure_set_meta_marshal()
448 * @n_params: the length of the @param_types array
449 * @param_types: (array length=n_params): the #GType of each argument from
450 * @args.
451 *
452 * The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__UCHAR().
453 */
454 void
g_cclosure_marshal_VOID__UCHARv(GClosure * closure,GValue * return_value,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)455 g_cclosure_marshal_VOID__UCHARv (GClosure *closure,
456 GValue *return_value,
457 gpointer instance,
458 va_list args,
459 gpointer marshal_data,
460 int n_params,
461 GType *param_types)
462 {
463 typedef void (*GMarshalFunc_VOID__UCHAR) (gpointer instance,
464 guchar arg_0,
465 gpointer data);
466 GCClosure *cc = (GCClosure*) closure;
467 gpointer data1, data2;
468 GMarshalFunc_VOID__UCHAR callback;
469 guchar arg0;
470 va_list args_copy;
471
472 G_VA_COPY (args_copy, args);
473 arg0 = (guchar) va_arg (args_copy, guint);
474 va_end (args_copy);
475
476 if (G_CCLOSURE_SWAP_DATA (closure))
477 {
478 data1 = closure->data;
479 data2 = instance;
480 }
481 else
482 {
483 data1 = instance;
484 data2 = closure->data;
485 }
486 callback = (GMarshalFunc_VOID__UCHAR) (marshal_data ? marshal_data : cc->callback);
487
488 callback (data1,
489 arg0,
490 data2);
491 }
492
493 /**
494 * g_cclosure_marshal_VOID__INT:
495 * @closure: A #GClosure.
496 * @return_value: A #GValue to store the return value. May be %NULL
497 * if the callback of closure doesn't return a value.
498 * @n_param_values: The length of the @param_values array.
499 * @param_values: An array of #GValues holding the arguments
500 * on which to invoke the callback of closure.
501 * @invocation_hint: The invocation hint given as the last argument to
502 * g_closure_invoke().
503 * @marshal_data: Additional data specified when registering the
504 * marshaller, see g_closure_set_marshal() and
505 * g_closure_set_meta_marshal()
506 *
507 * A #GClosureMarshal function for use with signals with a single
508 * integer argument.
509 */
510 /* VOID:INT */
511 void
g_cclosure_marshal_VOID__INT(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)512 g_cclosure_marshal_VOID__INT (GClosure *closure,
513 GValue *return_value G_GNUC_UNUSED,
514 guint n_param_values,
515 const GValue *param_values,
516 gpointer invocation_hint G_GNUC_UNUSED,
517 gpointer marshal_data)
518 {
519 typedef void (*GMarshalFunc_VOID__INT) (gpointer data1,
520 gint arg_1,
521 gpointer data2);
522 GMarshalFunc_VOID__INT callback;
523 GCClosure *cc = (GCClosure*) closure;
524 gpointer data1, data2;
525
526 g_return_if_fail (n_param_values == 2);
527
528 if (G_CCLOSURE_SWAP_DATA (closure))
529 {
530 data1 = closure->data;
531 data2 = g_value_peek_pointer (param_values + 0);
532 }
533 else
534 {
535 data1 = g_value_peek_pointer (param_values + 0);
536 data2 = closure->data;
537 }
538 callback = (GMarshalFunc_VOID__INT) (marshal_data ? marshal_data : cc->callback);
539
540 callback (data1,
541 g_marshal_value_peek_int (param_values + 1),
542 data2);
543 }
544
545 /**
546 * g_cclosure_marshal_VOID__INTv:
547 * @closure: the #GClosure to which the marshaller belongs
548 * @return_value: (nullable): a #GValue to store the return
549 * value. May be %NULL if the callback of @closure doesn't return a
550 * value.
551 * @instance: (type GObject.TypeInstance): the instance on which the closure is invoked.
552 * @args: va_list of arguments to be passed to the closure.
553 * @marshal_data: (nullable): additional data specified when
554 * registering the marshaller, see g_closure_set_marshal() and
555 * g_closure_set_meta_marshal()
556 * @n_params: the length of the @param_types array
557 * @param_types: (array length=n_params): the #GType of each argument from
558 * @args.
559 *
560 * The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__INT().
561 */
562 void
g_cclosure_marshal_VOID__INTv(GClosure * closure,GValue * return_value,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)563 g_cclosure_marshal_VOID__INTv (GClosure *closure,
564 GValue *return_value,
565 gpointer instance,
566 va_list args,
567 gpointer marshal_data,
568 int n_params,
569 GType *param_types)
570 {
571 typedef void (*GMarshalFunc_VOID__INT) (gpointer instance,
572 gint arg_0,
573 gpointer data);
574 GCClosure *cc = (GCClosure*) closure;
575 gpointer data1, data2;
576 GMarshalFunc_VOID__INT callback;
577 gint arg0;
578 va_list args_copy;
579
580 G_VA_COPY (args_copy, args);
581 arg0 = (gint) va_arg (args_copy, gint);
582 va_end (args_copy);
583
584 if (G_CCLOSURE_SWAP_DATA (closure))
585 {
586 data1 = closure->data;
587 data2 = instance;
588 }
589 else
590 {
591 data1 = instance;
592 data2 = closure->data;
593 }
594 callback = (GMarshalFunc_VOID__INT) (marshal_data ? marshal_data : cc->callback);
595
596 callback (data1,
597 arg0,
598 data2);
599 }
600
601 /**
602 * g_cclosure_marshal_VOID__UINT:
603 * @closure: A #GClosure.
604 * @return_value: A #GValue to store the return value. May be %NULL
605 * if the callback of closure doesn't return a value.
606 * @n_param_values: The length of the @param_values array.
607 * @param_values: An array of #GValues holding the arguments
608 * on which to invoke the callback of closure.
609 * @invocation_hint: The invocation hint given as the last argument to
610 * g_closure_invoke().
611 * @marshal_data: Additional data specified when registering the
612 * marshaller, see g_closure_set_marshal() and
613 * g_closure_set_meta_marshal()
614 *
615 * A #GClosureMarshal function for use with signals with with a single
616 * unsigned integer argument.
617 */
618 /* VOID:UINT */
619 void
g_cclosure_marshal_VOID__UINT(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)620 g_cclosure_marshal_VOID__UINT (GClosure *closure,
621 GValue *return_value G_GNUC_UNUSED,
622 guint n_param_values,
623 const GValue *param_values,
624 gpointer invocation_hint G_GNUC_UNUSED,
625 gpointer marshal_data)
626 {
627 typedef void (*GMarshalFunc_VOID__UINT) (gpointer data1,
628 guint arg_1,
629 gpointer data2);
630 GMarshalFunc_VOID__UINT callback;
631 GCClosure *cc = (GCClosure*) closure;
632 gpointer data1, data2;
633
634 g_return_if_fail (n_param_values == 2);
635
636 if (G_CCLOSURE_SWAP_DATA (closure))
637 {
638 data1 = closure->data;
639 data2 = g_value_peek_pointer (param_values + 0);
640 }
641 else
642 {
643 data1 = g_value_peek_pointer (param_values + 0);
644 data2 = closure->data;
645 }
646 callback = (GMarshalFunc_VOID__UINT) (marshal_data ? marshal_data : cc->callback);
647
648 callback (data1,
649 g_marshal_value_peek_uint (param_values + 1),
650 data2);
651 }
652
653 /**
654 * g_cclosure_marshal_VOID__UINTv:
655 * @closure: the #GClosure to which the marshaller belongs
656 * @return_value: (nullable): a #GValue to store the return
657 * value. May be %NULL if the callback of @closure doesn't return a
658 * value.
659 * @instance: (type GObject.TypeInstance): the instance on which the closure is invoked.
660 * @args: va_list of arguments to be passed to the closure.
661 * @marshal_data: (nullable): additional data specified when
662 * registering the marshaller, see g_closure_set_marshal() and
663 * g_closure_set_meta_marshal()
664 * @n_params: the length of the @param_types array
665 * @param_types: (array length=n_params): the #GType of each argument from
666 * @args.
667 *
668 * The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__UINT().
669 */
670 void
g_cclosure_marshal_VOID__UINTv(GClosure * closure,GValue * return_value,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)671 g_cclosure_marshal_VOID__UINTv (GClosure *closure,
672 GValue *return_value,
673 gpointer instance,
674 va_list args,
675 gpointer marshal_data,
676 int n_params,
677 GType *param_types)
678 {
679 typedef void (*GMarshalFunc_VOID__UINT) (gpointer instance,
680 guint arg_0,
681 gpointer data);
682 GCClosure *cc = (GCClosure*) closure;
683 gpointer data1, data2;
684 GMarshalFunc_VOID__UINT callback;
685 guint arg0;
686 va_list args_copy;
687
688 G_VA_COPY (args_copy, args);
689 arg0 = (guint) va_arg (args_copy, guint);
690 va_end (args_copy);
691
692 if (G_CCLOSURE_SWAP_DATA (closure))
693 {
694 data1 = closure->data;
695 data2 = instance;
696 }
697 else
698 {
699 data1 = instance;
700 data2 = closure->data;
701 }
702 callback = (GMarshalFunc_VOID__UINT) (marshal_data ? marshal_data : cc->callback);
703
704 callback (data1,
705 arg0,
706 data2);
707 }
708
709 /**
710 * g_cclosure_marshal_VOID__LONG:
711 * @closure: A #GClosure.
712 * @return_value: A #GValue to store the return value. May be %NULL
713 * if the callback of closure doesn't return a value.
714 * @n_param_values: The length of the @param_values array.
715 * @param_values: An array of #GValues holding the arguments
716 * on which to invoke the callback of closure.
717 * @invocation_hint: The invocation hint given as the last argument to
718 * g_closure_invoke().
719 * @marshal_data: Additional data specified when registering the
720 * marshaller, see g_closure_set_marshal() and
721 * g_closure_set_meta_marshal()
722 *
723 * A #GClosureMarshal function for use with signals with with a single
724 * long integer argument.
725 */
726 /* VOID:LONG */
727 void
g_cclosure_marshal_VOID__LONG(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)728 g_cclosure_marshal_VOID__LONG (GClosure *closure,
729 GValue *return_value G_GNUC_UNUSED,
730 guint n_param_values,
731 const GValue *param_values,
732 gpointer invocation_hint G_GNUC_UNUSED,
733 gpointer marshal_data)
734 {
735 typedef void (*GMarshalFunc_VOID__LONG) (gpointer data1,
736 glong arg_1,
737 gpointer data2);
738 GMarshalFunc_VOID__LONG callback;
739 GCClosure *cc = (GCClosure*) closure;
740 gpointer data1, data2;
741
742 g_return_if_fail (n_param_values == 2);
743
744 if (G_CCLOSURE_SWAP_DATA (closure))
745 {
746 data1 = closure->data;
747 data2 = g_value_peek_pointer (param_values + 0);
748 }
749 else
750 {
751 data1 = g_value_peek_pointer (param_values + 0);
752 data2 = closure->data;
753 }
754 callback = (GMarshalFunc_VOID__LONG) (marshal_data ? marshal_data : cc->callback);
755
756 callback (data1,
757 g_marshal_value_peek_long (param_values + 1),
758 data2);
759 }
760
761 /**
762 * g_cclosure_marshal_VOID__LONGv:
763 * @closure: the #GClosure to which the marshaller belongs
764 * @return_value: (nullable): a #GValue to store the return
765 * value. May be %NULL if the callback of @closure doesn't return a
766 * value.
767 * @instance: (type GObject.TypeInstance): the instance on which the closure is invoked.
768 * @args: va_list of arguments to be passed to the closure.
769 * @marshal_data: (nullable): additional data specified when
770 * registering the marshaller, see g_closure_set_marshal() and
771 * g_closure_set_meta_marshal()
772 * @n_params: the length of the @param_types array
773 * @param_types: (array length=n_params): the #GType of each argument from
774 * @args.
775 *
776 * The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__LONG().
777 */
778 void
g_cclosure_marshal_VOID__LONGv(GClosure * closure,GValue * return_value,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)779 g_cclosure_marshal_VOID__LONGv (GClosure *closure,
780 GValue *return_value,
781 gpointer instance,
782 va_list args,
783 gpointer marshal_data,
784 int n_params,
785 GType *param_types)
786 {
787 typedef void (*GMarshalFunc_VOID__LONG) (gpointer instance,
788 glong arg_0,
789 gpointer data);
790 GCClosure *cc = (GCClosure*) closure;
791 gpointer data1, data2;
792 GMarshalFunc_VOID__LONG callback;
793 glong arg0;
794 va_list args_copy;
795
796 G_VA_COPY (args_copy, args);
797 arg0 = (glong) va_arg (args_copy, glong);
798 va_end (args_copy);
799
800 if (G_CCLOSURE_SWAP_DATA (closure))
801 {
802 data1 = closure->data;
803 data2 = instance;
804 }
805 else
806 {
807 data1 = instance;
808 data2 = closure->data;
809 }
810 callback = (GMarshalFunc_VOID__LONG) (marshal_data ? marshal_data : cc->callback);
811
812 callback (data1,
813 arg0,
814 data2);
815 }
816
817 /**
818 * g_cclosure_marshal_VOID__ULONG:
819 * @closure: A #GClosure.
820 * @return_value: A #GValue to store the return value. May be %NULL
821 * if the callback of closure doesn't return a value.
822 * @n_param_values: The length of the @param_values array.
823 * @param_values: An array of #GValues holding the arguments
824 * on which to invoke the callback of closure.
825 * @invocation_hint: The invocation hint given as the last argument to
826 * g_closure_invoke().
827 * @marshal_data: Additional data specified when registering the
828 * marshaller, see g_closure_set_marshal() and
829 * g_closure_set_meta_marshal()
830 *
831 * A #GClosureMarshal function for use with signals with a single
832 * unsigned long integer argument.
833 */
834 /* VOID:ULONG */
835 void
g_cclosure_marshal_VOID__ULONG(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)836 g_cclosure_marshal_VOID__ULONG (GClosure *closure,
837 GValue *return_value G_GNUC_UNUSED,
838 guint n_param_values,
839 const GValue *param_values,
840 gpointer invocation_hint G_GNUC_UNUSED,
841 gpointer marshal_data)
842 {
843 typedef void (*GMarshalFunc_VOID__ULONG) (gpointer data1,
844 gulong arg_1,
845 gpointer data2);
846 GMarshalFunc_VOID__ULONG callback;
847 GCClosure *cc = (GCClosure*) closure;
848 gpointer data1, data2;
849
850 g_return_if_fail (n_param_values == 2);
851
852 if (G_CCLOSURE_SWAP_DATA (closure))
853 {
854 data1 = closure->data;
855 data2 = g_value_peek_pointer (param_values + 0);
856 }
857 else
858 {
859 data1 = g_value_peek_pointer (param_values + 0);
860 data2 = closure->data;
861 }
862 callback = (GMarshalFunc_VOID__ULONG) (marshal_data ? marshal_data : cc->callback);
863
864 callback (data1,
865 g_marshal_value_peek_ulong (param_values + 1),
866 data2);
867 }
868
869 /**
870 * g_cclosure_marshal_VOID__ULONGv:
871 * @closure: the #GClosure to which the marshaller belongs
872 * @return_value: (nullable): a #GValue to store the return
873 * value. May be %NULL if the callback of @closure doesn't return a
874 * value.
875 * @instance: (type GObject.TypeInstance): the instance on which the closure is invoked.
876 * @args: va_list of arguments to be passed to the closure.
877 * @marshal_data: (nullable): additional data specified when
878 * registering the marshaller, see g_closure_set_marshal() and
879 * g_closure_set_meta_marshal()
880 * @n_params: the length of the @param_types array
881 * @param_types: (array length=n_params): the #GType of each argument from
882 * @args.
883 *
884 * The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__ULONG().
885 */
886 void
g_cclosure_marshal_VOID__ULONGv(GClosure * closure,GValue * return_value,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)887 g_cclosure_marshal_VOID__ULONGv (GClosure *closure,
888 GValue *return_value,
889 gpointer instance,
890 va_list args,
891 gpointer marshal_data,
892 int n_params,
893 GType *param_types)
894 {
895 typedef void (*GMarshalFunc_VOID__ULONG) (gpointer instance,
896 gulong arg_0,
897 gpointer data);
898 GCClosure *cc = (GCClosure*) closure;
899 gpointer data1, data2;
900 GMarshalFunc_VOID__ULONG callback;
901 gulong arg0;
902 va_list args_copy;
903
904 G_VA_COPY (args_copy, args);
905 arg0 = (gulong) va_arg (args_copy, gulong);
906 va_end (args_copy);
907
908 if (G_CCLOSURE_SWAP_DATA (closure))
909 {
910 data1 = closure->data;
911 data2 = instance;
912 }
913 else
914 {
915 data1 = instance;
916 data2 = closure->data;
917 }
918 callback = (GMarshalFunc_VOID__ULONG) (marshal_data ? marshal_data : cc->callback);
919
920 callback (data1,
921 arg0,
922 data2);
923 }
924
925 /**
926 * g_cclosure_marshal_VOID__ENUM:
927 * @closure: A #GClosure.
928 * @return_value: A #GValue to store the return value. May be %NULL
929 * if the callback of closure doesn't return a value.
930 * @n_param_values: The length of the @param_values array.
931 * @param_values: An array of #GValues holding the arguments
932 * on which to invoke the callback of closure.
933 * @invocation_hint: The invocation hint given as the last argument to
934 * g_closure_invoke().
935 * @marshal_data: Additional data specified when registering the
936 * marshaller, see g_closure_set_marshal() and
937 * g_closure_set_meta_marshal()
938 *
939 * A #GClosureMarshal function for use with signals with a single
940 * argument with an enumerated type.
941 */
942 /* VOID:ENUM */
943 void
g_cclosure_marshal_VOID__ENUM(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)944 g_cclosure_marshal_VOID__ENUM (GClosure *closure,
945 GValue *return_value G_GNUC_UNUSED,
946 guint n_param_values,
947 const GValue *param_values,
948 gpointer invocation_hint G_GNUC_UNUSED,
949 gpointer marshal_data)
950 {
951 typedef void (*GMarshalFunc_VOID__ENUM) (gpointer data1,
952 gint arg_1,
953 gpointer data2);
954 GMarshalFunc_VOID__ENUM callback;
955 GCClosure *cc = (GCClosure*) closure;
956 gpointer data1, data2;
957
958 g_return_if_fail (n_param_values == 2);
959
960 if (G_CCLOSURE_SWAP_DATA (closure))
961 {
962 data1 = closure->data;
963 data2 = g_value_peek_pointer (param_values + 0);
964 }
965 else
966 {
967 data1 = g_value_peek_pointer (param_values + 0);
968 data2 = closure->data;
969 }
970 callback = (GMarshalFunc_VOID__ENUM) (marshal_data ? marshal_data : cc->callback);
971
972 callback (data1,
973 g_marshal_value_peek_enum (param_values + 1),
974 data2);
975 }
976
977 /**
978 * g_cclosure_marshal_VOID__ENUMv:
979 * @closure: the #GClosure to which the marshaller belongs
980 * @return_value: (nullable): a #GValue to store the return
981 * value. May be %NULL if the callback of @closure doesn't return a
982 * value.
983 * @instance: (type GObject.TypeInstance): the instance on which the closure is invoked.
984 * @args: va_list of arguments to be passed to the closure.
985 * @marshal_data: (nullable): additional data specified when
986 * registering the marshaller, see g_closure_set_marshal() and
987 * g_closure_set_meta_marshal()
988 * @n_params: the length of the @param_types array
989 * @param_types: (array length=n_params): the #GType of each argument from
990 * @args.
991 *
992 * The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__ENUM().
993 */
994 void
g_cclosure_marshal_VOID__ENUMv(GClosure * closure,GValue * return_value,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)995 g_cclosure_marshal_VOID__ENUMv (GClosure *closure,
996 GValue *return_value,
997 gpointer instance,
998 va_list args,
999 gpointer marshal_data,
1000 int n_params,
1001 GType *param_types)
1002 {
1003 typedef void (*GMarshalFunc_VOID__ENUM) (gpointer instance,
1004 gint arg_0,
1005 gpointer data);
1006 GCClosure *cc = (GCClosure*) closure;
1007 gpointer data1, data2;
1008 GMarshalFunc_VOID__ENUM callback;
1009 gint arg0;
1010 va_list args_copy;
1011
1012 G_VA_COPY (args_copy, args);
1013 arg0 = (gint) va_arg (args_copy, gint);
1014 va_end (args_copy);
1015
1016 if (G_CCLOSURE_SWAP_DATA (closure))
1017 {
1018 data1 = closure->data;
1019 data2 = instance;
1020 }
1021 else
1022 {
1023 data1 = instance;
1024 data2 = closure->data;
1025 }
1026 callback = (GMarshalFunc_VOID__ENUM) (marshal_data ? marshal_data : cc->callback);
1027
1028 callback (data1,
1029 arg0,
1030 data2);
1031 }
1032
1033 /**
1034 * g_cclosure_marshal_VOID__FLAGS:
1035 * @closure: A #GClosure.
1036 * @return_value: A #GValue to store the return value. May be %NULL
1037 * if the callback of closure doesn't return a value.
1038 * @n_param_values: The length of the @param_values array.
1039 * @param_values: An array of #GValues holding the arguments
1040 * on which to invoke the callback of closure.
1041 * @invocation_hint: The invocation hint given as the last argument to
1042 * g_closure_invoke().
1043 * @marshal_data: Additional data specified when registering the
1044 * marshaller, see g_closure_set_marshal() and
1045 * g_closure_set_meta_marshal()
1046 *
1047 * A #GClosureMarshal function for use with signals with a single
1048 * argument with a flags types.
1049 */
1050 /* VOID:FLAGS */
1051 void
g_cclosure_marshal_VOID__FLAGS(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)1052 g_cclosure_marshal_VOID__FLAGS (GClosure *closure,
1053 GValue *return_value G_GNUC_UNUSED,
1054 guint n_param_values,
1055 const GValue *param_values,
1056 gpointer invocation_hint G_GNUC_UNUSED,
1057 gpointer marshal_data)
1058 {
1059 typedef void (*GMarshalFunc_VOID__FLAGS) (gpointer data1,
1060 guint arg_1,
1061 gpointer data2);
1062 GMarshalFunc_VOID__FLAGS callback;
1063 GCClosure *cc = (GCClosure*) closure;
1064 gpointer data1, data2;
1065
1066 g_return_if_fail (n_param_values == 2);
1067
1068 if (G_CCLOSURE_SWAP_DATA (closure))
1069 {
1070 data1 = closure->data;
1071 data2 = g_value_peek_pointer (param_values + 0);
1072 }
1073 else
1074 {
1075 data1 = g_value_peek_pointer (param_values + 0);
1076 data2 = closure->data;
1077 }
1078 callback = (GMarshalFunc_VOID__FLAGS) (marshal_data ? marshal_data : cc->callback);
1079
1080 callback (data1,
1081 g_marshal_value_peek_flags (param_values + 1),
1082 data2);
1083 }
1084
1085 /**
1086 * g_cclosure_marshal_VOID__FLAGSv:
1087 * @closure: the #GClosure to which the marshaller belongs
1088 * @return_value: (nullable): a #GValue to store the return
1089 * value. May be %NULL if the callback of @closure doesn't return a
1090 * value.
1091 * @instance: (type GObject.TypeInstance): the instance on which the closure is invoked.
1092 * @args: va_list of arguments to be passed to the closure.
1093 * @marshal_data: (nullable): additional data specified when
1094 * registering the marshaller, see g_closure_set_marshal() and
1095 * g_closure_set_meta_marshal()
1096 * @n_params: the length of the @param_types array
1097 * @param_types: (array length=n_params): the #GType of each argument from
1098 * @args.
1099 *
1100 * The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__FLAGS().
1101 */
1102 void
g_cclosure_marshal_VOID__FLAGSv(GClosure * closure,GValue * return_value,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)1103 g_cclosure_marshal_VOID__FLAGSv (GClosure *closure,
1104 GValue *return_value,
1105 gpointer instance,
1106 va_list args,
1107 gpointer marshal_data,
1108 int n_params,
1109 GType *param_types)
1110 {
1111 typedef void (*GMarshalFunc_VOID__FLAGS) (gpointer instance,
1112 guint arg_0,
1113 gpointer data);
1114 GCClosure *cc = (GCClosure*) closure;
1115 gpointer data1, data2;
1116 GMarshalFunc_VOID__FLAGS callback;
1117 guint arg0;
1118 va_list args_copy;
1119
1120 G_VA_COPY (args_copy, args);
1121 arg0 = (guint) va_arg (args_copy, guint);
1122 va_end (args_copy);
1123
1124 if (G_CCLOSURE_SWAP_DATA (closure))
1125 {
1126 data1 = closure->data;
1127 data2 = instance;
1128 }
1129 else
1130 {
1131 data1 = instance;
1132 data2 = closure->data;
1133 }
1134 callback = (GMarshalFunc_VOID__FLAGS) (marshal_data ? marshal_data : cc->callback);
1135
1136 callback (data1,
1137 arg0,
1138 data2);
1139 }
1140
1141 /**
1142 * g_cclosure_marshal_VOID__FLOAT:
1143 * @closure: A #GClosure.
1144 * @return_value: A #GValue to store the return value. May be %NULL
1145 * if the callback of closure doesn't return a value.
1146 * @n_param_values: The length of the @param_values array.
1147 * @param_values: An array of #GValues holding the arguments
1148 * on which to invoke the callback of closure.
1149 * @invocation_hint: The invocation hint given as the last argument to
1150 * g_closure_invoke().
1151 * @marshal_data: Additional data specified when registering the
1152 * marshaller, see g_closure_set_marshal() and
1153 * g_closure_set_meta_marshal()
1154 *
1155 * A #GClosureMarshal function for use with signals with one
1156 * single-precision floating point argument.
1157 */
1158 /* VOID:FLOAT */
1159 void
g_cclosure_marshal_VOID__FLOAT(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)1160 g_cclosure_marshal_VOID__FLOAT (GClosure *closure,
1161 GValue *return_value G_GNUC_UNUSED,
1162 guint n_param_values,
1163 const GValue *param_values,
1164 gpointer invocation_hint G_GNUC_UNUSED,
1165 gpointer marshal_data)
1166 {
1167 typedef void (*GMarshalFunc_VOID__FLOAT) (gpointer data1,
1168 gfloat arg_1,
1169 gpointer data2);
1170 GMarshalFunc_VOID__FLOAT callback;
1171 GCClosure *cc = (GCClosure*) closure;
1172 gpointer data1, data2;
1173
1174 g_return_if_fail (n_param_values == 2);
1175
1176 if (G_CCLOSURE_SWAP_DATA (closure))
1177 {
1178 data1 = closure->data;
1179 data2 = g_value_peek_pointer (param_values + 0);
1180 }
1181 else
1182 {
1183 data1 = g_value_peek_pointer (param_values + 0);
1184 data2 = closure->data;
1185 }
1186 callback = (GMarshalFunc_VOID__FLOAT) (marshal_data ? marshal_data : cc->callback);
1187
1188 callback (data1,
1189 g_marshal_value_peek_float (param_values + 1),
1190 data2);
1191 }
1192
1193 /**
1194 * g_cclosure_marshal_VOID__FLOATv:
1195 * @closure: the #GClosure to which the marshaller belongs
1196 * @return_value: (nullable): a #GValue to store the return
1197 * value. May be %NULL if the callback of @closure doesn't return a
1198 * value.
1199 * @instance: (type GObject.TypeInstance): the instance on which the closure is invoked.
1200 * @args: va_list of arguments to be passed to the closure.
1201 * @marshal_data: (nullable): additional data specified when
1202 * registering the marshaller, see g_closure_set_marshal() and
1203 * g_closure_set_meta_marshal()
1204 * @n_params: the length of the @param_types array
1205 * @param_types: (array length=n_params): the #GType of each argument from
1206 * @args.
1207 *
1208 * The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__FLOAT().
1209 */
1210 void
g_cclosure_marshal_VOID__FLOATv(GClosure * closure,GValue * return_value,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)1211 g_cclosure_marshal_VOID__FLOATv (GClosure *closure,
1212 GValue *return_value,
1213 gpointer instance,
1214 va_list args,
1215 gpointer marshal_data,
1216 int n_params,
1217 GType *param_types)
1218 {
1219 typedef void (*GMarshalFunc_VOID__FLOAT) (gpointer instance,
1220 gfloat arg_0,
1221 gpointer data);
1222 GCClosure *cc = (GCClosure*) closure;
1223 gpointer data1, data2;
1224 GMarshalFunc_VOID__FLOAT callback;
1225 gfloat arg0;
1226 va_list args_copy;
1227
1228 G_VA_COPY (args_copy, args);
1229 arg0 = (gfloat) va_arg (args_copy, gdouble);
1230 va_end (args_copy);
1231
1232 if (G_CCLOSURE_SWAP_DATA (closure))
1233 {
1234 data1 = closure->data;
1235 data2 = instance;
1236 }
1237 else
1238 {
1239 data1 = instance;
1240 data2 = closure->data;
1241 }
1242 callback = (GMarshalFunc_VOID__FLOAT) (marshal_data ? marshal_data : cc->callback);
1243
1244 callback (data1,
1245 arg0,
1246 data2);
1247 }
1248
1249 /**
1250 * g_cclosure_marshal_VOID__DOUBLE:
1251 * @closure: A #GClosure.
1252 * @return_value: A #GValue to store the return value. May be %NULL
1253 * if the callback of closure doesn't return a value.
1254 * @n_param_values: The length of the @param_values array.
1255 * @param_values: An array of #GValues holding the arguments
1256 * on which to invoke the callback of closure.
1257 * @invocation_hint: The invocation hint given as the last argument to
1258 * g_closure_invoke().
1259 * @marshal_data: Additional data specified when registering the
1260 * marshaller, see g_closure_set_marshal() and
1261 * g_closure_set_meta_marshal()
1262 *
1263 * A #GClosureMarshal function for use with signals with one
1264 * double-precision floating point argument.
1265 */
1266 /* VOID:DOUBLE */
1267 void
g_cclosure_marshal_VOID__DOUBLE(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)1268 g_cclosure_marshal_VOID__DOUBLE (GClosure *closure,
1269 GValue *return_value G_GNUC_UNUSED,
1270 guint n_param_values,
1271 const GValue *param_values,
1272 gpointer invocation_hint G_GNUC_UNUSED,
1273 gpointer marshal_data)
1274 {
1275 typedef void (*GMarshalFunc_VOID__DOUBLE) (gpointer data1,
1276 gdouble arg_1,
1277 gpointer data2);
1278 GMarshalFunc_VOID__DOUBLE callback;
1279 GCClosure *cc = (GCClosure*) closure;
1280 gpointer data1, data2;
1281
1282 g_return_if_fail (n_param_values == 2);
1283
1284 if (G_CCLOSURE_SWAP_DATA (closure))
1285 {
1286 data1 = closure->data;
1287 data2 = g_value_peek_pointer (param_values + 0);
1288 }
1289 else
1290 {
1291 data1 = g_value_peek_pointer (param_values + 0);
1292 data2 = closure->data;
1293 }
1294 callback = (GMarshalFunc_VOID__DOUBLE) (marshal_data ? marshal_data : cc->callback);
1295
1296 callback (data1,
1297 g_marshal_value_peek_double (param_values + 1),
1298 data2);
1299 }
1300
1301 /**
1302 * g_cclosure_marshal_VOID__DOUBLEv:
1303 * @closure: the #GClosure to which the marshaller belongs
1304 * @return_value: (nullable): a #GValue to store the return
1305 * value. May be %NULL if the callback of @closure doesn't return a
1306 * value.
1307 * @instance: (type GObject.TypeInstance): the instance on which the closure is invoked.
1308 * @args: va_list of arguments to be passed to the closure.
1309 * @marshal_data: (nullable): additional data specified when
1310 * registering the marshaller, see g_closure_set_marshal() and
1311 * g_closure_set_meta_marshal()
1312 * @n_params: the length of the @param_types array
1313 * @param_types: (array length=n_params): the #GType of each argument from
1314 * @args.
1315 *
1316 * The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__DOUBLE().
1317 */
1318 void
g_cclosure_marshal_VOID__DOUBLEv(GClosure * closure,GValue * return_value,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)1319 g_cclosure_marshal_VOID__DOUBLEv (GClosure *closure,
1320 GValue *return_value,
1321 gpointer instance,
1322 va_list args,
1323 gpointer marshal_data,
1324 int n_params,
1325 GType *param_types)
1326 {
1327 typedef void (*GMarshalFunc_VOID__DOUBLE) (gpointer instance,
1328 gdouble arg_0,
1329 gpointer data);
1330 GCClosure *cc = (GCClosure*) closure;
1331 gpointer data1, data2;
1332 GMarshalFunc_VOID__DOUBLE callback;
1333 gdouble arg0;
1334 va_list args_copy;
1335
1336 G_VA_COPY (args_copy, args);
1337 arg0 = (gdouble) va_arg (args_copy, gdouble);
1338 va_end (args_copy);
1339
1340 if (G_CCLOSURE_SWAP_DATA (closure))
1341 {
1342 data1 = closure->data;
1343 data2 = instance;
1344 }
1345 else
1346 {
1347 data1 = instance;
1348 data2 = closure->data;
1349 }
1350 callback = (GMarshalFunc_VOID__DOUBLE) (marshal_data ? marshal_data : cc->callback);
1351
1352 callback (data1,
1353 arg0,
1354 data2);
1355 }
1356
1357 /**
1358 * g_cclosure_marshal_VOID__STRING:
1359 * @closure: A #GClosure.
1360 * @return_value: A #GValue to store the return value. May be %NULL
1361 * if the callback of closure doesn't return a value.
1362 * @n_param_values: The length of the @param_values array.
1363 * @param_values: An array of #GValues holding the arguments
1364 * on which to invoke the callback of closure.
1365 * @invocation_hint: The invocation hint given as the last argument to
1366 * g_closure_invoke().
1367 * @marshal_data: Additional data specified when registering the
1368 * marshaller, see g_closure_set_marshal() and
1369 * g_closure_set_meta_marshal()
1370 *
1371 * A #GClosureMarshal function for use with signals with a single string
1372 * argument.
1373 */
1374 /* VOID:STRING */
1375 void
g_cclosure_marshal_VOID__STRING(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)1376 g_cclosure_marshal_VOID__STRING (GClosure *closure,
1377 GValue *return_value G_GNUC_UNUSED,
1378 guint n_param_values,
1379 const GValue *param_values,
1380 gpointer invocation_hint G_GNUC_UNUSED,
1381 gpointer marshal_data)
1382 {
1383 typedef void (*GMarshalFunc_VOID__STRING) (gpointer data1,
1384 gpointer arg_1,
1385 gpointer data2);
1386 GMarshalFunc_VOID__STRING callback;
1387 GCClosure *cc = (GCClosure*) closure;
1388 gpointer data1, data2;
1389
1390 g_return_if_fail (n_param_values == 2);
1391
1392 if (G_CCLOSURE_SWAP_DATA (closure))
1393 {
1394 data1 = closure->data;
1395 data2 = g_value_peek_pointer (param_values + 0);
1396 }
1397 else
1398 {
1399 data1 = g_value_peek_pointer (param_values + 0);
1400 data2 = closure->data;
1401 }
1402 callback = (GMarshalFunc_VOID__STRING) (marshal_data ? marshal_data : cc->callback);
1403
1404 callback (data1,
1405 g_marshal_value_peek_string (param_values + 1),
1406 data2);
1407 }
1408
1409 /**
1410 * g_cclosure_marshal_VOID__STRINGv:
1411 * @closure: the #GClosure to which the marshaller belongs
1412 * @return_value: (nullable): a #GValue to store the return
1413 * value. May be %NULL if the callback of @closure doesn't return a
1414 * value.
1415 * @instance: (type GObject.TypeInstance): the instance on which the closure is invoked.
1416 * @args: va_list of arguments to be passed to the closure.
1417 * @marshal_data: (nullable): additional data specified when
1418 * registering the marshaller, see g_closure_set_marshal() and
1419 * g_closure_set_meta_marshal()
1420 * @n_params: the length of the @param_types array
1421 * @param_types: (array length=n_params): the #GType of each argument from
1422 * @args.
1423 *
1424 * The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__STRING().
1425 */
1426 void
g_cclosure_marshal_VOID__STRINGv(GClosure * closure,GValue * return_value,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)1427 g_cclosure_marshal_VOID__STRINGv (GClosure *closure,
1428 GValue *return_value,
1429 gpointer instance,
1430 va_list args,
1431 gpointer marshal_data,
1432 int n_params,
1433 GType *param_types)
1434 {
1435 typedef void (*GMarshalFunc_VOID__STRING) (gpointer instance,
1436 gpointer arg_0,
1437 gpointer data);
1438 GCClosure *cc = (GCClosure*) closure;
1439 gpointer data1, data2;
1440 GMarshalFunc_VOID__STRING callback;
1441 gpointer arg0;
1442 va_list args_copy;
1443
1444 G_VA_COPY (args_copy, args);
1445 arg0 = (gpointer) va_arg (args_copy, gpointer);
1446 if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
1447 arg0 = g_strdup (arg0);
1448 va_end (args_copy);
1449
1450 if (G_CCLOSURE_SWAP_DATA (closure))
1451 {
1452 data1 = closure->data;
1453 data2 = instance;
1454 }
1455 else
1456 {
1457 data1 = instance;
1458 data2 = closure->data;
1459 }
1460 callback = (GMarshalFunc_VOID__STRING) (marshal_data ? marshal_data : cc->callback);
1461
1462 callback (data1,
1463 arg0,
1464 data2);
1465 if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
1466 g_free (arg0);
1467 }
1468
1469 /**
1470 * g_cclosure_marshal_VOID__PARAM:
1471 * @closure: A #GClosure.
1472 * @return_value: A #GValue to store the return value. May be %NULL
1473 * if the callback of closure doesn't return a value.
1474 * @n_param_values: The length of the @param_values array.
1475 * @param_values: An array of #GValues holding the arguments
1476 * on which to invoke the callback of closure.
1477 * @invocation_hint: The invocation hint given as the last argument to
1478 * g_closure_invoke().
1479 * @marshal_data: Additional data specified when registering the
1480 * marshaller, see g_closure_set_marshal() and
1481 * g_closure_set_meta_marshal()
1482 *
1483 * A #GClosureMarshal function for use with signals with a single
1484 * argument of type #GParamSpec.
1485 */
1486 /* VOID:PARAM */
1487 void
g_cclosure_marshal_VOID__PARAM(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)1488 g_cclosure_marshal_VOID__PARAM (GClosure *closure,
1489 GValue *return_value G_GNUC_UNUSED,
1490 guint n_param_values,
1491 const GValue *param_values,
1492 gpointer invocation_hint G_GNUC_UNUSED,
1493 gpointer marshal_data)
1494 {
1495 typedef void (*GMarshalFunc_VOID__PARAM) (gpointer data1,
1496 gpointer arg_1,
1497 gpointer data2);
1498 GMarshalFunc_VOID__PARAM callback;
1499 GCClosure *cc = (GCClosure*) closure;
1500 gpointer data1, data2;
1501
1502 g_return_if_fail (n_param_values == 2);
1503
1504 if (G_CCLOSURE_SWAP_DATA (closure))
1505 {
1506 data1 = closure->data;
1507 data2 = g_value_peek_pointer (param_values + 0);
1508 }
1509 else
1510 {
1511 data1 = g_value_peek_pointer (param_values + 0);
1512 data2 = closure->data;
1513 }
1514 callback = (GMarshalFunc_VOID__PARAM) (marshal_data ? marshal_data : cc->callback);
1515
1516 callback (data1,
1517 g_marshal_value_peek_param (param_values + 1),
1518 data2);
1519 }
1520
1521 /**
1522 * g_cclosure_marshal_VOID__PARAMv:
1523 * @closure: the #GClosure to which the marshaller belongs
1524 * @return_value: (nullable): a #GValue to store the return
1525 * value. May be %NULL if the callback of @closure doesn't return a
1526 * value.
1527 * @instance: (type GObject.TypeInstance): the instance on which the closure is invoked.
1528 * @args: va_list of arguments to be passed to the closure.
1529 * @marshal_data: (nullable): additional data specified when
1530 * registering the marshaller, see g_closure_set_marshal() and
1531 * g_closure_set_meta_marshal()
1532 * @n_params: the length of the @param_types array
1533 * @param_types: (array length=n_params): the #GType of each argument from
1534 * @args.
1535 *
1536 * The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__PARAM().
1537 */
1538 void
g_cclosure_marshal_VOID__PARAMv(GClosure * closure,GValue * return_value,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)1539 g_cclosure_marshal_VOID__PARAMv (GClosure *closure,
1540 GValue *return_value,
1541 gpointer instance,
1542 va_list args,
1543 gpointer marshal_data,
1544 int n_params,
1545 GType *param_types)
1546 {
1547 typedef void (*GMarshalFunc_VOID__PARAM) (gpointer instance,
1548 gpointer arg_0,
1549 gpointer data);
1550 GCClosure *cc = (GCClosure*) closure;
1551 gpointer data1, data2;
1552 GMarshalFunc_VOID__PARAM callback;
1553 gpointer arg0;
1554 va_list args_copy;
1555
1556 G_VA_COPY (args_copy, args);
1557 arg0 = (gpointer) va_arg (args_copy, gpointer);
1558 if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
1559 arg0 = g_param_spec_ref (arg0);
1560 va_end (args_copy);
1561
1562 if (G_CCLOSURE_SWAP_DATA (closure))
1563 {
1564 data1 = closure->data;
1565 data2 = instance;
1566 }
1567 else
1568 {
1569 data1 = instance;
1570 data2 = closure->data;
1571 }
1572 callback = (GMarshalFunc_VOID__PARAM) (marshal_data ? marshal_data : cc->callback);
1573
1574 callback (data1,
1575 arg0,
1576 data2);
1577 if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
1578 g_param_spec_unref (arg0);
1579 }
1580
1581 /**
1582 * g_cclosure_marshal_VOID__BOXED:
1583 * @closure: A #GClosure.
1584 * @return_value: A #GValue to store the return value. May be %NULL
1585 * if the callback of closure doesn't return a value.
1586 * @n_param_values: The length of the @param_values array.
1587 * @param_values: An array of #GValues holding the arguments
1588 * on which to invoke the callback of closure.
1589 * @invocation_hint: The invocation hint given as the last argument to
1590 * g_closure_invoke().
1591 * @marshal_data: Additional data specified when registering the
1592 * marshaller, see g_closure_set_marshal() and
1593 * g_closure_set_meta_marshal()
1594 *
1595 * A #GClosureMarshal function for use with signals with a single
1596 * argument which is any boxed pointer type.
1597 */
1598 /* VOID:BOXED */
1599 void
g_cclosure_marshal_VOID__BOXED(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)1600 g_cclosure_marshal_VOID__BOXED (GClosure *closure,
1601 GValue *return_value G_GNUC_UNUSED,
1602 guint n_param_values,
1603 const GValue *param_values,
1604 gpointer invocation_hint G_GNUC_UNUSED,
1605 gpointer marshal_data)
1606 {
1607 typedef void (*GMarshalFunc_VOID__BOXED) (gpointer data1,
1608 gpointer arg_1,
1609 gpointer data2);
1610 GMarshalFunc_VOID__BOXED callback;
1611 GCClosure *cc = (GCClosure*) closure;
1612 gpointer data1, data2;
1613
1614 g_return_if_fail (n_param_values == 2);
1615
1616 if (G_CCLOSURE_SWAP_DATA (closure))
1617 {
1618 data1 = closure->data;
1619 data2 = g_value_peek_pointer (param_values + 0);
1620 }
1621 else
1622 {
1623 data1 = g_value_peek_pointer (param_values + 0);
1624 data2 = closure->data;
1625 }
1626 callback = (GMarshalFunc_VOID__BOXED) (marshal_data ? marshal_data : cc->callback);
1627
1628 callback (data1,
1629 g_marshal_value_peek_boxed (param_values + 1),
1630 data2);
1631 }
1632
1633 /**
1634 * g_cclosure_marshal_VOID__BOXEDv:
1635 * @closure: the #GClosure to which the marshaller belongs
1636 * @return_value: (nullable): a #GValue to store the return
1637 * value. May be %NULL if the callback of @closure doesn't return a
1638 * value.
1639 * @instance: (type GObject.TypeInstance): the instance on which the closure is invoked.
1640 * @args: va_list of arguments to be passed to the closure.
1641 * @marshal_data: (nullable): additional data specified when
1642 * registering the marshaller, see g_closure_set_marshal() and
1643 * g_closure_set_meta_marshal()
1644 * @n_params: the length of the @param_types array
1645 * @param_types: (array length=n_params): the #GType of each argument from
1646 * @args.
1647 *
1648 * The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__BOXED().
1649 */
1650 void
g_cclosure_marshal_VOID__BOXEDv(GClosure * closure,GValue * return_value,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)1651 g_cclosure_marshal_VOID__BOXEDv (GClosure *closure,
1652 GValue *return_value,
1653 gpointer instance,
1654 va_list args,
1655 gpointer marshal_data,
1656 int n_params,
1657 GType *param_types)
1658 {
1659 typedef void (*GMarshalFunc_VOID__BOXED) (gpointer instance,
1660 gpointer arg_0,
1661 gpointer data);
1662 GCClosure *cc = (GCClosure*) closure;
1663 gpointer data1, data2;
1664 GMarshalFunc_VOID__BOXED callback;
1665 gpointer arg0;
1666 va_list args_copy;
1667
1668 G_VA_COPY (args_copy, args);
1669 arg0 = (gpointer) va_arg (args_copy, gpointer);
1670 if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
1671 arg0 = g_boxed_copy (param_types[0] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg0);
1672 va_end (args_copy);
1673
1674 if (G_CCLOSURE_SWAP_DATA (closure))
1675 {
1676 data1 = closure->data;
1677 data2 = instance;
1678 }
1679 else
1680 {
1681 data1 = instance;
1682 data2 = closure->data;
1683 }
1684 callback = (GMarshalFunc_VOID__BOXED) (marshal_data ? marshal_data : cc->callback);
1685
1686 callback (data1,
1687 arg0,
1688 data2);
1689 if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
1690 g_boxed_free (param_types[0] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg0);
1691 }
1692
1693 /**
1694 * g_cclosure_marshal_VOID__POINTER:
1695 * @closure: A #GClosure.
1696 * @return_value: A #GValue to store the return value. May be %NULL
1697 * if the callback of closure doesn't return a value.
1698 * @n_param_values: The length of the @param_values array.
1699 * @param_values: An array of #GValues holding the arguments
1700 * on which to invoke the callback of closure.
1701 * @invocation_hint: The invocation hint given as the last argument to
1702 * g_closure_invoke().
1703 * @marshal_data: Additional data specified when registering the
1704 * marshaller, see g_closure_set_marshal() and
1705 * g_closure_set_meta_marshal()
1706 *
1707 * A #GClosureMarshal function for use with signals with a single raw
1708 * pointer argument type.
1709 *
1710 * If it is possible, it is better to use one of the more specific
1711 * functions such as g_cclosure_marshal_VOID__OBJECT() or
1712 * g_cclosure_marshal_VOID__OBJECT().
1713 */
1714 /* VOID:POINTER */
1715 void
g_cclosure_marshal_VOID__POINTER(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)1716 g_cclosure_marshal_VOID__POINTER (GClosure *closure,
1717 GValue *return_value G_GNUC_UNUSED,
1718 guint n_param_values,
1719 const GValue *param_values,
1720 gpointer invocation_hint G_GNUC_UNUSED,
1721 gpointer marshal_data)
1722 {
1723 typedef void (*GMarshalFunc_VOID__POINTER) (gpointer data1,
1724 gpointer arg_1,
1725 gpointer data2);
1726 GMarshalFunc_VOID__POINTER callback;
1727 GCClosure *cc = (GCClosure*) closure;
1728 gpointer data1, data2;
1729
1730 g_return_if_fail (n_param_values == 2);
1731
1732 if (G_CCLOSURE_SWAP_DATA (closure))
1733 {
1734 data1 = closure->data;
1735 data2 = g_value_peek_pointer (param_values + 0);
1736 }
1737 else
1738 {
1739 data1 = g_value_peek_pointer (param_values + 0);
1740 data2 = closure->data;
1741 }
1742 callback = (GMarshalFunc_VOID__POINTER) (marshal_data ? marshal_data : cc->callback);
1743
1744 callback (data1,
1745 g_marshal_value_peek_pointer (param_values + 1),
1746 data2);
1747 }
1748
1749 /**
1750 * g_cclosure_marshal_VOID__POINTERv:
1751 * @closure: the #GClosure to which the marshaller belongs
1752 * @return_value: (nullable): a #GValue to store the return
1753 * value. May be %NULL if the callback of @closure doesn't return a
1754 * value.
1755 * @instance: (type GObject.TypeInstance): the instance on which the closure is invoked.
1756 * @args: va_list of arguments to be passed to the closure.
1757 * @marshal_data: (nullable): additional data specified when
1758 * registering the marshaller, see g_closure_set_marshal() and
1759 * g_closure_set_meta_marshal()
1760 * @n_params: the length of the @param_types array
1761 * @param_types: (array length=n_params): the #GType of each argument from
1762 * @args.
1763 *
1764 * The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__POINTER().
1765 */
1766 void
g_cclosure_marshal_VOID__POINTERv(GClosure * closure,GValue * return_value,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)1767 g_cclosure_marshal_VOID__POINTERv (GClosure *closure,
1768 GValue *return_value,
1769 gpointer instance,
1770 va_list args,
1771 gpointer marshal_data,
1772 int n_params,
1773 GType *param_types)
1774 {
1775 typedef void (*GMarshalFunc_VOID__POINTER) (gpointer instance,
1776 gpointer arg_0,
1777 gpointer data);
1778 GCClosure *cc = (GCClosure*) closure;
1779 gpointer data1, data2;
1780 GMarshalFunc_VOID__POINTER callback;
1781 gpointer arg0;
1782 va_list args_copy;
1783
1784 G_VA_COPY (args_copy, args);
1785 arg0 = (gpointer) va_arg (args_copy, gpointer);
1786 va_end (args_copy);
1787
1788 if (G_CCLOSURE_SWAP_DATA (closure))
1789 {
1790 data1 = closure->data;
1791 data2 = instance;
1792 }
1793 else
1794 {
1795 data1 = instance;
1796 data2 = closure->data;
1797 }
1798 callback = (GMarshalFunc_VOID__POINTER) (marshal_data ? marshal_data : cc->callback);
1799
1800 callback (data1,
1801 arg0,
1802 data2);
1803 }
1804
1805 /**
1806 * g_cclosure_marshal_VOID__OBJECT:
1807 * @closure: A #GClosure.
1808 * @return_value: A #GValue to store the return value. May be %NULL
1809 * if the callback of closure doesn't return a value.
1810 * @n_param_values: The length of the @param_values array.
1811 * @param_values: An array of #GValues holding the arguments
1812 * on which to invoke the callback of closure.
1813 * @invocation_hint: The invocation hint given as the last argument to
1814 * g_closure_invoke().
1815 * @marshal_data: Additional data specified when registering the
1816 * marshaller, see g_closure_set_marshal() and
1817 * g_closure_set_meta_marshal()
1818 *
1819 * A #GClosureMarshal function for use with signals with a single
1820 * #GObject argument.
1821 */
1822 /* VOID:OBJECT */
1823 void
g_cclosure_marshal_VOID__OBJECT(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)1824 g_cclosure_marshal_VOID__OBJECT (GClosure *closure,
1825 GValue *return_value G_GNUC_UNUSED,
1826 guint n_param_values,
1827 const GValue *param_values,
1828 gpointer invocation_hint G_GNUC_UNUSED,
1829 gpointer marshal_data)
1830 {
1831 typedef void (*GMarshalFunc_VOID__OBJECT) (gpointer data1,
1832 gpointer arg_1,
1833 gpointer data2);
1834 GMarshalFunc_VOID__OBJECT callback;
1835 GCClosure *cc = (GCClosure*) closure;
1836 gpointer data1, data2;
1837
1838 g_return_if_fail (n_param_values == 2);
1839
1840 if (G_CCLOSURE_SWAP_DATA (closure))
1841 {
1842 data1 = closure->data;
1843 data2 = g_value_peek_pointer (param_values + 0);
1844 }
1845 else
1846 {
1847 data1 = g_value_peek_pointer (param_values + 0);
1848 data2 = closure->data;
1849 }
1850 callback = (GMarshalFunc_VOID__OBJECT) (marshal_data ? marshal_data : cc->callback);
1851
1852 callback (data1,
1853 g_marshal_value_peek_object (param_values + 1),
1854 data2);
1855 }
1856
1857 /**
1858 * g_cclosure_marshal_VOID__OBJECTv:
1859 * @closure: the #GClosure to which the marshaller belongs
1860 * @return_value: (nullable): a #GValue to store the return
1861 * value. May be %NULL if the callback of @closure doesn't return a
1862 * value.
1863 * @instance: (type GObject.TypeInstance): the instance on which the closure is invoked.
1864 * @args: va_list of arguments to be passed to the closure.
1865 * @marshal_data: (nullable): additional data specified when
1866 * registering the marshaller, see g_closure_set_marshal() and
1867 * g_closure_set_meta_marshal()
1868 * @n_params: the length of the @param_types array
1869 * @param_types: (array length=n_params): the #GType of each argument from
1870 * @args.
1871 *
1872 * The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__OBJECT().
1873 */
1874 void
g_cclosure_marshal_VOID__OBJECTv(GClosure * closure,GValue * return_value,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)1875 g_cclosure_marshal_VOID__OBJECTv (GClosure *closure,
1876 GValue *return_value,
1877 gpointer instance,
1878 va_list args,
1879 gpointer marshal_data,
1880 int n_params,
1881 GType *param_types)
1882 {
1883 typedef void (*GMarshalFunc_VOID__OBJECT) (gpointer instance,
1884 gpointer arg_0,
1885 gpointer data);
1886 GCClosure *cc = (GCClosure*) closure;
1887 gpointer data1, data2;
1888 GMarshalFunc_VOID__OBJECT callback;
1889 gpointer arg0;
1890 va_list args_copy;
1891
1892 G_VA_COPY (args_copy, args);
1893 arg0 = (gpointer) va_arg (args_copy, gpointer);
1894 if (arg0 != NULL)
1895 arg0 = g_object_ref (arg0);
1896 va_end (args_copy);
1897
1898 if (G_CCLOSURE_SWAP_DATA (closure))
1899 {
1900 data1 = closure->data;
1901 data2 = instance;
1902 }
1903 else
1904 {
1905 data1 = instance;
1906 data2 = closure->data;
1907 }
1908 callback = (GMarshalFunc_VOID__OBJECT) (marshal_data ? marshal_data : cc->callback);
1909
1910 callback (data1,
1911 arg0,
1912 data2);
1913 if (arg0 != NULL)
1914 g_object_unref (arg0);
1915 }
1916
1917 /**
1918 * g_cclosure_marshal_VOID__VARIANT:
1919 * @closure: A #GClosure.
1920 * @return_value: A #GValue to store the return value. May be %NULL
1921 * if the callback of closure doesn't return a value.
1922 * @n_param_values: The length of the @param_values array.
1923 * @param_values: An array of #GValues holding the arguments
1924 * on which to invoke the callback of closure.
1925 * @invocation_hint: The invocation hint given as the last argument to
1926 * g_closure_invoke().
1927 * @marshal_data: Additional data specified when registering the
1928 * marshaller, see g_closure_set_marshal() and
1929 * g_closure_set_meta_marshal()
1930 *
1931 * A #GClosureMarshal function for use with signals with a single
1932 * #GVariant argument.
1933 */
1934 /* VOID:VARIANT */
1935 void
g_cclosure_marshal_VOID__VARIANT(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)1936 g_cclosure_marshal_VOID__VARIANT (GClosure *closure,
1937 GValue *return_value G_GNUC_UNUSED,
1938 guint n_param_values,
1939 const GValue *param_values,
1940 gpointer invocation_hint G_GNUC_UNUSED,
1941 gpointer marshal_data)
1942 {
1943 typedef void (*GMarshalFunc_VOID__VARIANT) (gpointer data1,
1944 gpointer arg_1,
1945 gpointer data2);
1946 GMarshalFunc_VOID__VARIANT callback;
1947 GCClosure *cc = (GCClosure*) closure;
1948 gpointer data1, data2;
1949
1950 g_return_if_fail (n_param_values == 2);
1951
1952 if (G_CCLOSURE_SWAP_DATA (closure))
1953 {
1954 data1 = closure->data;
1955 data2 = g_value_peek_pointer (param_values + 0);
1956 }
1957 else
1958 {
1959 data1 = g_value_peek_pointer (param_values + 0);
1960 data2 = closure->data;
1961 }
1962 callback = (GMarshalFunc_VOID__VARIANT) (marshal_data ? marshal_data : cc->callback);
1963
1964 callback (data1,
1965 g_marshal_value_peek_variant (param_values + 1),
1966 data2);
1967 }
1968
1969 /**
1970 * g_cclosure_marshal_VOID__VARIANTv:
1971 * @closure: the #GClosure to which the marshaller belongs
1972 * @return_value: (nullable): a #GValue to store the return
1973 * value. May be %NULL if the callback of @closure doesn't return a
1974 * value.
1975 * @instance: (type GObject.TypeInstance): the instance on which the closure is invoked.
1976 * @args: va_list of arguments to be passed to the closure.
1977 * @marshal_data: (nullable): additional data specified when
1978 * registering the marshaller, see g_closure_set_marshal() and
1979 * g_closure_set_meta_marshal()
1980 * @n_params: the length of the @param_types array
1981 * @param_types: (array length=n_params): the #GType of each argument from
1982 * @args.
1983 *
1984 * The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__VARIANT().
1985 */
1986 void
g_cclosure_marshal_VOID__VARIANTv(GClosure * closure,GValue * return_value,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)1987 g_cclosure_marshal_VOID__VARIANTv (GClosure *closure,
1988 GValue *return_value,
1989 gpointer instance,
1990 va_list args,
1991 gpointer marshal_data,
1992 int n_params,
1993 GType *param_types)
1994 {
1995 typedef void (*GMarshalFunc_VOID__VARIANT) (gpointer instance,
1996 gpointer arg_0,
1997 gpointer data);
1998 GCClosure *cc = (GCClosure*) closure;
1999 gpointer data1, data2;
2000 GMarshalFunc_VOID__VARIANT callback;
2001 gpointer arg0;
2002 va_list args_copy;
2003
2004 G_VA_COPY (args_copy, args);
2005 arg0 = (gpointer) va_arg (args_copy, gpointer);
2006 if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
2007 arg0 = g_variant_ref_sink (arg0);
2008 va_end (args_copy);
2009
2010 if (G_CCLOSURE_SWAP_DATA (closure))
2011 {
2012 data1 = closure->data;
2013 data2 = instance;
2014 }
2015 else
2016 {
2017 data1 = instance;
2018 data2 = closure->data;
2019 }
2020 callback = (GMarshalFunc_VOID__VARIANT) (marshal_data ? marshal_data : cc->callback);
2021
2022 callback (data1,
2023 arg0,
2024 data2);
2025 if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
2026 g_variant_unref (arg0);
2027 }
2028
2029 /**
2030 * g_cclosure_marshal_VOID__UINT_POINTER:
2031 * @closure: A #GClosure.
2032 * @return_value: A #GValue to store the return value. May be %NULL
2033 * if the callback of closure doesn't return a value.
2034 * @n_param_values: The length of the @param_values array.
2035 * @param_values: An array of #GValues holding the arguments
2036 * on which to invoke the callback of closure.
2037 * @invocation_hint: The invocation hint given as the last argument to
2038 * g_closure_invoke().
2039 * @marshal_data: Additional data specified when registering the
2040 * marshaller, see g_closure_set_marshal() and
2041 * g_closure_set_meta_marshal()
2042 *
2043 * A #GClosureMarshal function for use with signals with an unsigned int
2044 * and a pointer as arguments.
2045 */
2046 /* VOID:UINT,POINTER */
2047 void
g_cclosure_marshal_VOID__UINT_POINTER(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)2048 g_cclosure_marshal_VOID__UINT_POINTER (GClosure *closure,
2049 GValue *return_value G_GNUC_UNUSED,
2050 guint n_param_values,
2051 const GValue *param_values,
2052 gpointer invocation_hint G_GNUC_UNUSED,
2053 gpointer marshal_data)
2054 {
2055 typedef void (*GMarshalFunc_VOID__UINT_POINTER) (gpointer data1,
2056 guint arg_1,
2057 gpointer arg_2,
2058 gpointer data2);
2059 GMarshalFunc_VOID__UINT_POINTER callback;
2060 GCClosure *cc = (GCClosure*) closure;
2061 gpointer data1, data2;
2062
2063 g_return_if_fail (n_param_values == 3);
2064
2065 if (G_CCLOSURE_SWAP_DATA (closure))
2066 {
2067 data1 = closure->data;
2068 data2 = g_value_peek_pointer (param_values + 0);
2069 }
2070 else
2071 {
2072 data1 = g_value_peek_pointer (param_values + 0);
2073 data2 = closure->data;
2074 }
2075 callback = (GMarshalFunc_VOID__UINT_POINTER) (marshal_data ? marshal_data : cc->callback);
2076
2077 callback (data1,
2078 g_marshal_value_peek_uint (param_values + 1),
2079 g_marshal_value_peek_pointer (param_values + 2),
2080 data2);
2081 }
2082
2083 /**
2084 * g_cclosure_marshal_VOID__UINT_POINTERv:
2085 * @closure: the #GClosure to which the marshaller belongs
2086 * @return_value: (nullable): a #GValue to store the return
2087 * value. May be %NULL if the callback of @closure doesn't return a
2088 * value.
2089 * @instance: (type GObject.TypeInstance): the instance on which the closure is invoked.
2090 * @args: va_list of arguments to be passed to the closure.
2091 * @marshal_data: (nullable): additional data specified when
2092 * registering the marshaller, see g_closure_set_marshal() and
2093 * g_closure_set_meta_marshal()
2094 * @n_params: the length of the @param_types array
2095 * @param_types: (array length=n_params): the #GType of each argument from
2096 * @args.
2097 *
2098 * The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__UINT_POINTER().
2099 */
2100 void
g_cclosure_marshal_VOID__UINT_POINTERv(GClosure * closure,GValue * return_value,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)2101 g_cclosure_marshal_VOID__UINT_POINTERv (GClosure *closure,
2102 GValue *return_value,
2103 gpointer instance,
2104 va_list args,
2105 gpointer marshal_data,
2106 int n_params,
2107 GType *param_types)
2108 {
2109 typedef void (*GMarshalFunc_VOID__UINT_POINTER) (gpointer instance,
2110 guint arg_0,
2111 gpointer arg_1,
2112 gpointer data);
2113 GCClosure *cc = (GCClosure*) closure;
2114 gpointer data1, data2;
2115 GMarshalFunc_VOID__UINT_POINTER callback;
2116 guint arg0;
2117 gpointer arg1;
2118 va_list args_copy;
2119
2120 G_VA_COPY (args_copy, args);
2121 arg0 = (guint) va_arg (args_copy, guint);
2122 arg1 = (gpointer) va_arg (args_copy, gpointer);
2123 va_end (args_copy);
2124
2125 if (G_CCLOSURE_SWAP_DATA (closure))
2126 {
2127 data1 = closure->data;
2128 data2 = instance;
2129 }
2130 else
2131 {
2132 data1 = instance;
2133 data2 = closure->data;
2134 }
2135 callback = (GMarshalFunc_VOID__UINT_POINTER) (marshal_data ? marshal_data : cc->callback);
2136
2137 callback (data1,
2138 arg0,
2139 arg1,
2140 data2);
2141 }
2142
2143 /**
2144 * g_cclosure_marshal_BOOLEAN__FLAGS:
2145 * @closure: A #GClosure.
2146 * @return_value: A #GValue to store the return value. May be %NULL
2147 * if the callback of closure doesn't return a value.
2148 * @n_param_values: The length of the @param_values array.
2149 * @param_values: An array of #GValues holding the arguments
2150 * on which to invoke the callback of closure.
2151 * @invocation_hint: The invocation hint given as the last argument to
2152 * g_closure_invoke().
2153 * @marshal_data: Additional data specified when registering the
2154 * marshaller, see g_closure_set_marshal() and
2155 * g_closure_set_meta_marshal()
2156 *
2157 * A #GClosureMarshal function for use with signals with handlers that
2158 * take a flags type as an argument and return a boolean. If you have
2159 * such a signal, you will probably also need to use an accumulator,
2160 * such as g_signal_accumulator_true_handled().
2161 */
2162 /* BOOL:FLAGS */
2163 void
g_cclosure_marshal_BOOLEAN__FLAGS(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)2164 g_cclosure_marshal_BOOLEAN__FLAGS (GClosure *closure,
2165 GValue *return_value G_GNUC_UNUSED,
2166 guint n_param_values,
2167 const GValue *param_values,
2168 gpointer invocation_hint G_GNUC_UNUSED,
2169 gpointer marshal_data)
2170 {
2171 typedef gboolean (*GMarshalFunc_BOOLEAN__FLAGS) (gpointer data1,
2172 guint arg_1,
2173 gpointer data2);
2174 GMarshalFunc_BOOLEAN__FLAGS callback;
2175 GCClosure *cc = (GCClosure*) closure;
2176 gpointer data1, data2;
2177 gboolean v_return;
2178
2179 g_return_if_fail (return_value != NULL);
2180 g_return_if_fail (n_param_values == 2);
2181
2182 if (G_CCLOSURE_SWAP_DATA (closure))
2183 {
2184 data1 = closure->data;
2185 data2 = g_value_peek_pointer (param_values + 0);
2186 }
2187 else
2188 {
2189 data1 = g_value_peek_pointer (param_values + 0);
2190 data2 = closure->data;
2191 }
2192 callback = (GMarshalFunc_BOOLEAN__FLAGS) (marshal_data ? marshal_data : cc->callback);
2193
2194 v_return = callback (data1,
2195 g_marshal_value_peek_flags (param_values + 1),
2196 data2);
2197
2198 g_value_set_boolean (return_value, v_return);
2199 }
2200
2201 /**
2202 * g_cclosure_marshal_BOOLEAN__FLAGSv:
2203 * @closure: the #GClosure to which the marshaller belongs
2204 * @return_value: (nullable): a #GValue to store the return
2205 * value. May be %NULL if the callback of @closure doesn't return a
2206 * value.
2207 * @instance: (type GObject.TypeInstance): the instance on which the closure is invoked.
2208 * @args: va_list of arguments to be passed to the closure.
2209 * @marshal_data: (nullable): additional data specified when
2210 * registering the marshaller, see g_closure_set_marshal() and
2211 * g_closure_set_meta_marshal()
2212 * @n_params: the length of the @param_types array
2213 * @param_types: (array length=n_params): the #GType of each argument from
2214 * @args.
2215 *
2216 * The #GVaClosureMarshal equivalent to g_cclosure_marshal_BOOLEAN__FLAGS().
2217 */
2218 void
g_cclosure_marshal_BOOLEAN__FLAGSv(GClosure * closure,GValue * return_value,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)2219 g_cclosure_marshal_BOOLEAN__FLAGSv (GClosure *closure,
2220 GValue *return_value,
2221 gpointer instance,
2222 va_list args,
2223 gpointer marshal_data,
2224 int n_params,
2225 GType *param_types)
2226 {
2227 typedef gboolean (*GMarshalFunc_BOOLEAN__FLAGS) (gpointer instance,
2228 guint arg_0,
2229 gpointer data);
2230 GCClosure *cc = (GCClosure*) closure;
2231 gpointer data1, data2;
2232 GMarshalFunc_BOOLEAN__FLAGS callback;
2233 guint arg0;
2234 va_list args_copy;
2235 gboolean v_return;
2236
2237 g_return_if_fail (return_value != NULL);
2238
2239 G_VA_COPY (args_copy, args);
2240 arg0 = (guint) va_arg (args_copy, guint);
2241 va_end (args_copy);
2242
2243 if (G_CCLOSURE_SWAP_DATA (closure))
2244 {
2245 data1 = closure->data;
2246 data2 = instance;
2247 }
2248 else
2249 {
2250 data1 = instance;
2251 data2 = closure->data;
2252 }
2253 callback = (GMarshalFunc_BOOLEAN__FLAGS) (marshal_data ? marshal_data : cc->callback);
2254
2255 v_return = callback (data1,
2256 arg0,
2257 data2);
2258
2259 g_value_set_boolean (return_value, v_return);
2260 }
2261
2262 /**
2263 * g_cclosure_marshal_STRING__OBJECT_POINTER:
2264 * @closure: A #GClosure.
2265 * @return_value: A #GValue to store the return value. May be %NULL
2266 * if the callback of closure doesn't return a value.
2267 * @n_param_values: The length of the @param_values array.
2268 * @param_values: An array of #GValues holding the arguments
2269 * on which to invoke the callback of closure.
2270 * @invocation_hint: The invocation hint given as the last argument to
2271 * g_closure_invoke().
2272 * @marshal_data: Additional data specified when registering the
2273 * marshaller, see g_closure_set_marshal() and
2274 * g_closure_set_meta_marshal()
2275 *
2276 * A #GClosureMarshal function for use with signals with handlers that
2277 * take a #GObject and a pointer and produce a string. It is highly
2278 * unlikely that your signal handler fits this description.
2279 */
2280 /* STRING:OBJECT,POINTER */
2281 void
g_cclosure_marshal_STRING__OBJECT_POINTER(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)2282 g_cclosure_marshal_STRING__OBJECT_POINTER (GClosure *closure,
2283 GValue *return_value G_GNUC_UNUSED,
2284 guint n_param_values,
2285 const GValue *param_values,
2286 gpointer invocation_hint G_GNUC_UNUSED,
2287 gpointer marshal_data)
2288 {
2289 typedef gchar* (*GMarshalFunc_STRING__OBJECT_POINTER) (gpointer data1,
2290 gpointer arg_1,
2291 gpointer arg_2,
2292 gpointer data2);
2293 GMarshalFunc_STRING__OBJECT_POINTER callback;
2294 GCClosure *cc = (GCClosure*) closure;
2295 gpointer data1, data2;
2296 gchar* v_return;
2297
2298 g_return_if_fail (return_value != NULL);
2299 g_return_if_fail (n_param_values == 3);
2300
2301 if (G_CCLOSURE_SWAP_DATA (closure))
2302 {
2303 data1 = closure->data;
2304 data2 = g_value_peek_pointer (param_values + 0);
2305 }
2306 else
2307 {
2308 data1 = g_value_peek_pointer (param_values + 0);
2309 data2 = closure->data;
2310 }
2311 callback = (GMarshalFunc_STRING__OBJECT_POINTER) (marshal_data ? marshal_data : cc->callback);
2312
2313 v_return = callback (data1,
2314 g_marshal_value_peek_object (param_values + 1),
2315 g_marshal_value_peek_pointer (param_values + 2),
2316 data2);
2317
2318 g_value_take_string (return_value, v_return);
2319 }
2320
2321 /**
2322 * g_cclosure_marshal_STRING__OBJECT_POINTERv:
2323 * @closure: the #GClosure to which the marshaller belongs
2324 * @return_value: (nullable): a #GValue to store the return
2325 * value. May be %NULL if the callback of @closure doesn't return a
2326 * value.
2327 * @instance: (type GObject.TypeInstance): the instance on which the closure is invoked.
2328 * @args: va_list of arguments to be passed to the closure.
2329 * @marshal_data: (nullable): additional data specified when
2330 * registering the marshaller, see g_closure_set_marshal() and
2331 * g_closure_set_meta_marshal()
2332 * @n_params: the length of the @param_types array
2333 * @param_types: (array length=n_params): the #GType of each argument from
2334 * @args.
2335 *
2336 * The #GVaClosureMarshal equivalent to g_cclosure_marshal_STRING__OBJECT_POINTER().
2337 */
2338 void
g_cclosure_marshal_STRING__OBJECT_POINTERv(GClosure * closure,GValue * return_value,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)2339 g_cclosure_marshal_STRING__OBJECT_POINTERv (GClosure *closure,
2340 GValue *return_value,
2341 gpointer instance,
2342 va_list args,
2343 gpointer marshal_data,
2344 int n_params,
2345 GType *param_types)
2346 {
2347 typedef gchar* (*GMarshalFunc_STRING__OBJECT_POINTER) (gpointer instance,
2348 gpointer arg_0,
2349 gpointer arg_1,
2350 gpointer data);
2351 GCClosure *cc = (GCClosure*) closure;
2352 gpointer data1, data2;
2353 GMarshalFunc_STRING__OBJECT_POINTER callback;
2354 gpointer arg0;
2355 gpointer arg1;
2356 va_list args_copy;
2357 gchar* v_return;
2358
2359 g_return_if_fail (return_value != NULL);
2360
2361 G_VA_COPY (args_copy, args);
2362 arg0 = (gpointer) va_arg (args_copy, gpointer);
2363 if (arg0 != NULL)
2364 arg0 = g_object_ref (arg0);
2365 arg1 = (gpointer) va_arg (args_copy, gpointer);
2366 va_end (args_copy);
2367
2368 if (G_CCLOSURE_SWAP_DATA (closure))
2369 {
2370 data1 = closure->data;
2371 data2 = instance;
2372 }
2373 else
2374 {
2375 data1 = instance;
2376 data2 = closure->data;
2377 }
2378 callback = (GMarshalFunc_STRING__OBJECT_POINTER) (marshal_data ? marshal_data : cc->callback);
2379
2380 v_return = callback (data1,
2381 arg0,
2382 arg1,
2383 data2);
2384 if (arg0 != NULL)
2385 g_object_unref (arg0);
2386
2387 g_value_take_string (return_value, v_return);
2388 }
2389
2390 /**
2391 * g_cclosure_marshal_BOOLEAN__BOXED_BOXED:
2392 * @closure: A #GClosure.
2393 * @return_value: A #GValue to store the return value. May be %NULL
2394 * if the callback of closure doesn't return a value.
2395 * @n_param_values: The length of the @param_values array.
2396 * @param_values: An array of #GValues holding the arguments
2397 * on which to invoke the callback of closure.
2398 * @invocation_hint: The invocation hint given as the last argument to
2399 * g_closure_invoke().
2400 * @marshal_data: Additional data specified when registering the
2401 * marshaller, see g_closure_set_marshal() and
2402 * g_closure_set_meta_marshal()
2403 *
2404 * A #GClosureMarshal function for use with signals with handlers that
2405 * take two boxed pointers as arguments and return a boolean. If you
2406 * have such a signal, you will probably also need to use an
2407 * accumulator, such as g_signal_accumulator_true_handled().
2408 */
2409 /* BOOL:BOXED,BOXED */
2410 void
g_cclosure_marshal_BOOLEAN__BOXED_BOXED(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)2411 g_cclosure_marshal_BOOLEAN__BOXED_BOXED (GClosure *closure,
2412 GValue *return_value G_GNUC_UNUSED,
2413 guint n_param_values,
2414 const GValue *param_values,
2415 gpointer invocation_hint G_GNUC_UNUSED,
2416 gpointer marshal_data)
2417 {
2418 typedef gboolean (*GMarshalFunc_BOOLEAN__BOXED_BOXED) (gpointer data1,
2419 gpointer arg_1,
2420 gpointer arg_2,
2421 gpointer data2);
2422 GMarshalFunc_BOOLEAN__BOXED_BOXED callback;
2423 GCClosure *cc = (GCClosure*) closure;
2424 gpointer data1, data2;
2425 gboolean v_return;
2426
2427 g_return_if_fail (return_value != NULL);
2428 g_return_if_fail (n_param_values == 3);
2429
2430 if (G_CCLOSURE_SWAP_DATA (closure))
2431 {
2432 data1 = closure->data;
2433 data2 = g_value_peek_pointer (param_values + 0);
2434 }
2435 else
2436 {
2437 data1 = g_value_peek_pointer (param_values + 0);
2438 data2 = closure->data;
2439 }
2440 callback = (GMarshalFunc_BOOLEAN__BOXED_BOXED) (marshal_data ? marshal_data : cc->callback);
2441
2442 v_return = callback (data1,
2443 g_marshal_value_peek_boxed (param_values + 1),
2444 g_marshal_value_peek_boxed (param_values + 2),
2445 data2);
2446
2447 g_value_set_boolean (return_value, v_return);
2448 }
2449
2450 /**
2451 * g_cclosure_marshal_BOOLEAN__BOXED_BOXEDv:
2452 * @closure: the #GClosure to which the marshaller belongs
2453 * @return_value: (nullable): a #GValue to store the return
2454 * value. May be %NULL if the callback of @closure doesn't return a
2455 * value.
2456 * @instance: (type GObject.TypeInstance): the instance on which the closure is invoked.
2457 * @args: va_list of arguments to be passed to the closure.
2458 * @marshal_data: (nullable): additional data specified when
2459 * registering the marshaller, see g_closure_set_marshal() and
2460 * g_closure_set_meta_marshal()
2461 * @n_params: the length of the @param_types array
2462 * @param_types: (array length=n_params): the #GType of each argument from
2463 * @args.
2464 *
2465 * The #GVaClosureMarshal equivalent to g_cclosure_marshal_BOOLEAN__BOXED_BOXED().
2466 */
2467 void
g_cclosure_marshal_BOOLEAN__BOXED_BOXEDv(GClosure * closure,GValue * return_value,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)2468 g_cclosure_marshal_BOOLEAN__BOXED_BOXEDv (GClosure *closure,
2469 GValue *return_value,
2470 gpointer instance,
2471 va_list args,
2472 gpointer marshal_data,
2473 int n_params,
2474 GType *param_types)
2475 {
2476 typedef gboolean (*GMarshalFunc_BOOLEAN__BOXED_BOXED) (gpointer instance,
2477 gpointer arg_0,
2478 gpointer arg_1,
2479 gpointer data);
2480 GCClosure *cc = (GCClosure*) closure;
2481 gpointer data1, data2;
2482 GMarshalFunc_BOOLEAN__BOXED_BOXED callback;
2483 gpointer arg0;
2484 gpointer arg1;
2485 va_list args_copy;
2486 gboolean v_return;
2487
2488 g_return_if_fail (return_value != NULL);
2489
2490 G_VA_COPY (args_copy, args);
2491 arg0 = (gpointer) va_arg (args_copy, gpointer);
2492 if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
2493 arg0 = g_boxed_copy (param_types[0] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg0);
2494 arg1 = (gpointer) va_arg (args_copy, gpointer);
2495 if ((param_types[1] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg1 != NULL)
2496 arg1 = g_boxed_copy (param_types[1] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg1);
2497 va_end (args_copy);
2498
2499 if (G_CCLOSURE_SWAP_DATA (closure))
2500 {
2501 data1 = closure->data;
2502 data2 = instance;
2503 }
2504 else
2505 {
2506 data1 = instance;
2507 data2 = closure->data;
2508 }
2509 callback = (GMarshalFunc_BOOLEAN__BOXED_BOXED) (marshal_data ? marshal_data : cc->callback);
2510
2511 v_return = callback (data1,
2512 arg0,
2513 arg1,
2514 data2);
2515 if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
2516 g_boxed_free (param_types[0] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg0);
2517 if ((param_types[1] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg1 != NULL)
2518 g_boxed_free (param_types[1] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg1);
2519
2520 g_value_set_boolean (return_value, v_return);
2521 }
2522