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