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