1 /* GObject - GLib Type, Object, Parameter and Signal Library
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.
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.
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/>.
19 #include <glib-object.h>
20 #include "gmarshal-internal.h"
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
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 */
70 _g_cclosure_marshal_BOOLEAN__OBJECT (GClosure *closure,
73 const GValue *param_values,
74 gpointer invocation_hint G_GNUC_UNUSED,
75 gpointer marshal_data)
77 typedef gboolean (*GMarshalFunc_BOOLEAN__OBJECT) (gpointer data1,
80 GCClosure *cc = (GCClosure *) closure;
81 gpointer data1, data2;
82 GMarshalFunc_BOOLEAN__OBJECT callback;
85 g_return_if_fail (return_value != NULL);
86 g_return_if_fail (n_param_values == 2);
88 if (G_CCLOSURE_SWAP_DATA (closure))
90 data1 = closure->data;
91 data2 = g_value_peek_pointer (param_values + 0);
95 data1 = g_value_peek_pointer (param_values + 0);
96 data2 = closure->data;
98 callback = (GMarshalFunc_BOOLEAN__OBJECT) (marshal_data ? marshal_data : cc->callback);
100 v_return = callback (data1,
101 g_marshal_value_peek_object (param_values + 1),
104 g_value_set_boolean (return_value, v_return);
108 _g_cclosure_marshal_BOOLEAN__OBJECTv (GClosure *closure,
109 GValue *return_value,
112 gpointer marshal_data,
116 typedef gboolean (*GMarshalFunc_BOOLEAN__OBJECT) (gpointer data1,
119 GCClosure *cc = (GCClosure *) closure;
120 gpointer data1, data2;
121 GMarshalFunc_BOOLEAN__OBJECT callback;
126 G_VA_COPY (args_copy, args);
127 arg0 = (gpointer) va_arg (args_copy, gpointer);
129 arg0 = g_object_ref (arg0);
132 g_return_if_fail (return_value != NULL);
134 if (G_CCLOSURE_SWAP_DATA (closure))
136 data1 = closure->data;
142 data2 = closure->data;
144 callback = (GMarshalFunc_BOOLEAN__OBJECT) (marshal_data ? marshal_data : cc->callback);
146 v_return = callback (data1,
150 g_object_unref (arg0);
152 g_value_set_boolean (return_value, v_return);
155 /* BOOLEAN:OBJECT,FLAGS */
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)
164 typedef gboolean (*GMarshalFunc_BOOLEAN__OBJECT_FLAGS) (gpointer data1,
168 GCClosure *cc = (GCClosure *) closure;
169 gpointer data1, data2;
170 GMarshalFunc_BOOLEAN__OBJECT_FLAGS callback;
173 g_return_if_fail (return_value != NULL);
174 g_return_if_fail (n_param_values == 3);
176 if (G_CCLOSURE_SWAP_DATA (closure))
178 data1 = closure->data;
179 data2 = g_value_peek_pointer (param_values + 0);
183 data1 = g_value_peek_pointer (param_values + 0);
184 data2 = closure->data;
186 callback = (GMarshalFunc_BOOLEAN__OBJECT_FLAGS) (marshal_data ? marshal_data : cc->callback);
188 v_return = callback (data1,
189 g_marshal_value_peek_object (param_values + 1),
190 g_marshal_value_peek_flags (param_values + 2),
193 g_value_set_boolean (return_value, v_return);
197 _g_cclosure_marshal_BOOLEAN__OBJECT_FLAGSv (GClosure *closure,
198 GValue *return_value,
201 gpointer marshal_data,
205 typedef gboolean (*GMarshalFunc_BOOLEAN__OBJECT_FLAGS) (gpointer data1,
209 GCClosure *cc = (GCClosure *) closure;
210 gpointer data1, data2;
211 GMarshalFunc_BOOLEAN__OBJECT_FLAGS callback;
217 G_VA_COPY (args_copy, args);
218 arg0 = (gpointer) va_arg (args_copy, gpointer);
220 arg0 = g_object_ref (arg0);
221 arg1 = (guint) va_arg (args_copy, guint);
224 g_return_if_fail (return_value != NULL);
226 if (G_CCLOSURE_SWAP_DATA (closure))
228 data1 = closure->data;
234 data2 = closure->data;
236 callback = (GMarshalFunc_BOOLEAN__OBJECT_FLAGS) (marshal_data ? marshal_data : cc->callback);
238 v_return = callback (data1,
243 g_object_unref (arg0);
245 g_value_set_boolean (return_value, v_return);
248 /* BOOLEAN:OBJECT,OBJECT */
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)
257 typedef gboolean (*GMarshalFunc_BOOLEAN__OBJECT_OBJECT) (gpointer data1,
261 GCClosure *cc = (GCClosure *) closure;
262 gpointer data1, data2;
263 GMarshalFunc_BOOLEAN__OBJECT_OBJECT callback;
266 g_return_if_fail (return_value != NULL);
267 g_return_if_fail (n_param_values == 3);
269 if (G_CCLOSURE_SWAP_DATA (closure))
271 data1 = closure->data;
272 data2 = g_value_peek_pointer (param_values + 0);
276 data1 = g_value_peek_pointer (param_values + 0);
277 data2 = closure->data;
279 callback = (GMarshalFunc_BOOLEAN__OBJECT_OBJECT) (marshal_data ? marshal_data : cc->callback);
281 v_return = callback (data1,
282 g_marshal_value_peek_object (param_values + 1),
283 g_marshal_value_peek_object (param_values + 2),
286 g_value_set_boolean (return_value, v_return);
290 _g_cclosure_marshal_BOOLEAN__OBJECT_OBJECTv (GClosure *closure,
291 GValue *return_value,
294 gpointer marshal_data,
298 typedef gboolean (*GMarshalFunc_BOOLEAN__OBJECT_OBJECT) (gpointer data1,
302 GCClosure *cc = (GCClosure *) closure;
303 gpointer data1, data2;
304 GMarshalFunc_BOOLEAN__OBJECT_OBJECT callback;
310 G_VA_COPY (args_copy, args);
311 arg0 = (gpointer) va_arg (args_copy, gpointer);
313 arg0 = g_object_ref (arg0);
314 arg1 = (gpointer) va_arg (args_copy, gpointer);
316 arg1 = g_object_ref (arg1);
319 g_return_if_fail (return_value != NULL);
321 if (G_CCLOSURE_SWAP_DATA (closure))
323 data1 = closure->data;
329 data2 = closure->data;
331 callback = (GMarshalFunc_BOOLEAN__OBJECT_OBJECT) (marshal_data ? marshal_data : cc->callback);
333 v_return = callback (data1,
338 g_object_unref (arg0);
340 g_object_unref (arg1);
342 g_value_set_boolean (return_value, v_return);
345 /* BOOLEAN:POINTER,INT */
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)
354 typedef gboolean (*GMarshalFunc_BOOLEAN__POINTER_INT) (gpointer data1,
358 GCClosure *cc = (GCClosure *) closure;
359 gpointer data1, data2;
360 GMarshalFunc_BOOLEAN__POINTER_INT callback;
363 g_return_if_fail (return_value != NULL);
364 g_return_if_fail (n_param_values == 3);
366 if (G_CCLOSURE_SWAP_DATA (closure))
368 data1 = closure->data;
369 data2 = g_value_peek_pointer (param_values + 0);
373 data1 = g_value_peek_pointer (param_values + 0);
374 data2 = closure->data;
376 callback = (GMarshalFunc_BOOLEAN__POINTER_INT) (marshal_data ? marshal_data : cc->callback);
378 v_return = callback (data1,
379 g_marshal_value_peek_pointer (param_values + 1),
380 g_marshal_value_peek_int (param_values + 2),
383 g_value_set_boolean (return_value, v_return);
387 _g_cclosure_marshal_BOOLEAN__POINTER_INTv (GClosure *closure,
388 GValue *return_value,
391 gpointer marshal_data,
395 typedef gboolean (*GMarshalFunc_BOOLEAN__POINTER_INT) (gpointer data1,
399 GCClosure *cc = (GCClosure *) closure;
400 gpointer data1, data2;
401 GMarshalFunc_BOOLEAN__POINTER_INT callback;
407 G_VA_COPY (args_copy, args);
408 arg0 = (gpointer) va_arg (args_copy, gpointer);
409 arg1 = (gint) va_arg (args_copy, gint);
412 g_return_if_fail (return_value != NULL);
414 if (G_CCLOSURE_SWAP_DATA (closure))
416 data1 = closure->data;
422 data2 = closure->data;
424 callback = (GMarshalFunc_BOOLEAN__POINTER_INT) (marshal_data ? marshal_data : cc->callback);
426 v_return = callback (data1,
432 g_value_set_boolean (return_value, v_return);
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)
444 typedef gboolean (*GMarshalFunc_BOOLEAN__STRING) (gpointer data1,
447 GCClosure *cc = (GCClosure *) closure;
448 gpointer data1, data2;
449 GMarshalFunc_BOOLEAN__STRING callback;
452 g_return_if_fail (return_value != NULL);
453 g_return_if_fail (n_param_values == 2);
455 if (G_CCLOSURE_SWAP_DATA (closure))
457 data1 = closure->data;
458 data2 = g_value_peek_pointer (param_values + 0);
462 data1 = g_value_peek_pointer (param_values + 0);
463 data2 = closure->data;
465 callback = (GMarshalFunc_BOOLEAN__STRING) (marshal_data ? marshal_data : cc->callback);
467 v_return = callback (data1,
468 g_marshal_value_peek_string (param_values + 1),
471 g_value_set_boolean (return_value, v_return);
475 _g_cclosure_marshal_BOOLEAN__STRINGv (GClosure *closure,
476 GValue *return_value,
479 gpointer marshal_data,
483 typedef gboolean (*GMarshalFunc_BOOLEAN__STRING) (gpointer data1,
486 GCClosure *cc = (GCClosure *) closure;
487 gpointer data1, data2;
488 GMarshalFunc_BOOLEAN__STRING callback;
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);
499 g_return_if_fail (return_value != NULL);
501 if (G_CCLOSURE_SWAP_DATA (closure))
503 data1 = closure->data;
509 data2 = closure->data;
511 callback = (GMarshalFunc_BOOLEAN__STRING) (marshal_data ? marshal_data : cc->callback);
513 v_return = callback (data1,
516 if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
519 g_value_set_boolean (return_value, v_return);
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)
531 typedef gboolean (*GMarshalFunc_BOOLEAN__UINT) (gpointer data1,
534 GCClosure *cc = (GCClosure *) closure;
535 gpointer data1, data2;
536 GMarshalFunc_BOOLEAN__UINT callback;
539 g_return_if_fail (return_value != NULL);
540 g_return_if_fail (n_param_values == 2);
542 if (G_CCLOSURE_SWAP_DATA (closure))
544 data1 = closure->data;
545 data2 = g_value_peek_pointer (param_values + 0);
549 data1 = g_value_peek_pointer (param_values + 0);
550 data2 = closure->data;
552 callback = (GMarshalFunc_BOOLEAN__UINT) (marshal_data ? marshal_data : cc->callback);
554 v_return = callback (data1,
555 g_marshal_value_peek_uint (param_values + 1),
558 g_value_set_boolean (return_value, v_return);
562 _g_cclosure_marshal_BOOLEAN__UINTv (GClosure *closure,
563 GValue *return_value,
566 gpointer marshal_data,
570 typedef gboolean (*GMarshalFunc_BOOLEAN__UINT) (gpointer data1,
573 GCClosure *cc = (GCClosure *) closure;
574 gpointer data1, data2;
575 GMarshalFunc_BOOLEAN__UINT callback;
580 G_VA_COPY (args_copy, args);
581 arg0 = (guint) va_arg (args_copy, guint);
584 g_return_if_fail (return_value != NULL);
586 if (G_CCLOSURE_SWAP_DATA (closure))
588 data1 = closure->data;
594 data2 = closure->data;
596 callback = (GMarshalFunc_BOOLEAN__UINT) (marshal_data ? marshal_data : cc->callback);
598 v_return = callback (data1,
603 g_value_set_boolean (return_value, v_return);
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)
615 typedef gboolean (*GMarshalFunc_BOOLEAN__VOID) (gpointer data1,
617 GCClosure *cc = (GCClosure *) closure;
618 gpointer data1, data2;
619 GMarshalFunc_BOOLEAN__VOID callback;
622 g_return_if_fail (return_value != NULL);
623 g_return_if_fail (n_param_values == 1);
625 if (G_CCLOSURE_SWAP_DATA (closure))
627 data1 = closure->data;
628 data2 = g_value_peek_pointer (param_values + 0);
632 data1 = g_value_peek_pointer (param_values + 0);
633 data2 = closure->data;
635 callback = (GMarshalFunc_BOOLEAN__VOID) (marshal_data ? marshal_data : cc->callback);
637 v_return = callback (data1,
640 g_value_set_boolean (return_value, v_return);
644 _g_cclosure_marshal_BOOLEAN__VOIDv (GClosure *closure,
645 GValue *return_value,
648 gpointer marshal_data,
652 typedef gboolean (*GMarshalFunc_BOOLEAN__VOID) (gpointer data1,
654 GCClosure *cc = (GCClosure *) closure;
655 gpointer data1, data2;
656 GMarshalFunc_BOOLEAN__VOID callback;
659 g_return_if_fail (return_value != NULL);
661 if (G_CCLOSURE_SWAP_DATA (closure))
663 data1 = closure->data;
669 data2 = closure->data;
671 callback = (GMarshalFunc_BOOLEAN__VOID) (marshal_data ? marshal_data : cc->callback);
673 v_return = callback (data1,
677 g_value_set_boolean (return_value, v_return);
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)
689 typedef gint (*GMarshalFunc_INT__BOXED) (gpointer data1,
692 GCClosure *cc = (GCClosure *) closure;
693 gpointer data1, data2;
694 GMarshalFunc_INT__BOXED callback;
697 g_return_if_fail (return_value != NULL);
698 g_return_if_fail (n_param_values == 2);
700 if (G_CCLOSURE_SWAP_DATA (closure))
702 data1 = closure->data;
703 data2 = g_value_peek_pointer (param_values + 0);
707 data1 = g_value_peek_pointer (param_values + 0);
708 data2 = closure->data;
710 callback = (GMarshalFunc_INT__BOXED) (marshal_data ? marshal_data : cc->callback);
712 v_return = callback (data1,
713 g_marshal_value_peek_boxed (param_values + 1),
716 g_value_set_int (return_value, v_return);
720 _g_cclosure_marshal_INT__BOXEDv (GClosure *closure,
721 GValue *return_value,
724 gpointer marshal_data,
728 typedef gint (*GMarshalFunc_INT__BOXED) (gpointer data1,
731 GCClosure *cc = (GCClosure *) closure;
732 gpointer data1, data2;
733 GMarshalFunc_INT__BOXED callback;
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);
744 g_return_if_fail (return_value != NULL);
746 if (G_CCLOSURE_SWAP_DATA (closure))
748 data1 = closure->data;
754 data2 = closure->data;
756 callback = (GMarshalFunc_INT__BOXED) (marshal_data ? marshal_data : cc->callback);
758 v_return = callback (data1,
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);
764 g_value_set_int (return_value, v_return);
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)
776 typedef gint (*GMarshalFunc_INT__OBJECT) (gpointer data1,
779 GCClosure *cc = (GCClosure *) closure;
780 gpointer data1, data2;
781 GMarshalFunc_INT__OBJECT callback;
784 g_return_if_fail (return_value != NULL);
785 g_return_if_fail (n_param_values == 2);
787 if (G_CCLOSURE_SWAP_DATA (closure))
789 data1 = closure->data;
790 data2 = g_value_peek_pointer (param_values + 0);
794 data1 = g_value_peek_pointer (param_values + 0);
795 data2 = closure->data;
797 callback = (GMarshalFunc_INT__OBJECT) (marshal_data ? marshal_data : cc->callback);
799 v_return = callback (data1,
800 g_marshal_value_peek_object (param_values + 1),
803 g_value_set_int (return_value, v_return);
807 _g_cclosure_marshal_INT__OBJECTv (GClosure *closure,
808 GValue *return_value,
811 gpointer marshal_data,
815 typedef gint (*GMarshalFunc_INT__OBJECT) (gpointer data1,
818 GCClosure *cc = (GCClosure *) closure;
819 gpointer data1, data2;
820 GMarshalFunc_INT__OBJECT callback;
825 G_VA_COPY (args_copy, args);
826 arg0 = (gpointer) va_arg (args_copy, gpointer);
828 arg0 = g_object_ref (arg0);
831 g_return_if_fail (return_value != NULL);
833 if (G_CCLOSURE_SWAP_DATA (closure))
835 data1 = closure->data;
841 data2 = closure->data;
843 callback = (GMarshalFunc_INT__OBJECT) (marshal_data ? marshal_data : cc->callback);
845 v_return = callback (data1,
849 g_object_unref (arg0);
851 g_value_set_int (return_value, v_return);
854 /* VOID:BOOLEAN,BOXED */
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)
863 typedef void (*GMarshalFunc_VOID__BOOLEAN_BOXED) (gpointer data1,
867 GCClosure *cc = (GCClosure *) closure;
868 gpointer data1, data2;
869 GMarshalFunc_VOID__BOOLEAN_BOXED callback;
871 g_return_if_fail (n_param_values == 3);
873 if (G_CCLOSURE_SWAP_DATA (closure))
875 data1 = closure->data;
876 data2 = g_value_peek_pointer (param_values + 0);
880 data1 = g_value_peek_pointer (param_values + 0);
881 data2 = closure->data;
883 callback = (GMarshalFunc_VOID__BOOLEAN_BOXED) (marshal_data ? marshal_data : cc->callback);
886 g_marshal_value_peek_boolean (param_values + 1),
887 g_marshal_value_peek_boxed (param_values + 2),
892 _g_cclosure_marshal_VOID__BOOLEAN_BOXEDv (GClosure *closure,
893 GValue *return_value G_GNUC_UNUSED,
896 gpointer marshal_data,
900 typedef void (*GMarshalFunc_VOID__BOOLEAN_BOXED) (gpointer data1,
904 GCClosure *cc = (GCClosure *) closure;
905 gpointer data1, data2;
906 GMarshalFunc_VOID__BOOLEAN_BOXED callback;
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);
919 if (G_CCLOSURE_SWAP_DATA (closure))
921 data1 = closure->data;
927 data2 = closure->data;
929 callback = (GMarshalFunc_VOID__BOOLEAN_BOXED) (marshal_data ? marshal_data : cc->callback);
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);
939 /* VOID:ENUM,OBJECT */
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)
948 typedef void (*GMarshalFunc_VOID__ENUM_OBJECT) (gpointer data1,
952 GCClosure *cc = (GCClosure *) closure;
953 gpointer data1, data2;
954 GMarshalFunc_VOID__ENUM_OBJECT callback;
956 g_return_if_fail (n_param_values == 3);
958 if (G_CCLOSURE_SWAP_DATA (closure))
960 data1 = closure->data;
961 data2 = g_value_peek_pointer (param_values + 0);
965 data1 = g_value_peek_pointer (param_values + 0);
966 data2 = closure->data;
968 callback = (GMarshalFunc_VOID__ENUM_OBJECT) (marshal_data ? marshal_data : cc->callback);
971 g_marshal_value_peek_enum (param_values + 1),
972 g_marshal_value_peek_object (param_values + 2),
977 _g_cclosure_marshal_VOID__ENUM_OBJECTv (GClosure *closure,
978 GValue *return_value G_GNUC_UNUSED,
981 gpointer marshal_data,
985 typedef void (*GMarshalFunc_VOID__ENUM_OBJECT) (gpointer data1,
989 GCClosure *cc = (GCClosure *) closure;
990 gpointer data1, data2;
991 GMarshalFunc_VOID__ENUM_OBJECT callback;
996 G_VA_COPY (args_copy, args);
997 arg0 = (gint) va_arg (args_copy, gint);
998 arg1 = (gpointer) va_arg (args_copy, gpointer);
1000 arg1 = g_object_ref (arg1);
1004 if (G_CCLOSURE_SWAP_DATA (closure))
1006 data1 = closure->data;
1012 data2 = closure->data;
1014 callback = (GMarshalFunc_VOID__ENUM_OBJECT) (marshal_data ? marshal_data : cc->callback);
1021 g_object_unref (arg1);
1024 /* VOID:ENUM,OBJECT,OBJECT */
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)
1033 typedef void (*GMarshalFunc_VOID__ENUM_OBJECT_OBJECT) (gpointer data1,
1038 GCClosure *cc = (GCClosure *) closure;
1039 gpointer data1, data2;
1040 GMarshalFunc_VOID__ENUM_OBJECT_OBJECT callback;
1042 g_return_if_fail (n_param_values == 4);
1044 if (G_CCLOSURE_SWAP_DATA (closure))
1046 data1 = closure->data;
1047 data2 = g_value_peek_pointer (param_values + 0);
1051 data1 = g_value_peek_pointer (param_values + 0);
1052 data2 = closure->data;
1054 callback = (GMarshalFunc_VOID__ENUM_OBJECT_OBJECT) (marshal_data ? marshal_data : cc->callback);
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),
1064 _g_cclosure_marshal_VOID__ENUM_OBJECT_OBJECTv (GClosure *closure,
1065 GValue *return_value G_GNUC_UNUSED,
1068 gpointer marshal_data,
1072 typedef void (*GMarshalFunc_VOID__ENUM_OBJECT_OBJECT) (gpointer data1,
1077 GCClosure *cc = (GCClosure *) closure;
1078 gpointer data1, data2;
1079 GMarshalFunc_VOID__ENUM_OBJECT_OBJECT callback;
1085 G_VA_COPY (args_copy, args);
1086 arg0 = (gint) va_arg (args_copy, gint);
1087 arg1 = (gpointer) va_arg (args_copy, gpointer);
1089 arg1 = g_object_ref (arg1);
1090 arg2 = (gpointer) va_arg (args_copy, gpointer);
1092 arg2 = g_object_ref (arg2);
1096 if (G_CCLOSURE_SWAP_DATA (closure))
1098 data1 = closure->data;
1104 data2 = closure->data;
1106 callback = (GMarshalFunc_VOID__ENUM_OBJECT_OBJECT) (marshal_data ? marshal_data : cc->callback);
1114 g_object_unref (arg1);
1116 g_object_unref (arg2);
1119 /* VOID:INT,INT,INT */
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)
1128 typedef void (*GMarshalFunc_VOID__INT_INT_INT) (gpointer data1,
1133 GCClosure *cc = (GCClosure *) closure;
1134 gpointer data1, data2;
1135 GMarshalFunc_VOID__INT_INT_INT callback;
1137 g_return_if_fail (n_param_values == 4);
1139 if (G_CCLOSURE_SWAP_DATA (closure))
1141 data1 = closure->data;
1142 data2 = g_value_peek_pointer (param_values + 0);
1146 data1 = g_value_peek_pointer (param_values + 0);
1147 data2 = closure->data;
1149 callback = (GMarshalFunc_VOID__INT_INT_INT) (marshal_data ? marshal_data : cc->callback);
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),
1159 _g_cclosure_marshal_VOID__INT_INT_INTv (GClosure *closure,
1160 GValue *return_value G_GNUC_UNUSED,
1163 gpointer marshal_data,
1167 typedef void (*GMarshalFunc_VOID__INT_INT_INT) (gpointer data1,
1172 GCClosure *cc = (GCClosure *) closure;
1173 gpointer data1, data2;
1174 GMarshalFunc_VOID__INT_INT_INT callback;
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);
1187 if (G_CCLOSURE_SWAP_DATA (closure))
1189 data1 = closure->data;
1195 data2 = closure->data;
1197 callback = (GMarshalFunc_VOID__INT_INT_INT) (marshal_data ? marshal_data : cc->callback);
1207 /* VOID:OBJECT,OBJECT */
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)
1216 typedef void (*GMarshalFunc_VOID__OBJECT_OBJECT) (gpointer data1,
1220 GCClosure *cc = (GCClosure *) closure;
1221 gpointer data1, data2;
1222 GMarshalFunc_VOID__OBJECT_OBJECT callback;
1224 g_return_if_fail (n_param_values == 3);
1226 if (G_CCLOSURE_SWAP_DATA (closure))
1228 data1 = closure->data;
1229 data2 = g_value_peek_pointer (param_values + 0);
1233 data1 = g_value_peek_pointer (param_values + 0);
1234 data2 = closure->data;
1236 callback = (GMarshalFunc_VOID__OBJECT_OBJECT) (marshal_data ? marshal_data : cc->callback);
1239 g_marshal_value_peek_object (param_values + 1),
1240 g_marshal_value_peek_object (param_values + 2),
1245 _g_cclosure_marshal_VOID__OBJECT_OBJECTv (GClosure *closure,
1246 GValue *return_value G_GNUC_UNUSED,
1249 gpointer marshal_data,
1253 typedef void (*GMarshalFunc_VOID__OBJECT_OBJECT) (gpointer data1,
1257 GCClosure *cc = (GCClosure *) closure;
1258 gpointer data1, data2;
1259 GMarshalFunc_VOID__OBJECT_OBJECT callback;
1264 G_VA_COPY (args_copy, args);
1265 arg0 = (gpointer) va_arg (args_copy, gpointer);
1267 arg0 = g_object_ref (arg0);
1268 arg1 = (gpointer) va_arg (args_copy, gpointer);
1270 arg1 = g_object_ref (arg1);
1274 if (G_CCLOSURE_SWAP_DATA (closure))
1276 data1 = closure->data;
1282 data2 = closure->data;
1284 callback = (GMarshalFunc_VOID__OBJECT_OBJECT) (marshal_data ? marshal_data : cc->callback);
1291 g_object_unref (arg0);
1293 g_object_unref (arg1);
1296 /* VOID:OBJECT,OBJECT,ENUM */
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)
1305 typedef void (*GMarshalFunc_VOID__OBJECT_OBJECT_ENUM) (gpointer data1,
1310 GCClosure *cc = (GCClosure *) closure;
1311 gpointer data1, data2;
1312 GMarshalFunc_VOID__OBJECT_OBJECT_ENUM callback;
1314 g_return_if_fail (n_param_values == 4);
1316 if (G_CCLOSURE_SWAP_DATA (closure))
1318 data1 = closure->data;
1319 data2 = g_value_peek_pointer (param_values + 0);
1323 data1 = g_value_peek_pointer (param_values + 0);
1324 data2 = closure->data;
1326 callback = (GMarshalFunc_VOID__OBJECT_OBJECT_ENUM) (marshal_data ? marshal_data : cc->callback);
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),
1336 _g_cclosure_marshal_VOID__OBJECT_OBJECT_ENUMv (GClosure *closure,
1337 GValue *return_value G_GNUC_UNUSED,
1340 gpointer marshal_data,
1344 typedef void (*GMarshalFunc_VOID__OBJECT_OBJECT_ENUM) (gpointer data1,
1349 GCClosure *cc = (GCClosure *) closure;
1350 gpointer data1, data2;
1351 GMarshalFunc_VOID__OBJECT_OBJECT_ENUM callback;
1357 G_VA_COPY (args_copy, args);
1358 arg0 = (gpointer) va_arg (args_copy, gpointer);
1360 arg0 = g_object_ref (arg0);
1361 arg1 = (gpointer) va_arg (args_copy, gpointer);
1363 arg1 = g_object_ref (arg1);
1364 arg2 = (gint) va_arg (args_copy, gint);
1368 if (G_CCLOSURE_SWAP_DATA (closure))
1370 data1 = closure->data;
1376 data2 = closure->data;
1378 callback = (GMarshalFunc_VOID__OBJECT_OBJECT_ENUM) (marshal_data ? marshal_data : cc->callback);
1386 g_object_unref (arg0);
1388 g_object_unref (arg1);
1391 /* VOID:OBJECT,OBJECT,STRING,STRING,VARIANT */
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)
1400 typedef void (*GMarshalFunc_VOID__OBJECT_OBJECT_STRING_STRING_VARIANT) (gpointer data1,
1407 GCClosure *cc = (GCClosure *) closure;
1408 gpointer data1, data2;
1409 GMarshalFunc_VOID__OBJECT_OBJECT_STRING_STRING_VARIANT callback;
1411 g_return_if_fail (n_param_values == 6);
1413 if (G_CCLOSURE_SWAP_DATA (closure))
1415 data1 = closure->data;
1416 data2 = g_value_peek_pointer (param_values + 0);
1420 data1 = g_value_peek_pointer (param_values + 0);
1421 data2 = closure->data;
1423 callback = (GMarshalFunc_VOID__OBJECT_OBJECT_STRING_STRING_VARIANT) (marshal_data ? marshal_data : cc->callback);
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),
1435 _g_cclosure_marshal_VOID__OBJECT_OBJECT_STRING_STRING_VARIANTv (GClosure *closure,
1436 GValue *return_value G_GNUC_UNUSED,
1439 gpointer marshal_data,
1443 typedef void (*GMarshalFunc_VOID__OBJECT_OBJECT_STRING_STRING_VARIANT) (gpointer data1,
1450 GCClosure *cc = (GCClosure *) closure;
1451 gpointer data1, data2;
1452 GMarshalFunc_VOID__OBJECT_OBJECT_STRING_STRING_VARIANT callback;
1460 G_VA_COPY (args_copy, args);
1461 arg0 = (gpointer) va_arg (args_copy, gpointer);
1463 arg0 = g_object_ref (arg0);
1464 arg1 = (gpointer) va_arg (args_copy, gpointer);
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);
1479 if (G_CCLOSURE_SWAP_DATA (closure))
1481 data1 = closure->data;
1487 data2 = closure->data;
1489 callback = (GMarshalFunc_VOID__OBJECT_OBJECT_STRING_STRING_VARIANT) (marshal_data ? marshal_data : cc->callback);
1499 g_object_unref (arg0);
1501 g_object_unref (arg1);
1502 if ((param_types[2] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg2 != NULL)
1504 if ((param_types[3] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg3 != NULL)
1506 if ((param_types[4] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg4 != NULL)
1507 g_variant_unref (arg4);
1510 /* VOID:OBJECT,OBJECT,VARIANT,BOXED */
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)
1519 typedef void (*GMarshalFunc_VOID__OBJECT_OBJECT_VARIANT_BOXED) (gpointer data1,
1525 GCClosure *cc = (GCClosure *) closure;
1526 gpointer data1, data2;
1527 GMarshalFunc_VOID__OBJECT_OBJECT_VARIANT_BOXED callback;
1529 g_return_if_fail (n_param_values == 5);
1531 if (G_CCLOSURE_SWAP_DATA (closure))
1533 data1 = closure->data;
1534 data2 = g_value_peek_pointer (param_values + 0);
1538 data1 = g_value_peek_pointer (param_values + 0);
1539 data2 = closure->data;
1541 callback = (GMarshalFunc_VOID__OBJECT_OBJECT_VARIANT_BOXED) (marshal_data ? marshal_data : cc->callback);
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),
1552 _g_cclosure_marshal_VOID__OBJECT_OBJECT_VARIANT_BOXEDv (GClosure *closure,
1553 GValue *return_value G_GNUC_UNUSED,
1556 gpointer marshal_data,
1560 typedef void (*GMarshalFunc_VOID__OBJECT_OBJECT_VARIANT_BOXED) (gpointer data1,
1566 GCClosure *cc = (GCClosure *) closure;
1567 gpointer data1, data2;
1568 GMarshalFunc_VOID__OBJECT_OBJECT_VARIANT_BOXED callback;
1575 G_VA_COPY (args_copy, args);
1576 arg0 = (gpointer) va_arg (args_copy, gpointer);
1578 arg0 = g_object_ref (arg0);
1579 arg1 = (gpointer) va_arg (args_copy, gpointer);
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);
1591 if (G_CCLOSURE_SWAP_DATA (closure))
1593 data1 = closure->data;
1599 data2 = closure->data;
1601 callback = (GMarshalFunc_VOID__OBJECT_OBJECT_VARIANT_BOXED) (marshal_data ? marshal_data : cc->callback);
1610 g_object_unref (arg0);
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);
1619 /* VOID:OBJECT,VARIANT */
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)
1628 typedef void (*GMarshalFunc_VOID__OBJECT_VARIANT) (gpointer data1,
1632 GCClosure *cc = (GCClosure *) closure;
1633 gpointer data1, data2;
1634 GMarshalFunc_VOID__OBJECT_VARIANT callback;
1636 g_return_if_fail (n_param_values == 3);
1638 if (G_CCLOSURE_SWAP_DATA (closure))
1640 data1 = closure->data;
1641 data2 = g_value_peek_pointer (param_values + 0);
1645 data1 = g_value_peek_pointer (param_values + 0);
1646 data2 = closure->data;
1648 callback = (GMarshalFunc_VOID__OBJECT_VARIANT) (marshal_data ? marshal_data : cc->callback);
1651 g_marshal_value_peek_object (param_values + 1),
1652 g_marshal_value_peek_variant (param_values + 2),
1657 _g_cclosure_marshal_VOID__OBJECT_VARIANTv (GClosure *closure,
1658 GValue *return_value G_GNUC_UNUSED,
1661 gpointer marshal_data,
1665 typedef void (*GMarshalFunc_VOID__OBJECT_VARIANT) (gpointer data1,
1669 GCClosure *cc = (GCClosure *) closure;
1670 gpointer data1, data2;
1671 GMarshalFunc_VOID__OBJECT_VARIANT callback;
1676 G_VA_COPY (args_copy, args);
1677 arg0 = (gpointer) va_arg (args_copy, gpointer);
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);
1686 if (G_CCLOSURE_SWAP_DATA (closure))
1688 data1 = closure->data;
1694 data2 = closure->data;
1696 callback = (GMarshalFunc_VOID__OBJECT_VARIANT) (marshal_data ? marshal_data : cc->callback);
1703 g_object_unref (arg0);
1704 if ((param_types[1] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg1 != NULL)
1705 g_variant_unref (arg1);
1708 /* VOID:POINTER,INT,STRING */
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)
1717 typedef void (*GMarshalFunc_VOID__POINTER_INT_STRING) (gpointer data1,
1722 GCClosure *cc = (GCClosure *) closure;
1723 gpointer data1, data2;
1724 GMarshalFunc_VOID__POINTER_INT_STRING callback;
1726 g_return_if_fail (n_param_values == 4);
1728 if (G_CCLOSURE_SWAP_DATA (closure))
1730 data1 = closure->data;
1731 data2 = g_value_peek_pointer (param_values + 0);
1735 data1 = g_value_peek_pointer (param_values + 0);
1736 data2 = closure->data;
1738 callback = (GMarshalFunc_VOID__POINTER_INT_STRING) (marshal_data ? marshal_data : cc->callback);
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),
1748 _g_cclosure_marshal_VOID__POINTER_INT_STRINGv (GClosure *closure,
1749 GValue *return_value G_GNUC_UNUSED,
1752 gpointer marshal_data,
1756 typedef void (*GMarshalFunc_VOID__POINTER_INT_STRING) (gpointer data1,
1761 GCClosure *cc = (GCClosure *) closure;
1762 gpointer data1, data2;
1763 GMarshalFunc_VOID__POINTER_INT_STRING callback;
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);
1778 if (G_CCLOSURE_SWAP_DATA (closure))
1780 data1 = closure->data;
1786 data2 = closure->data;
1788 callback = (GMarshalFunc_VOID__POINTER_INT_STRING) (marshal_data ? marshal_data : cc->callback);
1795 if ((param_types[2] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg2 != NULL)
1799 /* VOID:STRING,BOOLEAN */
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)
1808 typedef void (*GMarshalFunc_VOID__STRING_BOOLEAN) (gpointer data1,
1812 GCClosure *cc = (GCClosure *) closure;
1813 gpointer data1, data2;
1814 GMarshalFunc_VOID__STRING_BOOLEAN callback;
1816 g_return_if_fail (n_param_values == 3);
1818 if (G_CCLOSURE_SWAP_DATA (closure))
1820 data1 = closure->data;
1821 data2 = g_value_peek_pointer (param_values + 0);
1825 data1 = g_value_peek_pointer (param_values + 0);
1826 data2 = closure->data;
1828 callback = (GMarshalFunc_VOID__STRING_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
1831 g_marshal_value_peek_string (param_values + 1),
1832 g_marshal_value_peek_boolean (param_values + 2),
1837 _g_cclosure_marshal_VOID__STRING_BOOLEANv (GClosure *closure,
1838 GValue *return_value G_GNUC_UNUSED,
1841 gpointer marshal_data,
1845 typedef void (*GMarshalFunc_VOID__STRING_BOOLEAN) (gpointer data1,
1849 GCClosure *cc = (GCClosure *) closure;
1850 gpointer data1, data2;
1851 GMarshalFunc_VOID__STRING_BOOLEAN callback;
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);
1864 if (G_CCLOSURE_SWAP_DATA (closure))
1866 data1 = closure->data;
1872 data2 = closure->data;
1874 callback = (GMarshalFunc_VOID__STRING_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
1880 if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
1884 /* VOID:STRING,BOXED */
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)
1893 typedef void (*GMarshalFunc_VOID__STRING_BOXED) (gpointer data1,
1897 GCClosure *cc = (GCClosure *) closure;
1898 gpointer data1, data2;
1899 GMarshalFunc_VOID__STRING_BOXED callback;
1901 g_return_if_fail (n_param_values == 3);
1903 if (G_CCLOSURE_SWAP_DATA (closure))
1905 data1 = closure->data;
1906 data2 = g_value_peek_pointer (param_values + 0);
1910 data1 = g_value_peek_pointer (param_values + 0);
1911 data2 = closure->data;
1913 callback = (GMarshalFunc_VOID__STRING_BOXED) (marshal_data ? marshal_data : cc->callback);
1916 g_marshal_value_peek_string (param_values + 1),
1917 g_marshal_value_peek_boxed (param_values + 2),
1922 _g_cclosure_marshal_VOID__STRING_BOXEDv (GClosure *closure,
1923 GValue *return_value G_GNUC_UNUSED,
1926 gpointer marshal_data,
1930 typedef void (*GMarshalFunc_VOID__STRING_BOXED) (gpointer data1,
1934 GCClosure *cc = (GCClosure *) closure;
1935 gpointer data1, data2;
1936 GMarshalFunc_VOID__STRING_BOXED callback;
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);
1951 if (G_CCLOSURE_SWAP_DATA (closure))
1953 data1 = closure->data;
1959 data2 = closure->data;
1961 callback = (GMarshalFunc_VOID__STRING_BOXED) (marshal_data ? marshal_data : cc->callback);
1967 if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
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);
1973 /* VOID:STRING,BOXED,BOXED */
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)
1982 typedef void (*GMarshalFunc_VOID__STRING_BOXED_BOXED) (gpointer data1,
1987 GCClosure *cc = (GCClosure *) closure;
1988 gpointer data1, data2;
1989 GMarshalFunc_VOID__STRING_BOXED_BOXED callback;
1991 g_return_if_fail (n_param_values == 4);
1993 if (G_CCLOSURE_SWAP_DATA (closure))
1995 data1 = closure->data;
1996 data2 = g_value_peek_pointer (param_values + 0);
2000 data1 = g_value_peek_pointer (param_values + 0);
2001 data2 = closure->data;
2003 callback = (GMarshalFunc_VOID__STRING_BOXED_BOXED) (marshal_data ? marshal_data : cc->callback);
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),
2013 _g_cclosure_marshal_VOID__STRING_BOXED_BOXEDv (GClosure *closure,
2014 GValue *return_value G_GNUC_UNUSED,
2017 gpointer marshal_data,
2021 typedef void (*GMarshalFunc_VOID__STRING_BOXED_BOXED) (gpointer data1,
2026 GCClosure *cc = (GCClosure *) closure;
2027 gpointer data1, data2;
2028 GMarshalFunc_VOID__STRING_BOXED_BOXED callback;
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);
2047 if (G_CCLOSURE_SWAP_DATA (closure))
2049 data1 = closure->data;
2055 data2 = closure->data;
2057 callback = (GMarshalFunc_VOID__STRING_BOXED_BOXED) (marshal_data ? marshal_data : cc->callback);
2064 if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
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);
2072 /* VOID:STRING,INT64,INT64 */
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)
2081 typedef void (*GMarshalFunc_VOID__STRING_INT64_INT64) (gpointer data1,
2086 GCClosure *cc = (GCClosure *) closure;
2087 gpointer data1, data2;
2088 GMarshalFunc_VOID__STRING_INT64_INT64 callback;
2090 g_return_if_fail (n_param_values == 4);
2092 if (G_CCLOSURE_SWAP_DATA (closure))
2094 data1 = closure->data;
2095 data2 = g_value_peek_pointer (param_values + 0);
2099 data1 = g_value_peek_pointer (param_values + 0);
2100 data2 = closure->data;
2102 callback = (GMarshalFunc_VOID__STRING_INT64_INT64) (marshal_data ? marshal_data : cc->callback);
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),
2112 _g_cclosure_marshal_VOID__STRING_INT64_INT64v (GClosure *closure,
2113 GValue *return_value G_GNUC_UNUSED,
2116 gpointer marshal_data,
2120 typedef void (*GMarshalFunc_VOID__STRING_INT64_INT64) (gpointer data1,
2125 GCClosure *cc = (GCClosure *) closure;
2126 gpointer data1, data2;
2127 GMarshalFunc_VOID__STRING_INT64_INT64 callback;
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);
2142 if (G_CCLOSURE_SWAP_DATA (closure))
2144 data1 = closure->data;
2150 data2 = closure->data;
2152 callback = (GMarshalFunc_VOID__STRING_INT64_INT64) (marshal_data ? marshal_data : cc->callback);
2159 if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
2163 /* VOID:STRING,STRING,STRING,FLAGS */
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)
2172 typedef void (*GMarshalFunc_VOID__STRING_STRING_STRING_FLAGS) (gpointer data1,
2178 GCClosure *cc = (GCClosure *) closure;
2179 gpointer data1, data2;
2180 GMarshalFunc_VOID__STRING_STRING_STRING_FLAGS callback;
2182 g_return_if_fail (n_param_values == 5);
2184 if (G_CCLOSURE_SWAP_DATA (closure))
2186 data1 = closure->data;
2187 data2 = g_value_peek_pointer (param_values + 0);
2191 data1 = g_value_peek_pointer (param_values + 0);
2192 data2 = closure->data;
2194 callback = (GMarshalFunc_VOID__STRING_STRING_STRING_FLAGS) (marshal_data ? marshal_data : cc->callback);
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),
2205 _g_cclosure_marshal_VOID__STRING_STRING_STRING_FLAGSv (GClosure *closure,
2206 GValue *return_value G_GNUC_UNUSED,
2209 gpointer marshal_data,
2213 typedef void (*GMarshalFunc_VOID__STRING_STRING_STRING_FLAGS) (gpointer data1,
2219 GCClosure *cc = (GCClosure *) closure;
2220 gpointer data1, data2;
2221 GMarshalFunc_VOID__STRING_STRING_STRING_FLAGS callback;
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);
2242 if (G_CCLOSURE_SWAP_DATA (closure))
2244 data1 = closure->data;
2250 data2 = closure->data;
2252 callback = (GMarshalFunc_VOID__STRING_STRING_STRING_FLAGS) (marshal_data ? marshal_data : cc->callback);
2260 if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
2262 if ((param_types[1] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg1 != NULL)
2264 if ((param_types[2] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg2 != NULL)
2268 /* VOID:STRING,STRING,VARIANT */
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)
2277 typedef void (*GMarshalFunc_VOID__STRING_STRING_VARIANT) (gpointer data1,
2282 GCClosure *cc = (GCClosure *) closure;
2283 gpointer data1, data2;
2284 GMarshalFunc_VOID__STRING_STRING_VARIANT callback;
2286 g_return_if_fail (n_param_values == 4);
2288 if (G_CCLOSURE_SWAP_DATA (closure))
2290 data1 = closure->data;
2291 data2 = g_value_peek_pointer (param_values + 0);
2295 data1 = g_value_peek_pointer (param_values + 0);
2296 data2 = closure->data;
2298 callback = (GMarshalFunc_VOID__STRING_STRING_VARIANT) (marshal_data ? marshal_data : cc->callback);
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),
2308 _g_cclosure_marshal_VOID__STRING_STRING_VARIANTv (GClosure *closure,
2309 GValue *return_value G_GNUC_UNUSED,
2312 gpointer marshal_data,
2316 typedef void (*GMarshalFunc_VOID__STRING_STRING_VARIANT) (gpointer data1,
2321 GCClosure *cc = (GCClosure *) closure;
2322 gpointer data1, data2;
2323 GMarshalFunc_VOID__STRING_STRING_VARIANT callback;
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);
2342 if (G_CCLOSURE_SWAP_DATA (closure))
2344 data1 = closure->data;
2350 data2 = closure->data;
2352 callback = (GMarshalFunc_VOID__STRING_STRING_VARIANT) (marshal_data ? marshal_data : cc->callback);
2359 if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
2361 if ((param_types[1] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg1 != NULL)
2363 if ((param_types[2] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg2 != NULL)
2364 g_variant_unref (arg2);
2367 /* VOID:STRING,VARIANT */
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)
2376 typedef void (*GMarshalFunc_VOID__STRING_VARIANT) (gpointer data1,
2380 GCClosure *cc = (GCClosure *) closure;
2381 gpointer data1, data2;
2382 GMarshalFunc_VOID__STRING_VARIANT callback;
2384 g_return_if_fail (n_param_values == 3);
2386 if (G_CCLOSURE_SWAP_DATA (closure))
2388 data1 = closure->data;
2389 data2 = g_value_peek_pointer (param_values + 0);
2393 data1 = g_value_peek_pointer (param_values + 0);
2394 data2 = closure->data;
2396 callback = (GMarshalFunc_VOID__STRING_VARIANT) (marshal_data ? marshal_data : cc->callback);
2399 g_marshal_value_peek_string (param_values + 1),
2400 g_marshal_value_peek_variant (param_values + 2),
2405 _g_cclosure_marshal_VOID__STRING_VARIANTv (GClosure *closure,
2406 GValue *return_value G_GNUC_UNUSED,
2409 gpointer marshal_data,
2413 typedef void (*GMarshalFunc_VOID__STRING_VARIANT) (gpointer data1,
2417 GCClosure *cc = (GCClosure *) closure;
2418 gpointer data1, data2;
2419 GMarshalFunc_VOID__STRING_VARIANT callback;
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);
2434 if (G_CCLOSURE_SWAP_DATA (closure))
2436 data1 = closure->data;
2442 data2 = closure->data;
2444 callback = (GMarshalFunc_VOID__STRING_VARIANT) (marshal_data ? marshal_data : cc->callback);
2450 if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
2452 if ((param_types[1] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg1 != NULL)
2453 g_variant_unref (arg1);
2456 /* VOID:UINT,UINT,UINT */
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)
2465 typedef void (*GMarshalFunc_VOID__UINT_UINT_UINT) (gpointer data1,
2470 GCClosure *cc = (GCClosure *) closure;
2471 gpointer data1, data2;
2472 GMarshalFunc_VOID__UINT_UINT_UINT callback;
2474 g_return_if_fail (n_param_values == 4);
2476 if (G_CCLOSURE_SWAP_DATA (closure))
2478 data1 = closure->data;
2479 data2 = g_value_peek_pointer (param_values + 0);
2483 data1 = g_value_peek_pointer (param_values + 0);
2484 data2 = closure->data;
2486 callback = (GMarshalFunc_VOID__UINT_UINT_UINT) (marshal_data ? marshal_data : cc->callback);
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),
2496 _g_cclosure_marshal_VOID__UINT_UINT_UINTv (GClosure *closure,
2497 GValue *return_value G_GNUC_UNUSED,
2500 gpointer marshal_data,
2504 typedef void (*GMarshalFunc_VOID__UINT_UINT_UINT) (gpointer data1,
2509 GCClosure *cc = (GCClosure *) closure;
2510 gpointer data1, data2;
2511 GMarshalFunc_VOID__UINT_UINT_UINT callback;
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);
2524 if (G_CCLOSURE_SWAP_DATA (closure))
2526 data1 = closure->data;
2532 data2 = closure->data;
2534 callback = (GMarshalFunc_VOID__UINT_UINT_UINT) (marshal_data ? marshal_data : cc->callback);
2544 /* VOID:VARIANT,BOXED */
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)
2553 typedef void (*GMarshalFunc_VOID__VARIANT_BOXED) (gpointer data1,
2557 GCClosure *cc = (GCClosure *) closure;
2558 gpointer data1, data2;
2559 GMarshalFunc_VOID__VARIANT_BOXED callback;
2561 g_return_if_fail (n_param_values == 3);
2563 if (G_CCLOSURE_SWAP_DATA (closure))
2565 data1 = closure->data;
2566 data2 = g_value_peek_pointer (param_values + 0);
2570 data1 = g_value_peek_pointer (param_values + 0);
2571 data2 = closure->data;
2573 callback = (GMarshalFunc_VOID__VARIANT_BOXED) (marshal_data ? marshal_data : cc->callback);
2576 g_marshal_value_peek_variant (param_values + 1),
2577 g_marshal_value_peek_boxed (param_values + 2),
2582 _g_cclosure_marshal_VOID__VARIANT_BOXEDv (GClosure *closure,
2583 GValue *return_value G_GNUC_UNUSED,
2586 gpointer marshal_data,
2590 typedef void (*GMarshalFunc_VOID__VARIANT_BOXED) (gpointer data1,
2594 GCClosure *cc = (GCClosure *) closure;
2595 gpointer data1, data2;
2596 GMarshalFunc_VOID__VARIANT_BOXED callback;
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);
2611 if (G_CCLOSURE_SWAP_DATA (closure))
2613 data1 = closure->data;
2619 data2 = closure->data;
2621 callback = (GMarshalFunc_VOID__VARIANT_BOXED) (marshal_data ? marshal_data : cc->callback);
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);