1 #undef G_ENABLE_DEBUG
2 /* This file is generated by glib-genmarshal, do not modify it. This code is licensed under the same license as the containing project. Note that it links to GLib, so must comply with the LGPL linking clauses. */
3 #include <glib-object.h>
4
5 #ifdef G_ENABLE_DEBUG
6 #define g_marshal_value_peek_boolean(v) g_value_get_boolean (v)
7 #define g_marshal_value_peek_char(v) g_value_get_schar (v)
8 #define g_marshal_value_peek_uchar(v) g_value_get_uchar (v)
9 #define g_marshal_value_peek_int(v) g_value_get_int (v)
10 #define g_marshal_value_peek_uint(v) g_value_get_uint (v)
11 #define g_marshal_value_peek_long(v) g_value_get_long (v)
12 #define g_marshal_value_peek_ulong(v) g_value_get_ulong (v)
13 #define g_marshal_value_peek_int64(v) g_value_get_int64 (v)
14 #define g_marshal_value_peek_uint64(v) g_value_get_uint64 (v)
15 #define g_marshal_value_peek_enum(v) g_value_get_enum (v)
16 #define g_marshal_value_peek_flags(v) g_value_get_flags (v)
17 #define g_marshal_value_peek_float(v) g_value_get_float (v)
18 #define g_marshal_value_peek_double(v) g_value_get_double (v)
19 #define g_marshal_value_peek_string(v) (char*) g_value_get_string (v)
20 #define g_marshal_value_peek_param(v) g_value_get_param (v)
21 #define g_marshal_value_peek_boxed(v) g_value_get_boxed (v)
22 #define g_marshal_value_peek_pointer(v) g_value_get_pointer (v)
23 #define g_marshal_value_peek_object(v) g_value_get_object (v)
24 #define g_marshal_value_peek_variant(v) g_value_get_variant (v)
25 #else /* !G_ENABLE_DEBUG */
26 /* WARNING: This code accesses GValues directly, which is UNSUPPORTED API.
27 * Do not access GValues directly in your code. Instead, use the
28 * g_value_get_*() functions
29 */
30 #define g_marshal_value_peek_boolean(v) (v)->data[0].v_int
31 #define g_marshal_value_peek_char(v) (v)->data[0].v_int
32 #define g_marshal_value_peek_uchar(v) (v)->data[0].v_uint
33 #define g_marshal_value_peek_int(v) (v)->data[0].v_int
34 #define g_marshal_value_peek_uint(v) (v)->data[0].v_uint
35 #define g_marshal_value_peek_long(v) (v)->data[0].v_long
36 #define g_marshal_value_peek_ulong(v) (v)->data[0].v_ulong
37 #define g_marshal_value_peek_int64(v) (v)->data[0].v_int64
38 #define g_marshal_value_peek_uint64(v) (v)->data[0].v_uint64
39 #define g_marshal_value_peek_enum(v) (v)->data[0].v_long
40 #define g_marshal_value_peek_flags(v) (v)->data[0].v_ulong
41 #define g_marshal_value_peek_float(v) (v)->data[0].v_float
42 #define g_marshal_value_peek_double(v) (v)->data[0].v_double
43 #define g_marshal_value_peek_string(v) (v)->data[0].v_pointer
44 #define g_marshal_value_peek_param(v) (v)->data[0].v_pointer
45 #define g_marshal_value_peek_boxed(v) (v)->data[0].v_pointer
46 #define g_marshal_value_peek_pointer(v) (v)->data[0].v_pointer
47 #define g_marshal_value_peek_object(v) (v)->data[0].v_pointer
48 #define g_marshal_value_peek_variant(v) (v)->data[0].v_pointer
49 #endif /* !G_ENABLE_DEBUG */
50
51 /* BOOLEAN:BOXED (./gtkmarshalers.list:24) */
52 void
_gtk_marshal_BOOLEAN__BOXED(GClosure * closure,GValue * return_value,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)53 _gtk_marshal_BOOLEAN__BOXED (GClosure *closure,
54 GValue *return_value,
55 guint n_param_values,
56 const GValue *param_values,
57 gpointer invocation_hint G_GNUC_UNUSED,
58 gpointer marshal_data)
59 {
60 typedef gboolean (*GMarshalFunc_BOOLEAN__BOXED) (gpointer data1,
61 gpointer arg1,
62 gpointer data2);
63 GCClosure *cc = (GCClosure *) closure;
64 gpointer data1, data2;
65 GMarshalFunc_BOOLEAN__BOXED callback;
66 gboolean v_return;
67
68 g_return_if_fail (return_value != NULL);
69 g_return_if_fail (n_param_values == 2);
70
71 if (G_CCLOSURE_SWAP_DATA (closure))
72 {
73 data1 = closure->data;
74 data2 = g_value_peek_pointer (param_values + 0);
75 }
76 else
77 {
78 data1 = g_value_peek_pointer (param_values + 0);
79 data2 = closure->data;
80 }
81 callback = (GMarshalFunc_BOOLEAN__BOXED) (marshal_data ? marshal_data : cc->callback);
82
83 v_return = callback (data1,
84 g_marshal_value_peek_boxed (param_values + 1),
85 data2);
86
87 g_value_set_boolean (return_value, v_return);
88 }
89
90 void
_gtk_marshal_BOOLEAN__BOXEDv(GClosure * closure,GValue * return_value,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)91 _gtk_marshal_BOOLEAN__BOXEDv (GClosure *closure,
92 GValue *return_value,
93 gpointer instance,
94 va_list args,
95 gpointer marshal_data,
96 int n_params,
97 GType *param_types)
98 {
99 typedef gboolean (*GMarshalFunc_BOOLEAN__BOXED) (gpointer data1,
100 gpointer arg1,
101 gpointer data2);
102 GCClosure *cc = (GCClosure *) closure;
103 gpointer data1, data2;
104 GMarshalFunc_BOOLEAN__BOXED callback;
105 gboolean v_return;
106 gpointer arg0;
107 va_list args_copy;
108
109 G_VA_COPY (args_copy, args);
110 arg0 = (gpointer) va_arg (args_copy, gpointer);
111 if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
112 arg0 = g_boxed_copy (param_types[0] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg0);
113 va_end (args_copy);
114
115 g_return_if_fail (return_value != NULL);
116
117 if (G_CCLOSURE_SWAP_DATA (closure))
118 {
119 data1 = closure->data;
120 data2 = instance;
121 }
122 else
123 {
124 data1 = instance;
125 data2 = closure->data;
126 }
127 callback = (GMarshalFunc_BOOLEAN__BOXED) (marshal_data ? marshal_data : cc->callback);
128
129 v_return = callback (data1,
130 arg0,
131 data2);
132 if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
133 g_boxed_free (param_types[0] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg0);
134
135 g_value_set_boolean (return_value, v_return);
136 }
137
138 /* BOOLEAN:ENUM (./gtkmarshalers.list:26) */
139 void
_gtk_marshal_BOOLEAN__ENUM(GClosure * closure,GValue * return_value,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)140 _gtk_marshal_BOOLEAN__ENUM (GClosure *closure,
141 GValue *return_value,
142 guint n_param_values,
143 const GValue *param_values,
144 gpointer invocation_hint G_GNUC_UNUSED,
145 gpointer marshal_data)
146 {
147 typedef gboolean (*GMarshalFunc_BOOLEAN__ENUM) (gpointer data1,
148 gint arg1,
149 gpointer data2);
150 GCClosure *cc = (GCClosure *) closure;
151 gpointer data1, data2;
152 GMarshalFunc_BOOLEAN__ENUM callback;
153 gboolean v_return;
154
155 g_return_if_fail (return_value != NULL);
156 g_return_if_fail (n_param_values == 2);
157
158 if (G_CCLOSURE_SWAP_DATA (closure))
159 {
160 data1 = closure->data;
161 data2 = g_value_peek_pointer (param_values + 0);
162 }
163 else
164 {
165 data1 = g_value_peek_pointer (param_values + 0);
166 data2 = closure->data;
167 }
168 callback = (GMarshalFunc_BOOLEAN__ENUM) (marshal_data ? marshal_data : cc->callback);
169
170 v_return = callback (data1,
171 g_marshal_value_peek_enum (param_values + 1),
172 data2);
173
174 g_value_set_boolean (return_value, v_return);
175 }
176
177 void
_gtk_marshal_BOOLEAN__ENUMv(GClosure * closure,GValue * return_value,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)178 _gtk_marshal_BOOLEAN__ENUMv (GClosure *closure,
179 GValue *return_value,
180 gpointer instance,
181 va_list args,
182 gpointer marshal_data,
183 int n_params,
184 GType *param_types)
185 {
186 typedef gboolean (*GMarshalFunc_BOOLEAN__ENUM) (gpointer data1,
187 gint arg1,
188 gpointer data2);
189 GCClosure *cc = (GCClosure *) closure;
190 gpointer data1, data2;
191 GMarshalFunc_BOOLEAN__ENUM callback;
192 gboolean v_return;
193 gint arg0;
194 va_list args_copy;
195
196 G_VA_COPY (args_copy, args);
197 arg0 = (gint) va_arg (args_copy, gint);
198 va_end (args_copy);
199
200 g_return_if_fail (return_value != NULL);
201
202 if (G_CCLOSURE_SWAP_DATA (closure))
203 {
204 data1 = closure->data;
205 data2 = instance;
206 }
207 else
208 {
209 data1 = instance;
210 data2 = closure->data;
211 }
212 callback = (GMarshalFunc_BOOLEAN__ENUM) (marshal_data ? marshal_data : cc->callback);
213
214 v_return = callback (data1,
215 arg0,
216 data2);
217
218
219 g_value_set_boolean (return_value, v_return);
220 }
221
222 /* BOOLEAN:ENUM,BOOLEAN (./gtkmarshalers.list:27) */
223 void
_gtk_marshal_BOOLEAN__ENUM_BOOLEAN(GClosure * closure,GValue * return_value,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)224 _gtk_marshal_BOOLEAN__ENUM_BOOLEAN (GClosure *closure,
225 GValue *return_value,
226 guint n_param_values,
227 const GValue *param_values,
228 gpointer invocation_hint G_GNUC_UNUSED,
229 gpointer marshal_data)
230 {
231 typedef gboolean (*GMarshalFunc_BOOLEAN__ENUM_BOOLEAN) (gpointer data1,
232 gint arg1,
233 gboolean arg2,
234 gpointer data2);
235 GCClosure *cc = (GCClosure *) closure;
236 gpointer data1, data2;
237 GMarshalFunc_BOOLEAN__ENUM_BOOLEAN callback;
238 gboolean v_return;
239
240 g_return_if_fail (return_value != NULL);
241 g_return_if_fail (n_param_values == 3);
242
243 if (G_CCLOSURE_SWAP_DATA (closure))
244 {
245 data1 = closure->data;
246 data2 = g_value_peek_pointer (param_values + 0);
247 }
248 else
249 {
250 data1 = g_value_peek_pointer (param_values + 0);
251 data2 = closure->data;
252 }
253 callback = (GMarshalFunc_BOOLEAN__ENUM_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
254
255 v_return = callback (data1,
256 g_marshal_value_peek_enum (param_values + 1),
257 g_marshal_value_peek_boolean (param_values + 2),
258 data2);
259
260 g_value_set_boolean (return_value, v_return);
261 }
262
263 void
_gtk_marshal_BOOLEAN__ENUM_BOOLEANv(GClosure * closure,GValue * return_value,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)264 _gtk_marshal_BOOLEAN__ENUM_BOOLEANv (GClosure *closure,
265 GValue *return_value,
266 gpointer instance,
267 va_list args,
268 gpointer marshal_data,
269 int n_params,
270 GType *param_types)
271 {
272 typedef gboolean (*GMarshalFunc_BOOLEAN__ENUM_BOOLEAN) (gpointer data1,
273 gint arg1,
274 gboolean arg2,
275 gpointer data2);
276 GCClosure *cc = (GCClosure *) closure;
277 gpointer data1, data2;
278 GMarshalFunc_BOOLEAN__ENUM_BOOLEAN callback;
279 gboolean v_return;
280 gint arg0;
281 gboolean arg1;
282 va_list args_copy;
283
284 G_VA_COPY (args_copy, args);
285 arg0 = (gint) va_arg (args_copy, gint);
286 arg1 = (gboolean) va_arg (args_copy, gboolean);
287 va_end (args_copy);
288
289 g_return_if_fail (return_value != NULL);
290
291 if (G_CCLOSURE_SWAP_DATA (closure))
292 {
293 data1 = closure->data;
294 data2 = instance;
295 }
296 else
297 {
298 data1 = instance;
299 data2 = closure->data;
300 }
301 callback = (GMarshalFunc_BOOLEAN__ENUM_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
302
303 v_return = callback (data1,
304 arg0,
305 arg1,
306 data2);
307
308
309 g_value_set_boolean (return_value, v_return);
310 }
311
312 /* BOOLEAN:ENUM,BOXED,BOXED,BOXED (./gtkmarshalers.list:28) */
313 void
_gtk_marshal_BOOLEAN__ENUM_BOXED_BOXED_BOXED(GClosure * closure,GValue * return_value,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)314 _gtk_marshal_BOOLEAN__ENUM_BOXED_BOXED_BOXED (GClosure *closure,
315 GValue *return_value,
316 guint n_param_values,
317 const GValue *param_values,
318 gpointer invocation_hint G_GNUC_UNUSED,
319 gpointer marshal_data)
320 {
321 typedef gboolean (*GMarshalFunc_BOOLEAN__ENUM_BOXED_BOXED_BOXED) (gpointer data1,
322 gint arg1,
323 gpointer arg2,
324 gpointer arg3,
325 gpointer arg4,
326 gpointer data2);
327 GCClosure *cc = (GCClosure *) closure;
328 gpointer data1, data2;
329 GMarshalFunc_BOOLEAN__ENUM_BOXED_BOXED_BOXED callback;
330 gboolean v_return;
331
332 g_return_if_fail (return_value != NULL);
333 g_return_if_fail (n_param_values == 5);
334
335 if (G_CCLOSURE_SWAP_DATA (closure))
336 {
337 data1 = closure->data;
338 data2 = g_value_peek_pointer (param_values + 0);
339 }
340 else
341 {
342 data1 = g_value_peek_pointer (param_values + 0);
343 data2 = closure->data;
344 }
345 callback = (GMarshalFunc_BOOLEAN__ENUM_BOXED_BOXED_BOXED) (marshal_data ? marshal_data : cc->callback);
346
347 v_return = callback (data1,
348 g_marshal_value_peek_enum (param_values + 1),
349 g_marshal_value_peek_boxed (param_values + 2),
350 g_marshal_value_peek_boxed (param_values + 3),
351 g_marshal_value_peek_boxed (param_values + 4),
352 data2);
353
354 g_value_set_boolean (return_value, v_return);
355 }
356
357 void
_gtk_marshal_BOOLEAN__ENUM_BOXED_BOXED_BOXEDv(GClosure * closure,GValue * return_value,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)358 _gtk_marshal_BOOLEAN__ENUM_BOXED_BOXED_BOXEDv (GClosure *closure,
359 GValue *return_value,
360 gpointer instance,
361 va_list args,
362 gpointer marshal_data,
363 int n_params,
364 GType *param_types)
365 {
366 typedef gboolean (*GMarshalFunc_BOOLEAN__ENUM_BOXED_BOXED_BOXED) (gpointer data1,
367 gint arg1,
368 gpointer arg2,
369 gpointer arg3,
370 gpointer arg4,
371 gpointer data2);
372 GCClosure *cc = (GCClosure *) closure;
373 gpointer data1, data2;
374 GMarshalFunc_BOOLEAN__ENUM_BOXED_BOXED_BOXED callback;
375 gboolean v_return;
376 gint arg0;
377 gpointer arg1;
378 gpointer arg2;
379 gpointer arg3;
380 va_list args_copy;
381
382 G_VA_COPY (args_copy, args);
383 arg0 = (gint) va_arg (args_copy, gint);
384 arg1 = (gpointer) va_arg (args_copy, gpointer);
385 if ((param_types[1] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg1 != NULL)
386 arg1 = g_boxed_copy (param_types[1] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg1);
387 arg2 = (gpointer) va_arg (args_copy, gpointer);
388 if ((param_types[2] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg2 != NULL)
389 arg2 = g_boxed_copy (param_types[2] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg2);
390 arg3 = (gpointer) va_arg (args_copy, gpointer);
391 if ((param_types[3] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg3 != NULL)
392 arg3 = g_boxed_copy (param_types[3] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg3);
393 va_end (args_copy);
394
395 g_return_if_fail (return_value != NULL);
396
397 if (G_CCLOSURE_SWAP_DATA (closure))
398 {
399 data1 = closure->data;
400 data2 = instance;
401 }
402 else
403 {
404 data1 = instance;
405 data2 = closure->data;
406 }
407 callback = (GMarshalFunc_BOOLEAN__ENUM_BOXED_BOXED_BOXED) (marshal_data ? marshal_data : cc->callback);
408
409 v_return = callback (data1,
410 arg0,
411 arg1,
412 arg2,
413 arg3,
414 data2);
415 if ((param_types[1] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg1 != NULL)
416 g_boxed_free (param_types[1] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg1);
417 if ((param_types[2] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg2 != NULL)
418 g_boxed_free (param_types[2] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg2);
419 if ((param_types[3] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg3 != NULL)
420 g_boxed_free (param_types[3] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg3);
421
422 g_value_set_boolean (return_value, v_return);
423 }
424
425 /* BOOLEAN:ENUM,DOUBLE (./gtkmarshalers.list:29) */
426 void
_gtk_marshal_BOOLEAN__ENUM_DOUBLE(GClosure * closure,GValue * return_value,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)427 _gtk_marshal_BOOLEAN__ENUM_DOUBLE (GClosure *closure,
428 GValue *return_value,
429 guint n_param_values,
430 const GValue *param_values,
431 gpointer invocation_hint G_GNUC_UNUSED,
432 gpointer marshal_data)
433 {
434 typedef gboolean (*GMarshalFunc_BOOLEAN__ENUM_DOUBLE) (gpointer data1,
435 gint arg1,
436 gdouble arg2,
437 gpointer data2);
438 GCClosure *cc = (GCClosure *) closure;
439 gpointer data1, data2;
440 GMarshalFunc_BOOLEAN__ENUM_DOUBLE callback;
441 gboolean v_return;
442
443 g_return_if_fail (return_value != NULL);
444 g_return_if_fail (n_param_values == 3);
445
446 if (G_CCLOSURE_SWAP_DATA (closure))
447 {
448 data1 = closure->data;
449 data2 = g_value_peek_pointer (param_values + 0);
450 }
451 else
452 {
453 data1 = g_value_peek_pointer (param_values + 0);
454 data2 = closure->data;
455 }
456 callback = (GMarshalFunc_BOOLEAN__ENUM_DOUBLE) (marshal_data ? marshal_data : cc->callback);
457
458 v_return = callback (data1,
459 g_marshal_value_peek_enum (param_values + 1),
460 g_marshal_value_peek_double (param_values + 2),
461 data2);
462
463 g_value_set_boolean (return_value, v_return);
464 }
465
466 void
_gtk_marshal_BOOLEAN__ENUM_DOUBLEv(GClosure * closure,GValue * return_value,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)467 _gtk_marshal_BOOLEAN__ENUM_DOUBLEv (GClosure *closure,
468 GValue *return_value,
469 gpointer instance,
470 va_list args,
471 gpointer marshal_data,
472 int n_params,
473 GType *param_types)
474 {
475 typedef gboolean (*GMarshalFunc_BOOLEAN__ENUM_DOUBLE) (gpointer data1,
476 gint arg1,
477 gdouble arg2,
478 gpointer data2);
479 GCClosure *cc = (GCClosure *) closure;
480 gpointer data1, data2;
481 GMarshalFunc_BOOLEAN__ENUM_DOUBLE callback;
482 gboolean v_return;
483 gint arg0;
484 gdouble arg1;
485 va_list args_copy;
486
487 G_VA_COPY (args_copy, args);
488 arg0 = (gint) va_arg (args_copy, gint);
489 arg1 = (gdouble) va_arg (args_copy, gdouble);
490 va_end (args_copy);
491
492 g_return_if_fail (return_value != NULL);
493
494 if (G_CCLOSURE_SWAP_DATA (closure))
495 {
496 data1 = closure->data;
497 data2 = instance;
498 }
499 else
500 {
501 data1 = instance;
502 data2 = closure->data;
503 }
504 callback = (GMarshalFunc_BOOLEAN__ENUM_DOUBLE) (marshal_data ? marshal_data : cc->callback);
505
506 v_return = callback (data1,
507 arg0,
508 arg1,
509 data2);
510
511
512 g_value_set_boolean (return_value, v_return);
513 }
514
515 /* BOOLEAN:ENUM,INT (./gtkmarshalers.list:30) */
516 void
_gtk_marshal_BOOLEAN__ENUM_INT(GClosure * closure,GValue * return_value,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)517 _gtk_marshal_BOOLEAN__ENUM_INT (GClosure *closure,
518 GValue *return_value,
519 guint n_param_values,
520 const GValue *param_values,
521 gpointer invocation_hint G_GNUC_UNUSED,
522 gpointer marshal_data)
523 {
524 typedef gboolean (*GMarshalFunc_BOOLEAN__ENUM_INT) (gpointer data1,
525 gint arg1,
526 gint arg2,
527 gpointer data2);
528 GCClosure *cc = (GCClosure *) closure;
529 gpointer data1, data2;
530 GMarshalFunc_BOOLEAN__ENUM_INT callback;
531 gboolean v_return;
532
533 g_return_if_fail (return_value != NULL);
534 g_return_if_fail (n_param_values == 3);
535
536 if (G_CCLOSURE_SWAP_DATA (closure))
537 {
538 data1 = closure->data;
539 data2 = g_value_peek_pointer (param_values + 0);
540 }
541 else
542 {
543 data1 = g_value_peek_pointer (param_values + 0);
544 data2 = closure->data;
545 }
546 callback = (GMarshalFunc_BOOLEAN__ENUM_INT) (marshal_data ? marshal_data : cc->callback);
547
548 v_return = callback (data1,
549 g_marshal_value_peek_enum (param_values + 1),
550 g_marshal_value_peek_int (param_values + 2),
551 data2);
552
553 g_value_set_boolean (return_value, v_return);
554 }
555
556 void
_gtk_marshal_BOOLEAN__ENUM_INTv(GClosure * closure,GValue * return_value,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)557 _gtk_marshal_BOOLEAN__ENUM_INTv (GClosure *closure,
558 GValue *return_value,
559 gpointer instance,
560 va_list args,
561 gpointer marshal_data,
562 int n_params,
563 GType *param_types)
564 {
565 typedef gboolean (*GMarshalFunc_BOOLEAN__ENUM_INT) (gpointer data1,
566 gint arg1,
567 gint arg2,
568 gpointer data2);
569 GCClosure *cc = (GCClosure *) closure;
570 gpointer data1, data2;
571 GMarshalFunc_BOOLEAN__ENUM_INT callback;
572 gboolean v_return;
573 gint arg0;
574 gint arg1;
575 va_list args_copy;
576
577 G_VA_COPY (args_copy, args);
578 arg0 = (gint) va_arg (args_copy, gint);
579 arg1 = (gint) va_arg (args_copy, gint);
580 va_end (args_copy);
581
582 g_return_if_fail (return_value != NULL);
583
584 if (G_CCLOSURE_SWAP_DATA (closure))
585 {
586 data1 = closure->data;
587 data2 = instance;
588 }
589 else
590 {
591 data1 = instance;
592 data2 = closure->data;
593 }
594 callback = (GMarshalFunc_BOOLEAN__ENUM_INT) (marshal_data ? marshal_data : cc->callback);
595
596 v_return = callback (data1,
597 arg0,
598 arg1,
599 data2);
600
601
602 g_value_set_boolean (return_value, v_return);
603 }
604
605 /* BOOLEAN:OBJECT (./gtkmarshalers.list:32) */
606 void
_gtk_marshal_BOOLEAN__OBJECT(GClosure * closure,GValue * return_value,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)607 _gtk_marshal_BOOLEAN__OBJECT (GClosure *closure,
608 GValue *return_value,
609 guint n_param_values,
610 const GValue *param_values,
611 gpointer invocation_hint G_GNUC_UNUSED,
612 gpointer marshal_data)
613 {
614 typedef gboolean (*GMarshalFunc_BOOLEAN__OBJECT) (gpointer data1,
615 gpointer arg1,
616 gpointer data2);
617 GCClosure *cc = (GCClosure *) closure;
618 gpointer data1, data2;
619 GMarshalFunc_BOOLEAN__OBJECT callback;
620 gboolean v_return;
621
622 g_return_if_fail (return_value != NULL);
623 g_return_if_fail (n_param_values == 2);
624
625 if (G_CCLOSURE_SWAP_DATA (closure))
626 {
627 data1 = closure->data;
628 data2 = g_value_peek_pointer (param_values + 0);
629 }
630 else
631 {
632 data1 = g_value_peek_pointer (param_values + 0);
633 data2 = closure->data;
634 }
635 callback = (GMarshalFunc_BOOLEAN__OBJECT) (marshal_data ? marshal_data : cc->callback);
636
637 v_return = callback (data1,
638 g_marshal_value_peek_object (param_values + 1),
639 data2);
640
641 g_value_set_boolean (return_value, v_return);
642 }
643
644 void
_gtk_marshal_BOOLEAN__OBJECTv(GClosure * closure,GValue * return_value,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)645 _gtk_marshal_BOOLEAN__OBJECTv (GClosure *closure,
646 GValue *return_value,
647 gpointer instance,
648 va_list args,
649 gpointer marshal_data,
650 int n_params,
651 GType *param_types)
652 {
653 typedef gboolean (*GMarshalFunc_BOOLEAN__OBJECT) (gpointer data1,
654 gpointer arg1,
655 gpointer data2);
656 GCClosure *cc = (GCClosure *) closure;
657 gpointer data1, data2;
658 GMarshalFunc_BOOLEAN__OBJECT callback;
659 gboolean v_return;
660 gpointer arg0;
661 va_list args_copy;
662
663 G_VA_COPY (args_copy, args);
664 arg0 = (gpointer) va_arg (args_copy, gpointer);
665 if (arg0 != NULL)
666 arg0 = g_object_ref (arg0);
667 va_end (args_copy);
668
669 g_return_if_fail (return_value != NULL);
670
671 if (G_CCLOSURE_SWAP_DATA (closure))
672 {
673 data1 = closure->data;
674 data2 = instance;
675 }
676 else
677 {
678 data1 = instance;
679 data2 = closure->data;
680 }
681 callback = (GMarshalFunc_BOOLEAN__OBJECT) (marshal_data ? marshal_data : cc->callback);
682
683 v_return = callback (data1,
684 arg0,
685 data2);
686 if (arg0 != NULL)
687 g_object_unref (arg0);
688
689 g_value_set_boolean (return_value, v_return);
690 }
691
692 /* BOOLEAN:OBJECT,UINT,FLAGS (./gtkmarshalers.list:33) */
693 void
_gtk_marshal_BOOLEAN__OBJECT_UINT_FLAGS(GClosure * closure,GValue * return_value,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)694 _gtk_marshal_BOOLEAN__OBJECT_UINT_FLAGS (GClosure *closure,
695 GValue *return_value,
696 guint n_param_values,
697 const GValue *param_values,
698 gpointer invocation_hint G_GNUC_UNUSED,
699 gpointer marshal_data)
700 {
701 typedef gboolean (*GMarshalFunc_BOOLEAN__OBJECT_UINT_FLAGS) (gpointer data1,
702 gpointer arg1,
703 guint arg2,
704 guint arg3,
705 gpointer data2);
706 GCClosure *cc = (GCClosure *) closure;
707 gpointer data1, data2;
708 GMarshalFunc_BOOLEAN__OBJECT_UINT_FLAGS callback;
709 gboolean v_return;
710
711 g_return_if_fail (return_value != NULL);
712 g_return_if_fail (n_param_values == 4);
713
714 if (G_CCLOSURE_SWAP_DATA (closure))
715 {
716 data1 = closure->data;
717 data2 = g_value_peek_pointer (param_values + 0);
718 }
719 else
720 {
721 data1 = g_value_peek_pointer (param_values + 0);
722 data2 = closure->data;
723 }
724 callback = (GMarshalFunc_BOOLEAN__OBJECT_UINT_FLAGS) (marshal_data ? marshal_data : cc->callback);
725
726 v_return = callback (data1,
727 g_marshal_value_peek_object (param_values + 1),
728 g_marshal_value_peek_uint (param_values + 2),
729 g_marshal_value_peek_flags (param_values + 3),
730 data2);
731
732 g_value_set_boolean (return_value, v_return);
733 }
734
735 void
_gtk_marshal_BOOLEAN__OBJECT_UINT_FLAGSv(GClosure * closure,GValue * return_value,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)736 _gtk_marshal_BOOLEAN__OBJECT_UINT_FLAGSv (GClosure *closure,
737 GValue *return_value,
738 gpointer instance,
739 va_list args,
740 gpointer marshal_data,
741 int n_params,
742 GType *param_types)
743 {
744 typedef gboolean (*GMarshalFunc_BOOLEAN__OBJECT_UINT_FLAGS) (gpointer data1,
745 gpointer arg1,
746 guint arg2,
747 guint arg3,
748 gpointer data2);
749 GCClosure *cc = (GCClosure *) closure;
750 gpointer data1, data2;
751 GMarshalFunc_BOOLEAN__OBJECT_UINT_FLAGS callback;
752 gboolean v_return;
753 gpointer arg0;
754 guint arg1;
755 guint arg2;
756 va_list args_copy;
757
758 G_VA_COPY (args_copy, args);
759 arg0 = (gpointer) va_arg (args_copy, gpointer);
760 if (arg0 != NULL)
761 arg0 = g_object_ref (arg0);
762 arg1 = (guint) va_arg (args_copy, guint);
763 arg2 = (guint) va_arg (args_copy, guint);
764 va_end (args_copy);
765
766 g_return_if_fail (return_value != NULL);
767
768 if (G_CCLOSURE_SWAP_DATA (closure))
769 {
770 data1 = closure->data;
771 data2 = instance;
772 }
773 else
774 {
775 data1 = instance;
776 data2 = closure->data;
777 }
778 callback = (GMarshalFunc_BOOLEAN__OBJECT_UINT_FLAGS) (marshal_data ? marshal_data : cc->callback);
779
780 v_return = callback (data1,
781 arg0,
782 arg1,
783 arg2,
784 data2);
785 if (arg0 != NULL)
786 g_object_unref (arg0);
787
788 g_value_set_boolean (return_value, v_return);
789 }
790
791 /* BOOLEAN:OBJECT,INT,INT,UINT (./gtkmarshalers.list:34) */
792 void
_gtk_marshal_BOOLEAN__OBJECT_INT_INT_UINT(GClosure * closure,GValue * return_value,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)793 _gtk_marshal_BOOLEAN__OBJECT_INT_INT_UINT (GClosure *closure,
794 GValue *return_value,
795 guint n_param_values,
796 const GValue *param_values,
797 gpointer invocation_hint G_GNUC_UNUSED,
798 gpointer marshal_data)
799 {
800 typedef gboolean (*GMarshalFunc_BOOLEAN__OBJECT_INT_INT_UINT) (gpointer data1,
801 gpointer arg1,
802 gint arg2,
803 gint arg3,
804 guint arg4,
805 gpointer data2);
806 GCClosure *cc = (GCClosure *) closure;
807 gpointer data1, data2;
808 GMarshalFunc_BOOLEAN__OBJECT_INT_INT_UINT callback;
809 gboolean v_return;
810
811 g_return_if_fail (return_value != NULL);
812 g_return_if_fail (n_param_values == 5);
813
814 if (G_CCLOSURE_SWAP_DATA (closure))
815 {
816 data1 = closure->data;
817 data2 = g_value_peek_pointer (param_values + 0);
818 }
819 else
820 {
821 data1 = g_value_peek_pointer (param_values + 0);
822 data2 = closure->data;
823 }
824 callback = (GMarshalFunc_BOOLEAN__OBJECT_INT_INT_UINT) (marshal_data ? marshal_data : cc->callback);
825
826 v_return = callback (data1,
827 g_marshal_value_peek_object (param_values + 1),
828 g_marshal_value_peek_int (param_values + 2),
829 g_marshal_value_peek_int (param_values + 3),
830 g_marshal_value_peek_uint (param_values + 4),
831 data2);
832
833 g_value_set_boolean (return_value, v_return);
834 }
835
836 void
_gtk_marshal_BOOLEAN__OBJECT_INT_INT_UINTv(GClosure * closure,GValue * return_value,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)837 _gtk_marshal_BOOLEAN__OBJECT_INT_INT_UINTv (GClosure *closure,
838 GValue *return_value,
839 gpointer instance,
840 va_list args,
841 gpointer marshal_data,
842 int n_params,
843 GType *param_types)
844 {
845 typedef gboolean (*GMarshalFunc_BOOLEAN__OBJECT_INT_INT_UINT) (gpointer data1,
846 gpointer arg1,
847 gint arg2,
848 gint arg3,
849 guint arg4,
850 gpointer data2);
851 GCClosure *cc = (GCClosure *) closure;
852 gpointer data1, data2;
853 GMarshalFunc_BOOLEAN__OBJECT_INT_INT_UINT callback;
854 gboolean v_return;
855 gpointer arg0;
856 gint arg1;
857 gint arg2;
858 guint arg3;
859 va_list args_copy;
860
861 G_VA_COPY (args_copy, args);
862 arg0 = (gpointer) va_arg (args_copy, gpointer);
863 if (arg0 != NULL)
864 arg0 = g_object_ref (arg0);
865 arg1 = (gint) va_arg (args_copy, gint);
866 arg2 = (gint) va_arg (args_copy, gint);
867 arg3 = (guint) va_arg (args_copy, guint);
868 va_end (args_copy);
869
870 g_return_if_fail (return_value != NULL);
871
872 if (G_CCLOSURE_SWAP_DATA (closure))
873 {
874 data1 = closure->data;
875 data2 = instance;
876 }
877 else
878 {
879 data1 = instance;
880 data2 = closure->data;
881 }
882 callback = (GMarshalFunc_BOOLEAN__OBJECT_INT_INT_UINT) (marshal_data ? marshal_data : cc->callback);
883
884 v_return = callback (data1,
885 arg0,
886 arg1,
887 arg2,
888 arg3,
889 data2);
890 if (arg0 != NULL)
891 g_object_unref (arg0);
892
893 g_value_set_boolean (return_value, v_return);
894 }
895
896 /* BOOLEAN:OBJECT,STRING,STRING,BOXED (./gtkmarshalers.list:35) */
897 void
_gtk_marshal_BOOLEAN__OBJECT_STRING_STRING_BOXED(GClosure * closure,GValue * return_value,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)898 _gtk_marshal_BOOLEAN__OBJECT_STRING_STRING_BOXED (GClosure *closure,
899 GValue *return_value,
900 guint n_param_values,
901 const GValue *param_values,
902 gpointer invocation_hint G_GNUC_UNUSED,
903 gpointer marshal_data)
904 {
905 typedef gboolean (*GMarshalFunc_BOOLEAN__OBJECT_STRING_STRING_BOXED) (gpointer data1,
906 gpointer arg1,
907 gpointer arg2,
908 gpointer arg3,
909 gpointer arg4,
910 gpointer data2);
911 GCClosure *cc = (GCClosure *) closure;
912 gpointer data1, data2;
913 GMarshalFunc_BOOLEAN__OBJECT_STRING_STRING_BOXED callback;
914 gboolean v_return;
915
916 g_return_if_fail (return_value != NULL);
917 g_return_if_fail (n_param_values == 5);
918
919 if (G_CCLOSURE_SWAP_DATA (closure))
920 {
921 data1 = closure->data;
922 data2 = g_value_peek_pointer (param_values + 0);
923 }
924 else
925 {
926 data1 = g_value_peek_pointer (param_values + 0);
927 data2 = closure->data;
928 }
929 callback = (GMarshalFunc_BOOLEAN__OBJECT_STRING_STRING_BOXED) (marshal_data ? marshal_data : cc->callback);
930
931 v_return = callback (data1,
932 g_marshal_value_peek_object (param_values + 1),
933 g_marshal_value_peek_string (param_values + 2),
934 g_marshal_value_peek_string (param_values + 3),
935 g_marshal_value_peek_boxed (param_values + 4),
936 data2);
937
938 g_value_set_boolean (return_value, v_return);
939 }
940
941 void
_gtk_marshal_BOOLEAN__OBJECT_STRING_STRING_BOXEDv(GClosure * closure,GValue * return_value,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)942 _gtk_marshal_BOOLEAN__OBJECT_STRING_STRING_BOXEDv (GClosure *closure,
943 GValue *return_value,
944 gpointer instance,
945 va_list args,
946 gpointer marshal_data,
947 int n_params,
948 GType *param_types)
949 {
950 typedef gboolean (*GMarshalFunc_BOOLEAN__OBJECT_STRING_STRING_BOXED) (gpointer data1,
951 gpointer arg1,
952 gpointer arg2,
953 gpointer arg3,
954 gpointer arg4,
955 gpointer data2);
956 GCClosure *cc = (GCClosure *) closure;
957 gpointer data1, data2;
958 GMarshalFunc_BOOLEAN__OBJECT_STRING_STRING_BOXED callback;
959 gboolean v_return;
960 gpointer arg0;
961 gpointer arg1;
962 gpointer arg2;
963 gpointer arg3;
964 va_list args_copy;
965
966 G_VA_COPY (args_copy, args);
967 arg0 = (gpointer) va_arg (args_copy, gpointer);
968 if (arg0 != NULL)
969 arg0 = g_object_ref (arg0);
970 arg1 = (gpointer) va_arg (args_copy, gpointer);
971 if ((param_types[1] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg1 != NULL)
972 arg1 = g_strdup (arg1);
973 arg2 = (gpointer) va_arg (args_copy, gpointer);
974 if ((param_types[2] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg2 != NULL)
975 arg2 = g_strdup (arg2);
976 arg3 = (gpointer) va_arg (args_copy, gpointer);
977 if ((param_types[3] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg3 != NULL)
978 arg3 = g_boxed_copy (param_types[3] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg3);
979 va_end (args_copy);
980
981 g_return_if_fail (return_value != NULL);
982
983 if (G_CCLOSURE_SWAP_DATA (closure))
984 {
985 data1 = closure->data;
986 data2 = instance;
987 }
988 else
989 {
990 data1 = instance;
991 data2 = closure->data;
992 }
993 callback = (GMarshalFunc_BOOLEAN__OBJECT_STRING_STRING_BOXED) (marshal_data ? marshal_data : cc->callback);
994
995 v_return = callback (data1,
996 arg0,
997 arg1,
998 arg2,
999 arg3,
1000 data2);
1001 if (arg0 != NULL)
1002 g_object_unref (arg0);
1003 if ((param_types[1] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg1 != NULL)
1004 g_free (arg1);
1005 if ((param_types[2] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg2 != NULL)
1006 g_free (arg2);
1007 if ((param_types[3] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg3 != NULL)
1008 g_boxed_free (param_types[3] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg3);
1009
1010 g_value_set_boolean (return_value, v_return);
1011 }
1012
1013 /* BOOLEAN:OBJECT,BOXED (./gtkmarshalers.list:36) */
1014 void
_gtk_marshal_BOOLEAN__OBJECT_BOXED(GClosure * closure,GValue * return_value,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)1015 _gtk_marshal_BOOLEAN__OBJECT_BOXED (GClosure *closure,
1016 GValue *return_value,
1017 guint n_param_values,
1018 const GValue *param_values,
1019 gpointer invocation_hint G_GNUC_UNUSED,
1020 gpointer marshal_data)
1021 {
1022 typedef gboolean (*GMarshalFunc_BOOLEAN__OBJECT_BOXED) (gpointer data1,
1023 gpointer arg1,
1024 gpointer arg2,
1025 gpointer data2);
1026 GCClosure *cc = (GCClosure *) closure;
1027 gpointer data1, data2;
1028 GMarshalFunc_BOOLEAN__OBJECT_BOXED callback;
1029 gboolean v_return;
1030
1031 g_return_if_fail (return_value != NULL);
1032 g_return_if_fail (n_param_values == 3);
1033
1034 if (G_CCLOSURE_SWAP_DATA (closure))
1035 {
1036 data1 = closure->data;
1037 data2 = g_value_peek_pointer (param_values + 0);
1038 }
1039 else
1040 {
1041 data1 = g_value_peek_pointer (param_values + 0);
1042 data2 = closure->data;
1043 }
1044 callback = (GMarshalFunc_BOOLEAN__OBJECT_BOXED) (marshal_data ? marshal_data : cc->callback);
1045
1046 v_return = callback (data1,
1047 g_marshal_value_peek_object (param_values + 1),
1048 g_marshal_value_peek_boxed (param_values + 2),
1049 data2);
1050
1051 g_value_set_boolean (return_value, v_return);
1052 }
1053
1054 void
_gtk_marshal_BOOLEAN__OBJECT_BOXEDv(GClosure * closure,GValue * return_value,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)1055 _gtk_marshal_BOOLEAN__OBJECT_BOXEDv (GClosure *closure,
1056 GValue *return_value,
1057 gpointer instance,
1058 va_list args,
1059 gpointer marshal_data,
1060 int n_params,
1061 GType *param_types)
1062 {
1063 typedef gboolean (*GMarshalFunc_BOOLEAN__OBJECT_BOXED) (gpointer data1,
1064 gpointer arg1,
1065 gpointer arg2,
1066 gpointer data2);
1067 GCClosure *cc = (GCClosure *) closure;
1068 gpointer data1, data2;
1069 GMarshalFunc_BOOLEAN__OBJECT_BOXED callback;
1070 gboolean v_return;
1071 gpointer arg0;
1072 gpointer arg1;
1073 va_list args_copy;
1074
1075 G_VA_COPY (args_copy, args);
1076 arg0 = (gpointer) va_arg (args_copy, gpointer);
1077 if (arg0 != NULL)
1078 arg0 = g_object_ref (arg0);
1079 arg1 = (gpointer) va_arg (args_copy, gpointer);
1080 if ((param_types[1] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg1 != NULL)
1081 arg1 = g_boxed_copy (param_types[1] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg1);
1082 va_end (args_copy);
1083
1084 g_return_if_fail (return_value != NULL);
1085
1086 if (G_CCLOSURE_SWAP_DATA (closure))
1087 {
1088 data1 = closure->data;
1089 data2 = instance;
1090 }
1091 else
1092 {
1093 data1 = instance;
1094 data2 = closure->data;
1095 }
1096 callback = (GMarshalFunc_BOOLEAN__OBJECT_BOXED) (marshal_data ? marshal_data : cc->callback);
1097
1098 v_return = callback (data1,
1099 arg0,
1100 arg1,
1101 data2);
1102 if (arg0 != NULL)
1103 g_object_unref (arg0);
1104 if ((param_types[1] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg1 != NULL)
1105 g_boxed_free (param_types[1] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg1);
1106
1107 g_value_set_boolean (return_value, v_return);
1108 }
1109
1110 /* BOOLEAN:OBJECT,BOXED,BOXED (./gtkmarshalers.list:37) */
1111 void
_gtk_marshal_BOOLEAN__OBJECT_BOXED_BOXED(GClosure * closure,GValue * return_value,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)1112 _gtk_marshal_BOOLEAN__OBJECT_BOXED_BOXED (GClosure *closure,
1113 GValue *return_value,
1114 guint n_param_values,
1115 const GValue *param_values,
1116 gpointer invocation_hint G_GNUC_UNUSED,
1117 gpointer marshal_data)
1118 {
1119 typedef gboolean (*GMarshalFunc_BOOLEAN__OBJECT_BOXED_BOXED) (gpointer data1,
1120 gpointer arg1,
1121 gpointer arg2,
1122 gpointer arg3,
1123 gpointer data2);
1124 GCClosure *cc = (GCClosure *) closure;
1125 gpointer data1, data2;
1126 GMarshalFunc_BOOLEAN__OBJECT_BOXED_BOXED callback;
1127 gboolean v_return;
1128
1129 g_return_if_fail (return_value != NULL);
1130 g_return_if_fail (n_param_values == 4);
1131
1132 if (G_CCLOSURE_SWAP_DATA (closure))
1133 {
1134 data1 = closure->data;
1135 data2 = g_value_peek_pointer (param_values + 0);
1136 }
1137 else
1138 {
1139 data1 = g_value_peek_pointer (param_values + 0);
1140 data2 = closure->data;
1141 }
1142 callback = (GMarshalFunc_BOOLEAN__OBJECT_BOXED_BOXED) (marshal_data ? marshal_data : cc->callback);
1143
1144 v_return = callback (data1,
1145 g_marshal_value_peek_object (param_values + 1),
1146 g_marshal_value_peek_boxed (param_values + 2),
1147 g_marshal_value_peek_boxed (param_values + 3),
1148 data2);
1149
1150 g_value_set_boolean (return_value, v_return);
1151 }
1152
1153 void
_gtk_marshal_BOOLEAN__OBJECT_BOXED_BOXEDv(GClosure * closure,GValue * return_value,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)1154 _gtk_marshal_BOOLEAN__OBJECT_BOXED_BOXEDv (GClosure *closure,
1155 GValue *return_value,
1156 gpointer instance,
1157 va_list args,
1158 gpointer marshal_data,
1159 int n_params,
1160 GType *param_types)
1161 {
1162 typedef gboolean (*GMarshalFunc_BOOLEAN__OBJECT_BOXED_BOXED) (gpointer data1,
1163 gpointer arg1,
1164 gpointer arg2,
1165 gpointer arg3,
1166 gpointer data2);
1167 GCClosure *cc = (GCClosure *) closure;
1168 gpointer data1, data2;
1169 GMarshalFunc_BOOLEAN__OBJECT_BOXED_BOXED callback;
1170 gboolean v_return;
1171 gpointer arg0;
1172 gpointer arg1;
1173 gpointer arg2;
1174 va_list args_copy;
1175
1176 G_VA_COPY (args_copy, args);
1177 arg0 = (gpointer) va_arg (args_copy, gpointer);
1178 if (arg0 != NULL)
1179 arg0 = g_object_ref (arg0);
1180 arg1 = (gpointer) va_arg (args_copy, gpointer);
1181 if ((param_types[1] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg1 != NULL)
1182 arg1 = g_boxed_copy (param_types[1] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg1);
1183 arg2 = (gpointer) va_arg (args_copy, gpointer);
1184 if ((param_types[2] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg2 != NULL)
1185 arg2 = g_boxed_copy (param_types[2] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg2);
1186 va_end (args_copy);
1187
1188 g_return_if_fail (return_value != NULL);
1189
1190 if (G_CCLOSURE_SWAP_DATA (closure))
1191 {
1192 data1 = closure->data;
1193 data2 = instance;
1194 }
1195 else
1196 {
1197 data1 = instance;
1198 data2 = closure->data;
1199 }
1200 callback = (GMarshalFunc_BOOLEAN__OBJECT_BOXED_BOXED) (marshal_data ? marshal_data : cc->callback);
1201
1202 v_return = callback (data1,
1203 arg0,
1204 arg1,
1205 arg2,
1206 data2);
1207 if (arg0 != NULL)
1208 g_object_unref (arg0);
1209 if ((param_types[1] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg1 != NULL)
1210 g_boxed_free (param_types[1] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg1);
1211 if ((param_types[2] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg2 != NULL)
1212 g_boxed_free (param_types[2] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg2);
1213
1214 g_value_set_boolean (return_value, v_return);
1215 }
1216
1217 /* BOOLEAN:OBJECT,OBJECT,OBJECT (./gtkmarshalers.list:38) */
1218 void
_gtk_marshal_BOOLEAN__OBJECT_OBJECT_OBJECT(GClosure * closure,GValue * return_value,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)1219 _gtk_marshal_BOOLEAN__OBJECT_OBJECT_OBJECT (GClosure *closure,
1220 GValue *return_value,
1221 guint n_param_values,
1222 const GValue *param_values,
1223 gpointer invocation_hint G_GNUC_UNUSED,
1224 gpointer marshal_data)
1225 {
1226 typedef gboolean (*GMarshalFunc_BOOLEAN__OBJECT_OBJECT_OBJECT) (gpointer data1,
1227 gpointer arg1,
1228 gpointer arg2,
1229 gpointer arg3,
1230 gpointer data2);
1231 GCClosure *cc = (GCClosure *) closure;
1232 gpointer data1, data2;
1233 GMarshalFunc_BOOLEAN__OBJECT_OBJECT_OBJECT callback;
1234 gboolean v_return;
1235
1236 g_return_if_fail (return_value != NULL);
1237 g_return_if_fail (n_param_values == 4);
1238
1239 if (G_CCLOSURE_SWAP_DATA (closure))
1240 {
1241 data1 = closure->data;
1242 data2 = g_value_peek_pointer (param_values + 0);
1243 }
1244 else
1245 {
1246 data1 = g_value_peek_pointer (param_values + 0);
1247 data2 = closure->data;
1248 }
1249 callback = (GMarshalFunc_BOOLEAN__OBJECT_OBJECT_OBJECT) (marshal_data ? marshal_data : cc->callback);
1250
1251 v_return = callback (data1,
1252 g_marshal_value_peek_object (param_values + 1),
1253 g_marshal_value_peek_object (param_values + 2),
1254 g_marshal_value_peek_object (param_values + 3),
1255 data2);
1256
1257 g_value_set_boolean (return_value, v_return);
1258 }
1259
1260 void
_gtk_marshal_BOOLEAN__OBJECT_OBJECT_OBJECTv(GClosure * closure,GValue * return_value,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)1261 _gtk_marshal_BOOLEAN__OBJECT_OBJECT_OBJECTv (GClosure *closure,
1262 GValue *return_value,
1263 gpointer instance,
1264 va_list args,
1265 gpointer marshal_data,
1266 int n_params,
1267 GType *param_types)
1268 {
1269 typedef gboolean (*GMarshalFunc_BOOLEAN__OBJECT_OBJECT_OBJECT) (gpointer data1,
1270 gpointer arg1,
1271 gpointer arg2,
1272 gpointer arg3,
1273 gpointer data2);
1274 GCClosure *cc = (GCClosure *) closure;
1275 gpointer data1, data2;
1276 GMarshalFunc_BOOLEAN__OBJECT_OBJECT_OBJECT callback;
1277 gboolean v_return;
1278 gpointer arg0;
1279 gpointer arg1;
1280 gpointer arg2;
1281 va_list args_copy;
1282
1283 G_VA_COPY (args_copy, args);
1284 arg0 = (gpointer) va_arg (args_copy, gpointer);
1285 if (arg0 != NULL)
1286 arg0 = g_object_ref (arg0);
1287 arg1 = (gpointer) va_arg (args_copy, gpointer);
1288 if (arg1 != NULL)
1289 arg1 = g_object_ref (arg1);
1290 arg2 = (gpointer) va_arg (args_copy, gpointer);
1291 if (arg2 != NULL)
1292 arg2 = g_object_ref (arg2);
1293 va_end (args_copy);
1294
1295 g_return_if_fail (return_value != NULL);
1296
1297 if (G_CCLOSURE_SWAP_DATA (closure))
1298 {
1299 data1 = closure->data;
1300 data2 = instance;
1301 }
1302 else
1303 {
1304 data1 = instance;
1305 data2 = closure->data;
1306 }
1307 callback = (GMarshalFunc_BOOLEAN__OBJECT_OBJECT_OBJECT) (marshal_data ? marshal_data : cc->callback);
1308
1309 v_return = callback (data1,
1310 arg0,
1311 arg1,
1312 arg2,
1313 data2);
1314 if (arg0 != NULL)
1315 g_object_unref (arg0);
1316 if (arg1 != NULL)
1317 g_object_unref (arg1);
1318 if (arg2 != NULL)
1319 g_object_unref (arg2);
1320
1321 g_value_set_boolean (return_value, v_return);
1322 }
1323
1324 /* BOOLEAN:OBJECT,STRING,STRING (./gtkmarshalers.list:39) */
1325 void
_gtk_marshal_BOOLEAN__OBJECT_STRING_STRING(GClosure * closure,GValue * return_value,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)1326 _gtk_marshal_BOOLEAN__OBJECT_STRING_STRING (GClosure *closure,
1327 GValue *return_value,
1328 guint n_param_values,
1329 const GValue *param_values,
1330 gpointer invocation_hint G_GNUC_UNUSED,
1331 gpointer marshal_data)
1332 {
1333 typedef gboolean (*GMarshalFunc_BOOLEAN__OBJECT_STRING_STRING) (gpointer data1,
1334 gpointer arg1,
1335 gpointer arg2,
1336 gpointer arg3,
1337 gpointer data2);
1338 GCClosure *cc = (GCClosure *) closure;
1339 gpointer data1, data2;
1340 GMarshalFunc_BOOLEAN__OBJECT_STRING_STRING callback;
1341 gboolean v_return;
1342
1343 g_return_if_fail (return_value != NULL);
1344 g_return_if_fail (n_param_values == 4);
1345
1346 if (G_CCLOSURE_SWAP_DATA (closure))
1347 {
1348 data1 = closure->data;
1349 data2 = g_value_peek_pointer (param_values + 0);
1350 }
1351 else
1352 {
1353 data1 = g_value_peek_pointer (param_values + 0);
1354 data2 = closure->data;
1355 }
1356 callback = (GMarshalFunc_BOOLEAN__OBJECT_STRING_STRING) (marshal_data ? marshal_data : cc->callback);
1357
1358 v_return = callback (data1,
1359 g_marshal_value_peek_object (param_values + 1),
1360 g_marshal_value_peek_string (param_values + 2),
1361 g_marshal_value_peek_string (param_values + 3),
1362 data2);
1363
1364 g_value_set_boolean (return_value, v_return);
1365 }
1366
1367 void
_gtk_marshal_BOOLEAN__OBJECT_STRING_STRINGv(GClosure * closure,GValue * return_value,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)1368 _gtk_marshal_BOOLEAN__OBJECT_STRING_STRINGv (GClosure *closure,
1369 GValue *return_value,
1370 gpointer instance,
1371 va_list args,
1372 gpointer marshal_data,
1373 int n_params,
1374 GType *param_types)
1375 {
1376 typedef gboolean (*GMarshalFunc_BOOLEAN__OBJECT_STRING_STRING) (gpointer data1,
1377 gpointer arg1,
1378 gpointer arg2,
1379 gpointer arg3,
1380 gpointer data2);
1381 GCClosure *cc = (GCClosure *) closure;
1382 gpointer data1, data2;
1383 GMarshalFunc_BOOLEAN__OBJECT_STRING_STRING callback;
1384 gboolean v_return;
1385 gpointer arg0;
1386 gpointer arg1;
1387 gpointer arg2;
1388 va_list args_copy;
1389
1390 G_VA_COPY (args_copy, args);
1391 arg0 = (gpointer) va_arg (args_copy, gpointer);
1392 if (arg0 != NULL)
1393 arg0 = g_object_ref (arg0);
1394 arg1 = (gpointer) va_arg (args_copy, gpointer);
1395 if ((param_types[1] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg1 != NULL)
1396 arg1 = g_strdup (arg1);
1397 arg2 = (gpointer) va_arg (args_copy, gpointer);
1398 if ((param_types[2] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg2 != NULL)
1399 arg2 = g_strdup (arg2);
1400 va_end (args_copy);
1401
1402 g_return_if_fail (return_value != NULL);
1403
1404 if (G_CCLOSURE_SWAP_DATA (closure))
1405 {
1406 data1 = closure->data;
1407 data2 = instance;
1408 }
1409 else
1410 {
1411 data1 = instance;
1412 data2 = closure->data;
1413 }
1414 callback = (GMarshalFunc_BOOLEAN__OBJECT_STRING_STRING) (marshal_data ? marshal_data : cc->callback);
1415
1416 v_return = callback (data1,
1417 arg0,
1418 arg1,
1419 arg2,
1420 data2);
1421 if (arg0 != NULL)
1422 g_object_unref (arg0);
1423 if ((param_types[1] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg1 != NULL)
1424 g_free (arg1);
1425 if ((param_types[2] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg2 != NULL)
1426 g_free (arg2);
1427
1428 g_value_set_boolean (return_value, v_return);
1429 }
1430
1431 /* BOOLEAN:OBJECT,ENUM (./gtkmarshalers.list:40) */
1432 void
_gtk_marshal_BOOLEAN__OBJECT_ENUM(GClosure * closure,GValue * return_value,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)1433 _gtk_marshal_BOOLEAN__OBJECT_ENUM (GClosure *closure,
1434 GValue *return_value,
1435 guint n_param_values,
1436 const GValue *param_values,
1437 gpointer invocation_hint G_GNUC_UNUSED,
1438 gpointer marshal_data)
1439 {
1440 typedef gboolean (*GMarshalFunc_BOOLEAN__OBJECT_ENUM) (gpointer data1,
1441 gpointer arg1,
1442 gint arg2,
1443 gpointer data2);
1444 GCClosure *cc = (GCClosure *) closure;
1445 gpointer data1, data2;
1446 GMarshalFunc_BOOLEAN__OBJECT_ENUM callback;
1447 gboolean v_return;
1448
1449 g_return_if_fail (return_value != NULL);
1450 g_return_if_fail (n_param_values == 3);
1451
1452 if (G_CCLOSURE_SWAP_DATA (closure))
1453 {
1454 data1 = closure->data;
1455 data2 = g_value_peek_pointer (param_values + 0);
1456 }
1457 else
1458 {
1459 data1 = g_value_peek_pointer (param_values + 0);
1460 data2 = closure->data;
1461 }
1462 callback = (GMarshalFunc_BOOLEAN__OBJECT_ENUM) (marshal_data ? marshal_data : cc->callback);
1463
1464 v_return = callback (data1,
1465 g_marshal_value_peek_object (param_values + 1),
1466 g_marshal_value_peek_enum (param_values + 2),
1467 data2);
1468
1469 g_value_set_boolean (return_value, v_return);
1470 }
1471
1472 void
_gtk_marshal_BOOLEAN__OBJECT_ENUMv(GClosure * closure,GValue * return_value,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)1473 _gtk_marshal_BOOLEAN__OBJECT_ENUMv (GClosure *closure,
1474 GValue *return_value,
1475 gpointer instance,
1476 va_list args,
1477 gpointer marshal_data,
1478 int n_params,
1479 GType *param_types)
1480 {
1481 typedef gboolean (*GMarshalFunc_BOOLEAN__OBJECT_ENUM) (gpointer data1,
1482 gpointer arg1,
1483 gint arg2,
1484 gpointer data2);
1485 GCClosure *cc = (GCClosure *) closure;
1486 gpointer data1, data2;
1487 GMarshalFunc_BOOLEAN__OBJECT_ENUM callback;
1488 gboolean v_return;
1489 gpointer arg0;
1490 gint arg1;
1491 va_list args_copy;
1492
1493 G_VA_COPY (args_copy, args);
1494 arg0 = (gpointer) va_arg (args_copy, gpointer);
1495 if (arg0 != NULL)
1496 arg0 = g_object_ref (arg0);
1497 arg1 = (gint) va_arg (args_copy, gint);
1498 va_end (args_copy);
1499
1500 g_return_if_fail (return_value != NULL);
1501
1502 if (G_CCLOSURE_SWAP_DATA (closure))
1503 {
1504 data1 = closure->data;
1505 data2 = instance;
1506 }
1507 else
1508 {
1509 data1 = instance;
1510 data2 = closure->data;
1511 }
1512 callback = (GMarshalFunc_BOOLEAN__OBJECT_ENUM) (marshal_data ? marshal_data : cc->callback);
1513
1514 v_return = callback (data1,
1515 arg0,
1516 arg1,
1517 data2);
1518 if (arg0 != NULL)
1519 g_object_unref (arg0);
1520
1521 g_value_set_boolean (return_value, v_return);
1522 }
1523
1524 /* BOOLEAN:INT (./gtkmarshalers.list:41) */
1525 void
_gtk_marshal_BOOLEAN__INT(GClosure * closure,GValue * return_value,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)1526 _gtk_marshal_BOOLEAN__INT (GClosure *closure,
1527 GValue *return_value,
1528 guint n_param_values,
1529 const GValue *param_values,
1530 gpointer invocation_hint G_GNUC_UNUSED,
1531 gpointer marshal_data)
1532 {
1533 typedef gboolean (*GMarshalFunc_BOOLEAN__INT) (gpointer data1,
1534 gint arg1,
1535 gpointer data2);
1536 GCClosure *cc = (GCClosure *) closure;
1537 gpointer data1, data2;
1538 GMarshalFunc_BOOLEAN__INT callback;
1539 gboolean v_return;
1540
1541 g_return_if_fail (return_value != NULL);
1542 g_return_if_fail (n_param_values == 2);
1543
1544 if (G_CCLOSURE_SWAP_DATA (closure))
1545 {
1546 data1 = closure->data;
1547 data2 = g_value_peek_pointer (param_values + 0);
1548 }
1549 else
1550 {
1551 data1 = g_value_peek_pointer (param_values + 0);
1552 data2 = closure->data;
1553 }
1554 callback = (GMarshalFunc_BOOLEAN__INT) (marshal_data ? marshal_data : cc->callback);
1555
1556 v_return = callback (data1,
1557 g_marshal_value_peek_int (param_values + 1),
1558 data2);
1559
1560 g_value_set_boolean (return_value, v_return);
1561 }
1562
1563 void
_gtk_marshal_BOOLEAN__INTv(GClosure * closure,GValue * return_value,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)1564 _gtk_marshal_BOOLEAN__INTv (GClosure *closure,
1565 GValue *return_value,
1566 gpointer instance,
1567 va_list args,
1568 gpointer marshal_data,
1569 int n_params,
1570 GType *param_types)
1571 {
1572 typedef gboolean (*GMarshalFunc_BOOLEAN__INT) (gpointer data1,
1573 gint arg1,
1574 gpointer data2);
1575 GCClosure *cc = (GCClosure *) closure;
1576 gpointer data1, data2;
1577 GMarshalFunc_BOOLEAN__INT callback;
1578 gboolean v_return;
1579 gint arg0;
1580 va_list args_copy;
1581
1582 G_VA_COPY (args_copy, args);
1583 arg0 = (gint) va_arg (args_copy, gint);
1584 va_end (args_copy);
1585
1586 g_return_if_fail (return_value != NULL);
1587
1588 if (G_CCLOSURE_SWAP_DATA (closure))
1589 {
1590 data1 = closure->data;
1591 data2 = instance;
1592 }
1593 else
1594 {
1595 data1 = instance;
1596 data2 = closure->data;
1597 }
1598 callback = (GMarshalFunc_BOOLEAN__INT) (marshal_data ? marshal_data : cc->callback);
1599
1600 v_return = callback (data1,
1601 arg0,
1602 data2);
1603
1604
1605 g_value_set_boolean (return_value, v_return);
1606 }
1607
1608 /* BOOLEAN:INT,INT (./gtkmarshalers.list:42) */
1609 void
_gtk_marshal_BOOLEAN__INT_INT(GClosure * closure,GValue * return_value,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)1610 _gtk_marshal_BOOLEAN__INT_INT (GClosure *closure,
1611 GValue *return_value,
1612 guint n_param_values,
1613 const GValue *param_values,
1614 gpointer invocation_hint G_GNUC_UNUSED,
1615 gpointer marshal_data)
1616 {
1617 typedef gboolean (*GMarshalFunc_BOOLEAN__INT_INT) (gpointer data1,
1618 gint arg1,
1619 gint arg2,
1620 gpointer data2);
1621 GCClosure *cc = (GCClosure *) closure;
1622 gpointer data1, data2;
1623 GMarshalFunc_BOOLEAN__INT_INT callback;
1624 gboolean v_return;
1625
1626 g_return_if_fail (return_value != NULL);
1627 g_return_if_fail (n_param_values == 3);
1628
1629 if (G_CCLOSURE_SWAP_DATA (closure))
1630 {
1631 data1 = closure->data;
1632 data2 = g_value_peek_pointer (param_values + 0);
1633 }
1634 else
1635 {
1636 data1 = g_value_peek_pointer (param_values + 0);
1637 data2 = closure->data;
1638 }
1639 callback = (GMarshalFunc_BOOLEAN__INT_INT) (marshal_data ? marshal_data : cc->callback);
1640
1641 v_return = callback (data1,
1642 g_marshal_value_peek_int (param_values + 1),
1643 g_marshal_value_peek_int (param_values + 2),
1644 data2);
1645
1646 g_value_set_boolean (return_value, v_return);
1647 }
1648
1649 void
_gtk_marshal_BOOLEAN__INT_INTv(GClosure * closure,GValue * return_value,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)1650 _gtk_marshal_BOOLEAN__INT_INTv (GClosure *closure,
1651 GValue *return_value,
1652 gpointer instance,
1653 va_list args,
1654 gpointer marshal_data,
1655 int n_params,
1656 GType *param_types)
1657 {
1658 typedef gboolean (*GMarshalFunc_BOOLEAN__INT_INT) (gpointer data1,
1659 gint arg1,
1660 gint arg2,
1661 gpointer data2);
1662 GCClosure *cc = (GCClosure *) closure;
1663 gpointer data1, data2;
1664 GMarshalFunc_BOOLEAN__INT_INT callback;
1665 gboolean v_return;
1666 gint arg0;
1667 gint arg1;
1668 va_list args_copy;
1669
1670 G_VA_COPY (args_copy, args);
1671 arg0 = (gint) va_arg (args_copy, gint);
1672 arg1 = (gint) va_arg (args_copy, gint);
1673 va_end (args_copy);
1674
1675 g_return_if_fail (return_value != NULL);
1676
1677 if (G_CCLOSURE_SWAP_DATA (closure))
1678 {
1679 data1 = closure->data;
1680 data2 = instance;
1681 }
1682 else
1683 {
1684 data1 = instance;
1685 data2 = closure->data;
1686 }
1687 callback = (GMarshalFunc_BOOLEAN__INT_INT) (marshal_data ? marshal_data : cc->callback);
1688
1689 v_return = callback (data1,
1690 arg0,
1691 arg1,
1692 data2);
1693
1694
1695 g_value_set_boolean (return_value, v_return);
1696 }
1697
1698 /* BOOLEAN:INT,INT,INT (./gtkmarshalers.list:43) */
1699 void
_gtk_marshal_BOOLEAN__INT_INT_INT(GClosure * closure,GValue * return_value,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)1700 _gtk_marshal_BOOLEAN__INT_INT_INT (GClosure *closure,
1701 GValue *return_value,
1702 guint n_param_values,
1703 const GValue *param_values,
1704 gpointer invocation_hint G_GNUC_UNUSED,
1705 gpointer marshal_data)
1706 {
1707 typedef gboolean (*GMarshalFunc_BOOLEAN__INT_INT_INT) (gpointer data1,
1708 gint arg1,
1709 gint arg2,
1710 gint arg3,
1711 gpointer data2);
1712 GCClosure *cc = (GCClosure *) closure;
1713 gpointer data1, data2;
1714 GMarshalFunc_BOOLEAN__INT_INT_INT callback;
1715 gboolean v_return;
1716
1717 g_return_if_fail (return_value != NULL);
1718 g_return_if_fail (n_param_values == 4);
1719
1720 if (G_CCLOSURE_SWAP_DATA (closure))
1721 {
1722 data1 = closure->data;
1723 data2 = g_value_peek_pointer (param_values + 0);
1724 }
1725 else
1726 {
1727 data1 = g_value_peek_pointer (param_values + 0);
1728 data2 = closure->data;
1729 }
1730 callback = (GMarshalFunc_BOOLEAN__INT_INT_INT) (marshal_data ? marshal_data : cc->callback);
1731
1732 v_return = callback (data1,
1733 g_marshal_value_peek_int (param_values + 1),
1734 g_marshal_value_peek_int (param_values + 2),
1735 g_marshal_value_peek_int (param_values + 3),
1736 data2);
1737
1738 g_value_set_boolean (return_value, v_return);
1739 }
1740
1741 void
_gtk_marshal_BOOLEAN__INT_INT_INTv(GClosure * closure,GValue * return_value,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)1742 _gtk_marshal_BOOLEAN__INT_INT_INTv (GClosure *closure,
1743 GValue *return_value,
1744 gpointer instance,
1745 va_list args,
1746 gpointer marshal_data,
1747 int n_params,
1748 GType *param_types)
1749 {
1750 typedef gboolean (*GMarshalFunc_BOOLEAN__INT_INT_INT) (gpointer data1,
1751 gint arg1,
1752 gint arg2,
1753 gint arg3,
1754 gpointer data2);
1755 GCClosure *cc = (GCClosure *) closure;
1756 gpointer data1, data2;
1757 GMarshalFunc_BOOLEAN__INT_INT_INT callback;
1758 gboolean v_return;
1759 gint arg0;
1760 gint arg1;
1761 gint arg2;
1762 va_list args_copy;
1763
1764 G_VA_COPY (args_copy, args);
1765 arg0 = (gint) va_arg (args_copy, gint);
1766 arg1 = (gint) va_arg (args_copy, gint);
1767 arg2 = (gint) va_arg (args_copy, gint);
1768 va_end (args_copy);
1769
1770 g_return_if_fail (return_value != NULL);
1771
1772 if (G_CCLOSURE_SWAP_DATA (closure))
1773 {
1774 data1 = closure->data;
1775 data2 = instance;
1776 }
1777 else
1778 {
1779 data1 = instance;
1780 data2 = closure->data;
1781 }
1782 callback = (GMarshalFunc_BOOLEAN__INT_INT_INT) (marshal_data ? marshal_data : cc->callback);
1783
1784 v_return = callback (data1,
1785 arg0,
1786 arg1,
1787 arg2,
1788 data2);
1789
1790
1791 g_value_set_boolean (return_value, v_return);
1792 }
1793
1794 /* BOOLEAN:INT,INT,BOOLEAN,OBJECT (./gtkmarshalers.list:44) */
1795 void
_gtk_marshal_BOOLEAN__INT_INT_BOOLEAN_OBJECT(GClosure * closure,GValue * return_value,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)1796 _gtk_marshal_BOOLEAN__INT_INT_BOOLEAN_OBJECT (GClosure *closure,
1797 GValue *return_value,
1798 guint n_param_values,
1799 const GValue *param_values,
1800 gpointer invocation_hint G_GNUC_UNUSED,
1801 gpointer marshal_data)
1802 {
1803 typedef gboolean (*GMarshalFunc_BOOLEAN__INT_INT_BOOLEAN_OBJECT) (gpointer data1,
1804 gint arg1,
1805 gint arg2,
1806 gboolean arg3,
1807 gpointer arg4,
1808 gpointer data2);
1809 GCClosure *cc = (GCClosure *) closure;
1810 gpointer data1, data2;
1811 GMarshalFunc_BOOLEAN__INT_INT_BOOLEAN_OBJECT callback;
1812 gboolean v_return;
1813
1814 g_return_if_fail (return_value != NULL);
1815 g_return_if_fail (n_param_values == 5);
1816
1817 if (G_CCLOSURE_SWAP_DATA (closure))
1818 {
1819 data1 = closure->data;
1820 data2 = g_value_peek_pointer (param_values + 0);
1821 }
1822 else
1823 {
1824 data1 = g_value_peek_pointer (param_values + 0);
1825 data2 = closure->data;
1826 }
1827 callback = (GMarshalFunc_BOOLEAN__INT_INT_BOOLEAN_OBJECT) (marshal_data ? marshal_data : cc->callback);
1828
1829 v_return = callback (data1,
1830 g_marshal_value_peek_int (param_values + 1),
1831 g_marshal_value_peek_int (param_values + 2),
1832 g_marshal_value_peek_boolean (param_values + 3),
1833 g_marshal_value_peek_object (param_values + 4),
1834 data2);
1835
1836 g_value_set_boolean (return_value, v_return);
1837 }
1838
1839 void
_gtk_marshal_BOOLEAN__INT_INT_BOOLEAN_OBJECTv(GClosure * closure,GValue * return_value,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)1840 _gtk_marshal_BOOLEAN__INT_INT_BOOLEAN_OBJECTv (GClosure *closure,
1841 GValue *return_value,
1842 gpointer instance,
1843 va_list args,
1844 gpointer marshal_data,
1845 int n_params,
1846 GType *param_types)
1847 {
1848 typedef gboolean (*GMarshalFunc_BOOLEAN__INT_INT_BOOLEAN_OBJECT) (gpointer data1,
1849 gint arg1,
1850 gint arg2,
1851 gboolean arg3,
1852 gpointer arg4,
1853 gpointer data2);
1854 GCClosure *cc = (GCClosure *) closure;
1855 gpointer data1, data2;
1856 GMarshalFunc_BOOLEAN__INT_INT_BOOLEAN_OBJECT callback;
1857 gboolean v_return;
1858 gint arg0;
1859 gint arg1;
1860 gboolean arg2;
1861 gpointer arg3;
1862 va_list args_copy;
1863
1864 G_VA_COPY (args_copy, args);
1865 arg0 = (gint) va_arg (args_copy, gint);
1866 arg1 = (gint) va_arg (args_copy, gint);
1867 arg2 = (gboolean) va_arg (args_copy, gboolean);
1868 arg3 = (gpointer) va_arg (args_copy, gpointer);
1869 if (arg3 != NULL)
1870 arg3 = g_object_ref (arg3);
1871 va_end (args_copy);
1872
1873 g_return_if_fail (return_value != NULL);
1874
1875 if (G_CCLOSURE_SWAP_DATA (closure))
1876 {
1877 data1 = closure->data;
1878 data2 = instance;
1879 }
1880 else
1881 {
1882 data1 = instance;
1883 data2 = closure->data;
1884 }
1885 callback = (GMarshalFunc_BOOLEAN__INT_INT_BOOLEAN_OBJECT) (marshal_data ? marshal_data : cc->callback);
1886
1887 v_return = callback (data1,
1888 arg0,
1889 arg1,
1890 arg2,
1891 arg3,
1892 data2);
1893 if (arg3 != NULL)
1894 g_object_unref (arg3);
1895
1896 g_value_set_boolean (return_value, v_return);
1897 }
1898
1899 /* BOOLEAN:UINT (./gtkmarshalers.list:45) */
1900 void
_gtk_marshal_BOOLEAN__UINT(GClosure * closure,GValue * return_value,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)1901 _gtk_marshal_BOOLEAN__UINT (GClosure *closure,
1902 GValue *return_value,
1903 guint n_param_values,
1904 const GValue *param_values,
1905 gpointer invocation_hint G_GNUC_UNUSED,
1906 gpointer marshal_data)
1907 {
1908 typedef gboolean (*GMarshalFunc_BOOLEAN__UINT) (gpointer data1,
1909 guint arg1,
1910 gpointer data2);
1911 GCClosure *cc = (GCClosure *) closure;
1912 gpointer data1, data2;
1913 GMarshalFunc_BOOLEAN__UINT callback;
1914 gboolean v_return;
1915
1916 g_return_if_fail (return_value != NULL);
1917 g_return_if_fail (n_param_values == 2);
1918
1919 if (G_CCLOSURE_SWAP_DATA (closure))
1920 {
1921 data1 = closure->data;
1922 data2 = g_value_peek_pointer (param_values + 0);
1923 }
1924 else
1925 {
1926 data1 = g_value_peek_pointer (param_values + 0);
1927 data2 = closure->data;
1928 }
1929 callback = (GMarshalFunc_BOOLEAN__UINT) (marshal_data ? marshal_data : cc->callback);
1930
1931 v_return = callback (data1,
1932 g_marshal_value_peek_uint (param_values + 1),
1933 data2);
1934
1935 g_value_set_boolean (return_value, v_return);
1936 }
1937
1938 void
_gtk_marshal_BOOLEAN__UINTv(GClosure * closure,GValue * return_value,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)1939 _gtk_marshal_BOOLEAN__UINTv (GClosure *closure,
1940 GValue *return_value,
1941 gpointer instance,
1942 va_list args,
1943 gpointer marshal_data,
1944 int n_params,
1945 GType *param_types)
1946 {
1947 typedef gboolean (*GMarshalFunc_BOOLEAN__UINT) (gpointer data1,
1948 guint arg1,
1949 gpointer data2);
1950 GCClosure *cc = (GCClosure *) closure;
1951 gpointer data1, data2;
1952 GMarshalFunc_BOOLEAN__UINT callback;
1953 gboolean v_return;
1954 guint arg0;
1955 va_list args_copy;
1956
1957 G_VA_COPY (args_copy, args);
1958 arg0 = (guint) va_arg (args_copy, guint);
1959 va_end (args_copy);
1960
1961 g_return_if_fail (return_value != NULL);
1962
1963 if (G_CCLOSURE_SWAP_DATA (closure))
1964 {
1965 data1 = closure->data;
1966 data2 = instance;
1967 }
1968 else
1969 {
1970 data1 = instance;
1971 data2 = closure->data;
1972 }
1973 callback = (GMarshalFunc_BOOLEAN__UINT) (marshal_data ? marshal_data : cc->callback);
1974
1975 v_return = callback (data1,
1976 arg0,
1977 data2);
1978
1979
1980 g_value_set_boolean (return_value, v_return);
1981 }
1982
1983 /* BOOLEAN:UINT,UINT,FLAGS (./gtkmarshalers.list:46) */
1984 void
_gtk_marshal_BOOLEAN__UINT_UINT_FLAGS(GClosure * closure,GValue * return_value,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)1985 _gtk_marshal_BOOLEAN__UINT_UINT_FLAGS (GClosure *closure,
1986 GValue *return_value,
1987 guint n_param_values,
1988 const GValue *param_values,
1989 gpointer invocation_hint G_GNUC_UNUSED,
1990 gpointer marshal_data)
1991 {
1992 typedef gboolean (*GMarshalFunc_BOOLEAN__UINT_UINT_FLAGS) (gpointer data1,
1993 guint arg1,
1994 guint arg2,
1995 guint arg3,
1996 gpointer data2);
1997 GCClosure *cc = (GCClosure *) closure;
1998 gpointer data1, data2;
1999 GMarshalFunc_BOOLEAN__UINT_UINT_FLAGS callback;
2000 gboolean v_return;
2001
2002 g_return_if_fail (return_value != NULL);
2003 g_return_if_fail (n_param_values == 4);
2004
2005 if (G_CCLOSURE_SWAP_DATA (closure))
2006 {
2007 data1 = closure->data;
2008 data2 = g_value_peek_pointer (param_values + 0);
2009 }
2010 else
2011 {
2012 data1 = g_value_peek_pointer (param_values + 0);
2013 data2 = closure->data;
2014 }
2015 callback = (GMarshalFunc_BOOLEAN__UINT_UINT_FLAGS) (marshal_data ? marshal_data : cc->callback);
2016
2017 v_return = callback (data1,
2018 g_marshal_value_peek_uint (param_values + 1),
2019 g_marshal_value_peek_uint (param_values + 2),
2020 g_marshal_value_peek_flags (param_values + 3),
2021 data2);
2022
2023 g_value_set_boolean (return_value, v_return);
2024 }
2025
2026 void
_gtk_marshal_BOOLEAN__UINT_UINT_FLAGSv(GClosure * closure,GValue * return_value,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)2027 _gtk_marshal_BOOLEAN__UINT_UINT_FLAGSv (GClosure *closure,
2028 GValue *return_value,
2029 gpointer instance,
2030 va_list args,
2031 gpointer marshal_data,
2032 int n_params,
2033 GType *param_types)
2034 {
2035 typedef gboolean (*GMarshalFunc_BOOLEAN__UINT_UINT_FLAGS) (gpointer data1,
2036 guint arg1,
2037 guint arg2,
2038 guint arg3,
2039 gpointer data2);
2040 GCClosure *cc = (GCClosure *) closure;
2041 gpointer data1, data2;
2042 GMarshalFunc_BOOLEAN__UINT_UINT_FLAGS callback;
2043 gboolean v_return;
2044 guint arg0;
2045 guint arg1;
2046 guint arg2;
2047 va_list args_copy;
2048
2049 G_VA_COPY (args_copy, args);
2050 arg0 = (guint) va_arg (args_copy, guint);
2051 arg1 = (guint) va_arg (args_copy, guint);
2052 arg2 = (guint) va_arg (args_copy, guint);
2053 va_end (args_copy);
2054
2055 g_return_if_fail (return_value != NULL);
2056
2057 if (G_CCLOSURE_SWAP_DATA (closure))
2058 {
2059 data1 = closure->data;
2060 data2 = instance;
2061 }
2062 else
2063 {
2064 data1 = instance;
2065 data2 = closure->data;
2066 }
2067 callback = (GMarshalFunc_BOOLEAN__UINT_UINT_FLAGS) (marshal_data ? marshal_data : cc->callback);
2068
2069 v_return = callback (data1,
2070 arg0,
2071 arg1,
2072 arg2,
2073 data2);
2074
2075
2076 g_value_set_boolean (return_value, v_return);
2077 }
2078
2079 /* BOOLEAN:VOID (./gtkmarshalers.list:47) */
2080 void
_gtk_marshal_BOOLEAN__VOID(GClosure * closure,GValue * return_value,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)2081 _gtk_marshal_BOOLEAN__VOID (GClosure *closure,
2082 GValue *return_value,
2083 guint n_param_values,
2084 const GValue *param_values,
2085 gpointer invocation_hint G_GNUC_UNUSED,
2086 gpointer marshal_data)
2087 {
2088 typedef gboolean (*GMarshalFunc_BOOLEAN__VOID) (gpointer data1,
2089 gpointer data2);
2090 GCClosure *cc = (GCClosure *) closure;
2091 gpointer data1, data2;
2092 GMarshalFunc_BOOLEAN__VOID callback;
2093 gboolean v_return;
2094
2095 g_return_if_fail (return_value != NULL);
2096 g_return_if_fail (n_param_values == 1);
2097
2098 if (G_CCLOSURE_SWAP_DATA (closure))
2099 {
2100 data1 = closure->data;
2101 data2 = g_value_peek_pointer (param_values + 0);
2102 }
2103 else
2104 {
2105 data1 = g_value_peek_pointer (param_values + 0);
2106 data2 = closure->data;
2107 }
2108 callback = (GMarshalFunc_BOOLEAN__VOID) (marshal_data ? marshal_data : cc->callback);
2109
2110 v_return = callback (data1,
2111 data2);
2112
2113 g_value_set_boolean (return_value, v_return);
2114 }
2115
2116 void
_gtk_marshal_BOOLEAN__VOIDv(GClosure * closure,GValue * return_value,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)2117 _gtk_marshal_BOOLEAN__VOIDv (GClosure *closure,
2118 GValue *return_value,
2119 gpointer instance,
2120 va_list args,
2121 gpointer marshal_data,
2122 int n_params,
2123 GType *param_types)
2124 {
2125 typedef gboolean (*GMarshalFunc_BOOLEAN__VOID) (gpointer data1,
2126 gpointer data2);
2127 GCClosure *cc = (GCClosure *) closure;
2128 gpointer data1, data2;
2129 GMarshalFunc_BOOLEAN__VOID callback;
2130 gboolean v_return;
2131
2132 g_return_if_fail (return_value != NULL);
2133
2134 if (G_CCLOSURE_SWAP_DATA (closure))
2135 {
2136 data1 = closure->data;
2137 data2 = instance;
2138 }
2139 else
2140 {
2141 data1 = instance;
2142 data2 = closure->data;
2143 }
2144 callback = (GMarshalFunc_BOOLEAN__VOID) (marshal_data ? marshal_data : cc->callback);
2145
2146 v_return = callback (data1,
2147 data2);
2148
2149
2150 g_value_set_boolean (return_value, v_return);
2151 }
2152
2153 /* BOOLEAN:BOOLEAN (./gtkmarshalers.list:48) */
2154 void
_gtk_marshal_BOOLEAN__BOOLEAN(GClosure * closure,GValue * return_value,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)2155 _gtk_marshal_BOOLEAN__BOOLEAN (GClosure *closure,
2156 GValue *return_value,
2157 guint n_param_values,
2158 const GValue *param_values,
2159 gpointer invocation_hint G_GNUC_UNUSED,
2160 gpointer marshal_data)
2161 {
2162 typedef gboolean (*GMarshalFunc_BOOLEAN__BOOLEAN) (gpointer data1,
2163 gboolean arg1,
2164 gpointer data2);
2165 GCClosure *cc = (GCClosure *) closure;
2166 gpointer data1, data2;
2167 GMarshalFunc_BOOLEAN__BOOLEAN callback;
2168 gboolean v_return;
2169
2170 g_return_if_fail (return_value != NULL);
2171 g_return_if_fail (n_param_values == 2);
2172
2173 if (G_CCLOSURE_SWAP_DATA (closure))
2174 {
2175 data1 = closure->data;
2176 data2 = g_value_peek_pointer (param_values + 0);
2177 }
2178 else
2179 {
2180 data1 = g_value_peek_pointer (param_values + 0);
2181 data2 = closure->data;
2182 }
2183 callback = (GMarshalFunc_BOOLEAN__BOOLEAN) (marshal_data ? marshal_data : cc->callback);
2184
2185 v_return = callback (data1,
2186 g_marshal_value_peek_boolean (param_values + 1),
2187 data2);
2188
2189 g_value_set_boolean (return_value, v_return);
2190 }
2191
2192 void
_gtk_marshal_BOOLEAN__BOOLEANv(GClosure * closure,GValue * return_value,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)2193 _gtk_marshal_BOOLEAN__BOOLEANv (GClosure *closure,
2194 GValue *return_value,
2195 gpointer instance,
2196 va_list args,
2197 gpointer marshal_data,
2198 int n_params,
2199 GType *param_types)
2200 {
2201 typedef gboolean (*GMarshalFunc_BOOLEAN__BOOLEAN) (gpointer data1,
2202 gboolean arg1,
2203 gpointer data2);
2204 GCClosure *cc = (GCClosure *) closure;
2205 gpointer data1, data2;
2206 GMarshalFunc_BOOLEAN__BOOLEAN callback;
2207 gboolean v_return;
2208 gboolean arg0;
2209 va_list args_copy;
2210
2211 G_VA_COPY (args_copy, args);
2212 arg0 = (gboolean) va_arg (args_copy, gboolean);
2213 va_end (args_copy);
2214
2215 g_return_if_fail (return_value != NULL);
2216
2217 if (G_CCLOSURE_SWAP_DATA (closure))
2218 {
2219 data1 = closure->data;
2220 data2 = instance;
2221 }
2222 else
2223 {
2224 data1 = instance;
2225 data2 = closure->data;
2226 }
2227 callback = (GMarshalFunc_BOOLEAN__BOOLEAN) (marshal_data ? marshal_data : cc->callback);
2228
2229 v_return = callback (data1,
2230 arg0,
2231 data2);
2232
2233
2234 g_value_set_boolean (return_value, v_return);
2235 }
2236
2237 /* BOOLEAN:BOOLEAN,BOOLEAN,BOOLEAN (./gtkmarshalers.list:49) */
2238 void
_gtk_marshal_BOOLEAN__BOOLEAN_BOOLEAN_BOOLEAN(GClosure * closure,GValue * return_value,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)2239 _gtk_marshal_BOOLEAN__BOOLEAN_BOOLEAN_BOOLEAN (GClosure *closure,
2240 GValue *return_value,
2241 guint n_param_values,
2242 const GValue *param_values,
2243 gpointer invocation_hint G_GNUC_UNUSED,
2244 gpointer marshal_data)
2245 {
2246 typedef gboolean (*GMarshalFunc_BOOLEAN__BOOLEAN_BOOLEAN_BOOLEAN) (gpointer data1,
2247 gboolean arg1,
2248 gboolean arg2,
2249 gboolean arg3,
2250 gpointer data2);
2251 GCClosure *cc = (GCClosure *) closure;
2252 gpointer data1, data2;
2253 GMarshalFunc_BOOLEAN__BOOLEAN_BOOLEAN_BOOLEAN callback;
2254 gboolean v_return;
2255
2256 g_return_if_fail (return_value != NULL);
2257 g_return_if_fail (n_param_values == 4);
2258
2259 if (G_CCLOSURE_SWAP_DATA (closure))
2260 {
2261 data1 = closure->data;
2262 data2 = g_value_peek_pointer (param_values + 0);
2263 }
2264 else
2265 {
2266 data1 = g_value_peek_pointer (param_values + 0);
2267 data2 = closure->data;
2268 }
2269 callback = (GMarshalFunc_BOOLEAN__BOOLEAN_BOOLEAN_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
2270
2271 v_return = callback (data1,
2272 g_marshal_value_peek_boolean (param_values + 1),
2273 g_marshal_value_peek_boolean (param_values + 2),
2274 g_marshal_value_peek_boolean (param_values + 3),
2275 data2);
2276
2277 g_value_set_boolean (return_value, v_return);
2278 }
2279
2280 void
_gtk_marshal_BOOLEAN__BOOLEAN_BOOLEAN_BOOLEANv(GClosure * closure,GValue * return_value,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)2281 _gtk_marshal_BOOLEAN__BOOLEAN_BOOLEAN_BOOLEANv (GClosure *closure,
2282 GValue *return_value,
2283 gpointer instance,
2284 va_list args,
2285 gpointer marshal_data,
2286 int n_params,
2287 GType *param_types)
2288 {
2289 typedef gboolean (*GMarshalFunc_BOOLEAN__BOOLEAN_BOOLEAN_BOOLEAN) (gpointer data1,
2290 gboolean arg1,
2291 gboolean arg2,
2292 gboolean arg3,
2293 gpointer data2);
2294 GCClosure *cc = (GCClosure *) closure;
2295 gpointer data1, data2;
2296 GMarshalFunc_BOOLEAN__BOOLEAN_BOOLEAN_BOOLEAN callback;
2297 gboolean v_return;
2298 gboolean arg0;
2299 gboolean arg1;
2300 gboolean arg2;
2301 va_list args_copy;
2302
2303 G_VA_COPY (args_copy, args);
2304 arg0 = (gboolean) va_arg (args_copy, gboolean);
2305 arg1 = (gboolean) va_arg (args_copy, gboolean);
2306 arg2 = (gboolean) va_arg (args_copy, gboolean);
2307 va_end (args_copy);
2308
2309 g_return_if_fail (return_value != NULL);
2310
2311 if (G_CCLOSURE_SWAP_DATA (closure))
2312 {
2313 data1 = closure->data;
2314 data2 = instance;
2315 }
2316 else
2317 {
2318 data1 = instance;
2319 data2 = closure->data;
2320 }
2321 callback = (GMarshalFunc_BOOLEAN__BOOLEAN_BOOLEAN_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
2322
2323 v_return = callback (data1,
2324 arg0,
2325 arg1,
2326 arg2,
2327 data2);
2328
2329
2330 g_value_set_boolean (return_value, v_return);
2331 }
2332
2333 /* BOOLEAN:STRING (./gtkmarshalers.list:50) */
2334 void
_gtk_marshal_BOOLEAN__STRING(GClosure * closure,GValue * return_value,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)2335 _gtk_marshal_BOOLEAN__STRING (GClosure *closure,
2336 GValue *return_value,
2337 guint n_param_values,
2338 const GValue *param_values,
2339 gpointer invocation_hint G_GNUC_UNUSED,
2340 gpointer marshal_data)
2341 {
2342 typedef gboolean (*GMarshalFunc_BOOLEAN__STRING) (gpointer data1,
2343 gpointer arg1,
2344 gpointer data2);
2345 GCClosure *cc = (GCClosure *) closure;
2346 gpointer data1, data2;
2347 GMarshalFunc_BOOLEAN__STRING callback;
2348 gboolean v_return;
2349
2350 g_return_if_fail (return_value != NULL);
2351 g_return_if_fail (n_param_values == 2);
2352
2353 if (G_CCLOSURE_SWAP_DATA (closure))
2354 {
2355 data1 = closure->data;
2356 data2 = g_value_peek_pointer (param_values + 0);
2357 }
2358 else
2359 {
2360 data1 = g_value_peek_pointer (param_values + 0);
2361 data2 = closure->data;
2362 }
2363 callback = (GMarshalFunc_BOOLEAN__STRING) (marshal_data ? marshal_data : cc->callback);
2364
2365 v_return = callback (data1,
2366 g_marshal_value_peek_string (param_values + 1),
2367 data2);
2368
2369 g_value_set_boolean (return_value, v_return);
2370 }
2371
2372 void
_gtk_marshal_BOOLEAN__STRINGv(GClosure * closure,GValue * return_value,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)2373 _gtk_marshal_BOOLEAN__STRINGv (GClosure *closure,
2374 GValue *return_value,
2375 gpointer instance,
2376 va_list args,
2377 gpointer marshal_data,
2378 int n_params,
2379 GType *param_types)
2380 {
2381 typedef gboolean (*GMarshalFunc_BOOLEAN__STRING) (gpointer data1,
2382 gpointer arg1,
2383 gpointer data2);
2384 GCClosure *cc = (GCClosure *) closure;
2385 gpointer data1, data2;
2386 GMarshalFunc_BOOLEAN__STRING callback;
2387 gboolean v_return;
2388 gpointer arg0;
2389 va_list args_copy;
2390
2391 G_VA_COPY (args_copy, args);
2392 arg0 = (gpointer) va_arg (args_copy, gpointer);
2393 if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
2394 arg0 = g_strdup (arg0);
2395 va_end (args_copy);
2396
2397 g_return_if_fail (return_value != NULL);
2398
2399 if (G_CCLOSURE_SWAP_DATA (closure))
2400 {
2401 data1 = closure->data;
2402 data2 = instance;
2403 }
2404 else
2405 {
2406 data1 = instance;
2407 data2 = closure->data;
2408 }
2409 callback = (GMarshalFunc_BOOLEAN__STRING) (marshal_data ? marshal_data : cc->callback);
2410
2411 v_return = callback (data1,
2412 arg0,
2413 data2);
2414 if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
2415 g_free (arg0);
2416
2417 g_value_set_boolean (return_value, v_return);
2418 }
2419
2420 /* ENUM:ENUM (./gtkmarshalers.list:51) */
2421 void
_gtk_marshal_ENUM__ENUM(GClosure * closure,GValue * return_value,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)2422 _gtk_marshal_ENUM__ENUM (GClosure *closure,
2423 GValue *return_value,
2424 guint n_param_values,
2425 const GValue *param_values,
2426 gpointer invocation_hint G_GNUC_UNUSED,
2427 gpointer marshal_data)
2428 {
2429 typedef gint (*GMarshalFunc_ENUM__ENUM) (gpointer data1,
2430 gint arg1,
2431 gpointer data2);
2432 GCClosure *cc = (GCClosure *) closure;
2433 gpointer data1, data2;
2434 GMarshalFunc_ENUM__ENUM callback;
2435 gint v_return;
2436
2437 g_return_if_fail (return_value != NULL);
2438 g_return_if_fail (n_param_values == 2);
2439
2440 if (G_CCLOSURE_SWAP_DATA (closure))
2441 {
2442 data1 = closure->data;
2443 data2 = g_value_peek_pointer (param_values + 0);
2444 }
2445 else
2446 {
2447 data1 = g_value_peek_pointer (param_values + 0);
2448 data2 = closure->data;
2449 }
2450 callback = (GMarshalFunc_ENUM__ENUM) (marshal_data ? marshal_data : cc->callback);
2451
2452 v_return = callback (data1,
2453 g_marshal_value_peek_enum (param_values + 1),
2454 data2);
2455
2456 g_value_set_enum (return_value, v_return);
2457 }
2458
2459 void
_gtk_marshal_ENUM__ENUMv(GClosure * closure,GValue * return_value,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)2460 _gtk_marshal_ENUM__ENUMv (GClosure *closure,
2461 GValue *return_value,
2462 gpointer instance,
2463 va_list args,
2464 gpointer marshal_data,
2465 int n_params,
2466 GType *param_types)
2467 {
2468 typedef gint (*GMarshalFunc_ENUM__ENUM) (gpointer data1,
2469 gint arg1,
2470 gpointer data2);
2471 GCClosure *cc = (GCClosure *) closure;
2472 gpointer data1, data2;
2473 GMarshalFunc_ENUM__ENUM callback;
2474 gint v_return;
2475 gint arg0;
2476 va_list args_copy;
2477
2478 G_VA_COPY (args_copy, args);
2479 arg0 = (gint) va_arg (args_copy, gint);
2480 va_end (args_copy);
2481
2482 g_return_if_fail (return_value != NULL);
2483
2484 if (G_CCLOSURE_SWAP_DATA (closure))
2485 {
2486 data1 = closure->data;
2487 data2 = instance;
2488 }
2489 else
2490 {
2491 data1 = instance;
2492 data2 = closure->data;
2493 }
2494 callback = (GMarshalFunc_ENUM__ENUM) (marshal_data ? marshal_data : cc->callback);
2495
2496 v_return = callback (data1,
2497 arg0,
2498 data2);
2499
2500
2501 g_value_set_enum (return_value, v_return);
2502 }
2503
2504 /* ENUM:VOID (./gtkmarshalers.list:52) */
2505 void
_gtk_marshal_ENUM__VOID(GClosure * closure,GValue * return_value,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)2506 _gtk_marshal_ENUM__VOID (GClosure *closure,
2507 GValue *return_value,
2508 guint n_param_values,
2509 const GValue *param_values,
2510 gpointer invocation_hint G_GNUC_UNUSED,
2511 gpointer marshal_data)
2512 {
2513 typedef gint (*GMarshalFunc_ENUM__VOID) (gpointer data1,
2514 gpointer data2);
2515 GCClosure *cc = (GCClosure *) closure;
2516 gpointer data1, data2;
2517 GMarshalFunc_ENUM__VOID callback;
2518 gint v_return;
2519
2520 g_return_if_fail (return_value != NULL);
2521 g_return_if_fail (n_param_values == 1);
2522
2523 if (G_CCLOSURE_SWAP_DATA (closure))
2524 {
2525 data1 = closure->data;
2526 data2 = g_value_peek_pointer (param_values + 0);
2527 }
2528 else
2529 {
2530 data1 = g_value_peek_pointer (param_values + 0);
2531 data2 = closure->data;
2532 }
2533 callback = (GMarshalFunc_ENUM__VOID) (marshal_data ? marshal_data : cc->callback);
2534
2535 v_return = callback (data1,
2536 data2);
2537
2538 g_value_set_enum (return_value, v_return);
2539 }
2540
2541 void
_gtk_marshal_ENUM__VOIDv(GClosure * closure,GValue * return_value,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)2542 _gtk_marshal_ENUM__VOIDv (GClosure *closure,
2543 GValue *return_value,
2544 gpointer instance,
2545 va_list args,
2546 gpointer marshal_data,
2547 int n_params,
2548 GType *param_types)
2549 {
2550 typedef gint (*GMarshalFunc_ENUM__VOID) (gpointer data1,
2551 gpointer data2);
2552 GCClosure *cc = (GCClosure *) closure;
2553 gpointer data1, data2;
2554 GMarshalFunc_ENUM__VOID callback;
2555 gint v_return;
2556
2557 g_return_if_fail (return_value != NULL);
2558
2559 if (G_CCLOSURE_SWAP_DATA (closure))
2560 {
2561 data1 = closure->data;
2562 data2 = instance;
2563 }
2564 else
2565 {
2566 data1 = instance;
2567 data2 = closure->data;
2568 }
2569 callback = (GMarshalFunc_ENUM__VOID) (marshal_data ? marshal_data : cc->callback);
2570
2571 v_return = callback (data1,
2572 data2);
2573
2574
2575 g_value_set_enum (return_value, v_return);
2576 }
2577
2578 /* INT:POINTER (./gtkmarshalers.list:53) */
2579 void
_gtk_marshal_INT__POINTER(GClosure * closure,GValue * return_value,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)2580 _gtk_marshal_INT__POINTER (GClosure *closure,
2581 GValue *return_value,
2582 guint n_param_values,
2583 const GValue *param_values,
2584 gpointer invocation_hint G_GNUC_UNUSED,
2585 gpointer marshal_data)
2586 {
2587 typedef gint (*GMarshalFunc_INT__POINTER) (gpointer data1,
2588 gpointer arg1,
2589 gpointer data2);
2590 GCClosure *cc = (GCClosure *) closure;
2591 gpointer data1, data2;
2592 GMarshalFunc_INT__POINTER callback;
2593 gint v_return;
2594
2595 g_return_if_fail (return_value != NULL);
2596 g_return_if_fail (n_param_values == 2);
2597
2598 if (G_CCLOSURE_SWAP_DATA (closure))
2599 {
2600 data1 = closure->data;
2601 data2 = g_value_peek_pointer (param_values + 0);
2602 }
2603 else
2604 {
2605 data1 = g_value_peek_pointer (param_values + 0);
2606 data2 = closure->data;
2607 }
2608 callback = (GMarshalFunc_INT__POINTER) (marshal_data ? marshal_data : cc->callback);
2609
2610 v_return = callback (data1,
2611 g_marshal_value_peek_pointer (param_values + 1),
2612 data2);
2613
2614 g_value_set_int (return_value, v_return);
2615 }
2616
2617 void
_gtk_marshal_INT__POINTERv(GClosure * closure,GValue * return_value,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)2618 _gtk_marshal_INT__POINTERv (GClosure *closure,
2619 GValue *return_value,
2620 gpointer instance,
2621 va_list args,
2622 gpointer marshal_data,
2623 int n_params,
2624 GType *param_types)
2625 {
2626 typedef gint (*GMarshalFunc_INT__POINTER) (gpointer data1,
2627 gpointer arg1,
2628 gpointer data2);
2629 GCClosure *cc = (GCClosure *) closure;
2630 gpointer data1, data2;
2631 GMarshalFunc_INT__POINTER callback;
2632 gint v_return;
2633 gpointer arg0;
2634 va_list args_copy;
2635
2636 G_VA_COPY (args_copy, args);
2637 arg0 = (gpointer) va_arg (args_copy, gpointer);
2638 va_end (args_copy);
2639
2640 g_return_if_fail (return_value != NULL);
2641
2642 if (G_CCLOSURE_SWAP_DATA (closure))
2643 {
2644 data1 = closure->data;
2645 data2 = instance;
2646 }
2647 else
2648 {
2649 data1 = instance;
2650 data2 = closure->data;
2651 }
2652 callback = (GMarshalFunc_INT__POINTER) (marshal_data ? marshal_data : cc->callback);
2653
2654 v_return = callback (data1,
2655 arg0,
2656 data2);
2657
2658
2659 g_value_set_int (return_value, v_return);
2660 }
2661
2662 /* OBJECT:VOID (./gtkmarshalers.list:54) */
2663 void
_gtk_marshal_OBJECT__VOID(GClosure * closure,GValue * return_value,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)2664 _gtk_marshal_OBJECT__VOID (GClosure *closure,
2665 GValue *return_value,
2666 guint n_param_values,
2667 const GValue *param_values,
2668 gpointer invocation_hint G_GNUC_UNUSED,
2669 gpointer marshal_data)
2670 {
2671 typedef GObject* (*GMarshalFunc_OBJECT__VOID) (gpointer data1,
2672 gpointer data2);
2673 GCClosure *cc = (GCClosure *) closure;
2674 gpointer data1, data2;
2675 GMarshalFunc_OBJECT__VOID callback;
2676 GObject* v_return;
2677
2678 g_return_if_fail (return_value != NULL);
2679 g_return_if_fail (n_param_values == 1);
2680
2681 if (G_CCLOSURE_SWAP_DATA (closure))
2682 {
2683 data1 = closure->data;
2684 data2 = g_value_peek_pointer (param_values + 0);
2685 }
2686 else
2687 {
2688 data1 = g_value_peek_pointer (param_values + 0);
2689 data2 = closure->data;
2690 }
2691 callback = (GMarshalFunc_OBJECT__VOID) (marshal_data ? marshal_data : cc->callback);
2692
2693 v_return = callback (data1,
2694 data2);
2695
2696 g_value_take_object (return_value, v_return);
2697 }
2698
2699 void
_gtk_marshal_OBJECT__VOIDv(GClosure * closure,GValue * return_value,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)2700 _gtk_marshal_OBJECT__VOIDv (GClosure *closure,
2701 GValue *return_value,
2702 gpointer instance,
2703 va_list args,
2704 gpointer marshal_data,
2705 int n_params,
2706 GType *param_types)
2707 {
2708 typedef GObject* (*GMarshalFunc_OBJECT__VOID) (gpointer data1,
2709 gpointer data2);
2710 GCClosure *cc = (GCClosure *) closure;
2711 gpointer data1, data2;
2712 GMarshalFunc_OBJECT__VOID callback;
2713 GObject* v_return;
2714
2715 g_return_if_fail (return_value != NULL);
2716
2717 if (G_CCLOSURE_SWAP_DATA (closure))
2718 {
2719 data1 = closure->data;
2720 data2 = instance;
2721 }
2722 else
2723 {
2724 data1 = instance;
2725 data2 = closure->data;
2726 }
2727 callback = (GMarshalFunc_OBJECT__VOID) (marshal_data ? marshal_data : cc->callback);
2728
2729 v_return = callback (data1,
2730 data2);
2731
2732
2733 g_value_take_object (return_value, v_return);
2734 }
2735
2736 /* STRING:DOUBLE (./gtkmarshalers.list:55) */
2737 void
_gtk_marshal_STRING__DOUBLE(GClosure * closure,GValue * return_value,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)2738 _gtk_marshal_STRING__DOUBLE (GClosure *closure,
2739 GValue *return_value,
2740 guint n_param_values,
2741 const GValue *param_values,
2742 gpointer invocation_hint G_GNUC_UNUSED,
2743 gpointer marshal_data)
2744 {
2745 typedef gchar* (*GMarshalFunc_STRING__DOUBLE) (gpointer data1,
2746 gdouble arg1,
2747 gpointer data2);
2748 GCClosure *cc = (GCClosure *) closure;
2749 gpointer data1, data2;
2750 GMarshalFunc_STRING__DOUBLE callback;
2751 gchar* v_return;
2752
2753 g_return_if_fail (return_value != NULL);
2754 g_return_if_fail (n_param_values == 2);
2755
2756 if (G_CCLOSURE_SWAP_DATA (closure))
2757 {
2758 data1 = closure->data;
2759 data2 = g_value_peek_pointer (param_values + 0);
2760 }
2761 else
2762 {
2763 data1 = g_value_peek_pointer (param_values + 0);
2764 data2 = closure->data;
2765 }
2766 callback = (GMarshalFunc_STRING__DOUBLE) (marshal_data ? marshal_data : cc->callback);
2767
2768 v_return = callback (data1,
2769 g_marshal_value_peek_double (param_values + 1),
2770 data2);
2771
2772 g_value_take_string (return_value, v_return);
2773 }
2774
2775 void
_gtk_marshal_STRING__DOUBLEv(GClosure * closure,GValue * return_value,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)2776 _gtk_marshal_STRING__DOUBLEv (GClosure *closure,
2777 GValue *return_value,
2778 gpointer instance,
2779 va_list args,
2780 gpointer marshal_data,
2781 int n_params,
2782 GType *param_types)
2783 {
2784 typedef gchar* (*GMarshalFunc_STRING__DOUBLE) (gpointer data1,
2785 gdouble arg1,
2786 gpointer data2);
2787 GCClosure *cc = (GCClosure *) closure;
2788 gpointer data1, data2;
2789 GMarshalFunc_STRING__DOUBLE callback;
2790 gchar* v_return;
2791 gdouble arg0;
2792 va_list args_copy;
2793
2794 G_VA_COPY (args_copy, args);
2795 arg0 = (gdouble) va_arg (args_copy, gdouble);
2796 va_end (args_copy);
2797
2798 g_return_if_fail (return_value != NULL);
2799
2800 if (G_CCLOSURE_SWAP_DATA (closure))
2801 {
2802 data1 = closure->data;
2803 data2 = instance;
2804 }
2805 else
2806 {
2807 data1 = instance;
2808 data2 = closure->data;
2809 }
2810 callback = (GMarshalFunc_STRING__DOUBLE) (marshal_data ? marshal_data : cc->callback);
2811
2812 v_return = callback (data1,
2813 arg0,
2814 data2);
2815
2816
2817 g_value_take_string (return_value, v_return);
2818 }
2819
2820 /* STRING:STRING (./gtkmarshalers.list:56) */
2821 void
_gtk_marshal_STRING__STRING(GClosure * closure,GValue * return_value,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)2822 _gtk_marshal_STRING__STRING (GClosure *closure,
2823 GValue *return_value,
2824 guint n_param_values,
2825 const GValue *param_values,
2826 gpointer invocation_hint G_GNUC_UNUSED,
2827 gpointer marshal_data)
2828 {
2829 typedef gchar* (*GMarshalFunc_STRING__STRING) (gpointer data1,
2830 gpointer arg1,
2831 gpointer data2);
2832 GCClosure *cc = (GCClosure *) closure;
2833 gpointer data1, data2;
2834 GMarshalFunc_STRING__STRING callback;
2835 gchar* v_return;
2836
2837 g_return_if_fail (return_value != NULL);
2838 g_return_if_fail (n_param_values == 2);
2839
2840 if (G_CCLOSURE_SWAP_DATA (closure))
2841 {
2842 data1 = closure->data;
2843 data2 = g_value_peek_pointer (param_values + 0);
2844 }
2845 else
2846 {
2847 data1 = g_value_peek_pointer (param_values + 0);
2848 data2 = closure->data;
2849 }
2850 callback = (GMarshalFunc_STRING__STRING) (marshal_data ? marshal_data : cc->callback);
2851
2852 v_return = callback (data1,
2853 g_marshal_value_peek_string (param_values + 1),
2854 data2);
2855
2856 g_value_take_string (return_value, v_return);
2857 }
2858
2859 void
_gtk_marshal_STRING__STRINGv(GClosure * closure,GValue * return_value,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)2860 _gtk_marshal_STRING__STRINGv (GClosure *closure,
2861 GValue *return_value,
2862 gpointer instance,
2863 va_list args,
2864 gpointer marshal_data,
2865 int n_params,
2866 GType *param_types)
2867 {
2868 typedef gchar* (*GMarshalFunc_STRING__STRING) (gpointer data1,
2869 gpointer arg1,
2870 gpointer data2);
2871 GCClosure *cc = (GCClosure *) closure;
2872 gpointer data1, data2;
2873 GMarshalFunc_STRING__STRING callback;
2874 gchar* v_return;
2875 gpointer arg0;
2876 va_list args_copy;
2877
2878 G_VA_COPY (args_copy, args);
2879 arg0 = (gpointer) va_arg (args_copy, gpointer);
2880 if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
2881 arg0 = g_strdup (arg0);
2882 va_end (args_copy);
2883
2884 g_return_if_fail (return_value != NULL);
2885
2886 if (G_CCLOSURE_SWAP_DATA (closure))
2887 {
2888 data1 = closure->data;
2889 data2 = instance;
2890 }
2891 else
2892 {
2893 data1 = instance;
2894 data2 = closure->data;
2895 }
2896 callback = (GMarshalFunc_STRING__STRING) (marshal_data ? marshal_data : cc->callback);
2897
2898 v_return = callback (data1,
2899 arg0,
2900 data2);
2901 if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
2902 g_free (arg0);
2903
2904 g_value_take_string (return_value, v_return);
2905 }
2906
2907 /* VOID:DOUBLE,DOUBLE (./gtkmarshalers.list:57) */
2908 void
_gtk_marshal_VOID__DOUBLE_DOUBLE(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)2909 _gtk_marshal_VOID__DOUBLE_DOUBLE (GClosure *closure,
2910 GValue *return_value G_GNUC_UNUSED,
2911 guint n_param_values,
2912 const GValue *param_values,
2913 gpointer invocation_hint G_GNUC_UNUSED,
2914 gpointer marshal_data)
2915 {
2916 typedef void (*GMarshalFunc_VOID__DOUBLE_DOUBLE) (gpointer data1,
2917 gdouble arg1,
2918 gdouble arg2,
2919 gpointer data2);
2920 GCClosure *cc = (GCClosure *) closure;
2921 gpointer data1, data2;
2922 GMarshalFunc_VOID__DOUBLE_DOUBLE callback;
2923
2924 g_return_if_fail (n_param_values == 3);
2925
2926 if (G_CCLOSURE_SWAP_DATA (closure))
2927 {
2928 data1 = closure->data;
2929 data2 = g_value_peek_pointer (param_values + 0);
2930 }
2931 else
2932 {
2933 data1 = g_value_peek_pointer (param_values + 0);
2934 data2 = closure->data;
2935 }
2936 callback = (GMarshalFunc_VOID__DOUBLE_DOUBLE) (marshal_data ? marshal_data : cc->callback);
2937
2938 callback (data1,
2939 g_marshal_value_peek_double (param_values + 1),
2940 g_marshal_value_peek_double (param_values + 2),
2941 data2);
2942 }
2943
2944 void
_gtk_marshal_VOID__DOUBLE_DOUBLEv(GClosure * closure,GValue * return_value G_GNUC_UNUSED,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)2945 _gtk_marshal_VOID__DOUBLE_DOUBLEv (GClosure *closure,
2946 GValue *return_value G_GNUC_UNUSED,
2947 gpointer instance,
2948 va_list args,
2949 gpointer marshal_data,
2950 int n_params,
2951 GType *param_types)
2952 {
2953 typedef void (*GMarshalFunc_VOID__DOUBLE_DOUBLE) (gpointer data1,
2954 gdouble arg1,
2955 gdouble arg2,
2956 gpointer data2);
2957 GCClosure *cc = (GCClosure *) closure;
2958 gpointer data1, data2;
2959 GMarshalFunc_VOID__DOUBLE_DOUBLE callback;
2960 gdouble arg0;
2961 gdouble arg1;
2962 va_list args_copy;
2963
2964 G_VA_COPY (args_copy, args);
2965 arg0 = (gdouble) va_arg (args_copy, gdouble);
2966 arg1 = (gdouble) va_arg (args_copy, gdouble);
2967 va_end (args_copy);
2968
2969
2970 if (G_CCLOSURE_SWAP_DATA (closure))
2971 {
2972 data1 = closure->data;
2973 data2 = instance;
2974 }
2975 else
2976 {
2977 data1 = instance;
2978 data2 = closure->data;
2979 }
2980 callback = (GMarshalFunc_VOID__DOUBLE_DOUBLE) (marshal_data ? marshal_data : cc->callback);
2981
2982 callback (data1,
2983 arg0,
2984 arg1,
2985 data2);
2986
2987 }
2988
2989 /* VOID:BOOLEAN,BOOLEAN,BOOLEAN (./gtkmarshalers.list:58) */
2990 void
_gtk_marshal_VOID__BOOLEAN_BOOLEAN_BOOLEAN(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)2991 _gtk_marshal_VOID__BOOLEAN_BOOLEAN_BOOLEAN (GClosure *closure,
2992 GValue *return_value G_GNUC_UNUSED,
2993 guint n_param_values,
2994 const GValue *param_values,
2995 gpointer invocation_hint G_GNUC_UNUSED,
2996 gpointer marshal_data)
2997 {
2998 typedef void (*GMarshalFunc_VOID__BOOLEAN_BOOLEAN_BOOLEAN) (gpointer data1,
2999 gboolean arg1,
3000 gboolean arg2,
3001 gboolean arg3,
3002 gpointer data2);
3003 GCClosure *cc = (GCClosure *) closure;
3004 gpointer data1, data2;
3005 GMarshalFunc_VOID__BOOLEAN_BOOLEAN_BOOLEAN callback;
3006
3007 g_return_if_fail (n_param_values == 4);
3008
3009 if (G_CCLOSURE_SWAP_DATA (closure))
3010 {
3011 data1 = closure->data;
3012 data2 = g_value_peek_pointer (param_values + 0);
3013 }
3014 else
3015 {
3016 data1 = g_value_peek_pointer (param_values + 0);
3017 data2 = closure->data;
3018 }
3019 callback = (GMarshalFunc_VOID__BOOLEAN_BOOLEAN_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
3020
3021 callback (data1,
3022 g_marshal_value_peek_boolean (param_values + 1),
3023 g_marshal_value_peek_boolean (param_values + 2),
3024 g_marshal_value_peek_boolean (param_values + 3),
3025 data2);
3026 }
3027
3028 void
_gtk_marshal_VOID__BOOLEAN_BOOLEAN_BOOLEANv(GClosure * closure,GValue * return_value G_GNUC_UNUSED,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)3029 _gtk_marshal_VOID__BOOLEAN_BOOLEAN_BOOLEANv (GClosure *closure,
3030 GValue *return_value G_GNUC_UNUSED,
3031 gpointer instance,
3032 va_list args,
3033 gpointer marshal_data,
3034 int n_params,
3035 GType *param_types)
3036 {
3037 typedef void (*GMarshalFunc_VOID__BOOLEAN_BOOLEAN_BOOLEAN) (gpointer data1,
3038 gboolean arg1,
3039 gboolean arg2,
3040 gboolean arg3,
3041 gpointer data2);
3042 GCClosure *cc = (GCClosure *) closure;
3043 gpointer data1, data2;
3044 GMarshalFunc_VOID__BOOLEAN_BOOLEAN_BOOLEAN callback;
3045 gboolean arg0;
3046 gboolean arg1;
3047 gboolean arg2;
3048 va_list args_copy;
3049
3050 G_VA_COPY (args_copy, args);
3051 arg0 = (gboolean) va_arg (args_copy, gboolean);
3052 arg1 = (gboolean) va_arg (args_copy, gboolean);
3053 arg2 = (gboolean) va_arg (args_copy, gboolean);
3054 va_end (args_copy);
3055
3056
3057 if (G_CCLOSURE_SWAP_DATA (closure))
3058 {
3059 data1 = closure->data;
3060 data2 = instance;
3061 }
3062 else
3063 {
3064 data1 = instance;
3065 data2 = closure->data;
3066 }
3067 callback = (GMarshalFunc_VOID__BOOLEAN_BOOLEAN_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
3068
3069 callback (data1,
3070 arg0,
3071 arg1,
3072 arg2,
3073 data2);
3074
3075 }
3076
3077 /* VOID:BOXED,BOXED (./gtkmarshalers.list:59) */
3078 void
_gtk_marshal_VOID__BOXED_BOXED(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)3079 _gtk_marshal_VOID__BOXED_BOXED (GClosure *closure,
3080 GValue *return_value G_GNUC_UNUSED,
3081 guint n_param_values,
3082 const GValue *param_values,
3083 gpointer invocation_hint G_GNUC_UNUSED,
3084 gpointer marshal_data)
3085 {
3086 typedef void (*GMarshalFunc_VOID__BOXED_BOXED) (gpointer data1,
3087 gpointer arg1,
3088 gpointer arg2,
3089 gpointer data2);
3090 GCClosure *cc = (GCClosure *) closure;
3091 gpointer data1, data2;
3092 GMarshalFunc_VOID__BOXED_BOXED callback;
3093
3094 g_return_if_fail (n_param_values == 3);
3095
3096 if (G_CCLOSURE_SWAP_DATA (closure))
3097 {
3098 data1 = closure->data;
3099 data2 = g_value_peek_pointer (param_values + 0);
3100 }
3101 else
3102 {
3103 data1 = g_value_peek_pointer (param_values + 0);
3104 data2 = closure->data;
3105 }
3106 callback = (GMarshalFunc_VOID__BOXED_BOXED) (marshal_data ? marshal_data : cc->callback);
3107
3108 callback (data1,
3109 g_marshal_value_peek_boxed (param_values + 1),
3110 g_marshal_value_peek_boxed (param_values + 2),
3111 data2);
3112 }
3113
3114 void
_gtk_marshal_VOID__BOXED_BOXEDv(GClosure * closure,GValue * return_value G_GNUC_UNUSED,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)3115 _gtk_marshal_VOID__BOXED_BOXEDv (GClosure *closure,
3116 GValue *return_value G_GNUC_UNUSED,
3117 gpointer instance,
3118 va_list args,
3119 gpointer marshal_data,
3120 int n_params,
3121 GType *param_types)
3122 {
3123 typedef void (*GMarshalFunc_VOID__BOXED_BOXED) (gpointer data1,
3124 gpointer arg1,
3125 gpointer arg2,
3126 gpointer data2);
3127 GCClosure *cc = (GCClosure *) closure;
3128 gpointer data1, data2;
3129 GMarshalFunc_VOID__BOXED_BOXED callback;
3130 gpointer arg0;
3131 gpointer arg1;
3132 va_list args_copy;
3133
3134 G_VA_COPY (args_copy, args);
3135 arg0 = (gpointer) va_arg (args_copy, gpointer);
3136 if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
3137 arg0 = g_boxed_copy (param_types[0] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg0);
3138 arg1 = (gpointer) va_arg (args_copy, gpointer);
3139 if ((param_types[1] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg1 != NULL)
3140 arg1 = g_boxed_copy (param_types[1] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg1);
3141 va_end (args_copy);
3142
3143
3144 if (G_CCLOSURE_SWAP_DATA (closure))
3145 {
3146 data1 = closure->data;
3147 data2 = instance;
3148 }
3149 else
3150 {
3151 data1 = instance;
3152 data2 = closure->data;
3153 }
3154 callback = (GMarshalFunc_VOID__BOXED_BOXED) (marshal_data ? marshal_data : cc->callback);
3155
3156 callback (data1,
3157 arg0,
3158 arg1,
3159 data2);
3160 if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
3161 g_boxed_free (param_types[0] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg0);
3162 if ((param_types[1] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg1 != NULL)
3163 g_boxed_free (param_types[1] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg1);
3164 }
3165
3166 /* VOID:BOXED,BOXED,POINTER (./gtkmarshalers.list:60) */
3167 void
_gtk_marshal_VOID__BOXED_BOXED_POINTER(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)3168 _gtk_marshal_VOID__BOXED_BOXED_POINTER (GClosure *closure,
3169 GValue *return_value G_GNUC_UNUSED,
3170 guint n_param_values,
3171 const GValue *param_values,
3172 gpointer invocation_hint G_GNUC_UNUSED,
3173 gpointer marshal_data)
3174 {
3175 typedef void (*GMarshalFunc_VOID__BOXED_BOXED_POINTER) (gpointer data1,
3176 gpointer arg1,
3177 gpointer arg2,
3178 gpointer arg3,
3179 gpointer data2);
3180 GCClosure *cc = (GCClosure *) closure;
3181 gpointer data1, data2;
3182 GMarshalFunc_VOID__BOXED_BOXED_POINTER callback;
3183
3184 g_return_if_fail (n_param_values == 4);
3185
3186 if (G_CCLOSURE_SWAP_DATA (closure))
3187 {
3188 data1 = closure->data;
3189 data2 = g_value_peek_pointer (param_values + 0);
3190 }
3191 else
3192 {
3193 data1 = g_value_peek_pointer (param_values + 0);
3194 data2 = closure->data;
3195 }
3196 callback = (GMarshalFunc_VOID__BOXED_BOXED_POINTER) (marshal_data ? marshal_data : cc->callback);
3197
3198 callback (data1,
3199 g_marshal_value_peek_boxed (param_values + 1),
3200 g_marshal_value_peek_boxed (param_values + 2),
3201 g_marshal_value_peek_pointer (param_values + 3),
3202 data2);
3203 }
3204
3205 void
_gtk_marshal_VOID__BOXED_BOXED_POINTERv(GClosure * closure,GValue * return_value G_GNUC_UNUSED,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)3206 _gtk_marshal_VOID__BOXED_BOXED_POINTERv (GClosure *closure,
3207 GValue *return_value G_GNUC_UNUSED,
3208 gpointer instance,
3209 va_list args,
3210 gpointer marshal_data,
3211 int n_params,
3212 GType *param_types)
3213 {
3214 typedef void (*GMarshalFunc_VOID__BOXED_BOXED_POINTER) (gpointer data1,
3215 gpointer arg1,
3216 gpointer arg2,
3217 gpointer arg3,
3218 gpointer data2);
3219 GCClosure *cc = (GCClosure *) closure;
3220 gpointer data1, data2;
3221 GMarshalFunc_VOID__BOXED_BOXED_POINTER callback;
3222 gpointer arg0;
3223 gpointer arg1;
3224 gpointer arg2;
3225 va_list args_copy;
3226
3227 G_VA_COPY (args_copy, args);
3228 arg0 = (gpointer) va_arg (args_copy, gpointer);
3229 if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
3230 arg0 = g_boxed_copy (param_types[0] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg0);
3231 arg1 = (gpointer) va_arg (args_copy, gpointer);
3232 if ((param_types[1] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg1 != NULL)
3233 arg1 = g_boxed_copy (param_types[1] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg1);
3234 arg2 = (gpointer) va_arg (args_copy, gpointer);
3235 va_end (args_copy);
3236
3237
3238 if (G_CCLOSURE_SWAP_DATA (closure))
3239 {
3240 data1 = closure->data;
3241 data2 = instance;
3242 }
3243 else
3244 {
3245 data1 = instance;
3246 data2 = closure->data;
3247 }
3248 callback = (GMarshalFunc_VOID__BOXED_BOXED_POINTER) (marshal_data ? marshal_data : cc->callback);
3249
3250 callback (data1,
3251 arg0,
3252 arg1,
3253 arg2,
3254 data2);
3255 if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
3256 g_boxed_free (param_types[0] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg0);
3257 if ((param_types[1] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg1 != NULL)
3258 g_boxed_free (param_types[1] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg1);
3259 }
3260
3261 /* VOID:BOXED,ENUM (./gtkmarshalers.list:61) */
3262 void
_gtk_marshal_VOID__BOXED_ENUM(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)3263 _gtk_marshal_VOID__BOXED_ENUM (GClosure *closure,
3264 GValue *return_value G_GNUC_UNUSED,
3265 guint n_param_values,
3266 const GValue *param_values,
3267 gpointer invocation_hint G_GNUC_UNUSED,
3268 gpointer marshal_data)
3269 {
3270 typedef void (*GMarshalFunc_VOID__BOXED_ENUM) (gpointer data1,
3271 gpointer arg1,
3272 gint arg2,
3273 gpointer data2);
3274 GCClosure *cc = (GCClosure *) closure;
3275 gpointer data1, data2;
3276 GMarshalFunc_VOID__BOXED_ENUM callback;
3277
3278 g_return_if_fail (n_param_values == 3);
3279
3280 if (G_CCLOSURE_SWAP_DATA (closure))
3281 {
3282 data1 = closure->data;
3283 data2 = g_value_peek_pointer (param_values + 0);
3284 }
3285 else
3286 {
3287 data1 = g_value_peek_pointer (param_values + 0);
3288 data2 = closure->data;
3289 }
3290 callback = (GMarshalFunc_VOID__BOXED_ENUM) (marshal_data ? marshal_data : cc->callback);
3291
3292 callback (data1,
3293 g_marshal_value_peek_boxed (param_values + 1),
3294 g_marshal_value_peek_enum (param_values + 2),
3295 data2);
3296 }
3297
3298 void
_gtk_marshal_VOID__BOXED_ENUMv(GClosure * closure,GValue * return_value G_GNUC_UNUSED,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)3299 _gtk_marshal_VOID__BOXED_ENUMv (GClosure *closure,
3300 GValue *return_value G_GNUC_UNUSED,
3301 gpointer instance,
3302 va_list args,
3303 gpointer marshal_data,
3304 int n_params,
3305 GType *param_types)
3306 {
3307 typedef void (*GMarshalFunc_VOID__BOXED_ENUM) (gpointer data1,
3308 gpointer arg1,
3309 gint arg2,
3310 gpointer data2);
3311 GCClosure *cc = (GCClosure *) closure;
3312 gpointer data1, data2;
3313 GMarshalFunc_VOID__BOXED_ENUM callback;
3314 gpointer arg0;
3315 gint arg1;
3316 va_list args_copy;
3317
3318 G_VA_COPY (args_copy, args);
3319 arg0 = (gpointer) va_arg (args_copy, gpointer);
3320 if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
3321 arg0 = g_boxed_copy (param_types[0] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg0);
3322 arg1 = (gint) va_arg (args_copy, gint);
3323 va_end (args_copy);
3324
3325
3326 if (G_CCLOSURE_SWAP_DATA (closure))
3327 {
3328 data1 = closure->data;
3329 data2 = instance;
3330 }
3331 else
3332 {
3333 data1 = instance;
3334 data2 = closure->data;
3335 }
3336 callback = (GMarshalFunc_VOID__BOXED_ENUM) (marshal_data ? marshal_data : cc->callback);
3337
3338 callback (data1,
3339 arg0,
3340 arg1,
3341 data2);
3342 if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
3343 g_boxed_free (param_types[0] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg0);
3344 }
3345
3346 /* VOID:BOXED,OBJECT (./gtkmarshalers.list:62) */
3347 void
_gtk_marshal_VOID__BOXED_OBJECT(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)3348 _gtk_marshal_VOID__BOXED_OBJECT (GClosure *closure,
3349 GValue *return_value G_GNUC_UNUSED,
3350 guint n_param_values,
3351 const GValue *param_values,
3352 gpointer invocation_hint G_GNUC_UNUSED,
3353 gpointer marshal_data)
3354 {
3355 typedef void (*GMarshalFunc_VOID__BOXED_OBJECT) (gpointer data1,
3356 gpointer arg1,
3357 gpointer arg2,
3358 gpointer data2);
3359 GCClosure *cc = (GCClosure *) closure;
3360 gpointer data1, data2;
3361 GMarshalFunc_VOID__BOXED_OBJECT callback;
3362
3363 g_return_if_fail (n_param_values == 3);
3364
3365 if (G_CCLOSURE_SWAP_DATA (closure))
3366 {
3367 data1 = closure->data;
3368 data2 = g_value_peek_pointer (param_values + 0);
3369 }
3370 else
3371 {
3372 data1 = g_value_peek_pointer (param_values + 0);
3373 data2 = closure->data;
3374 }
3375 callback = (GMarshalFunc_VOID__BOXED_OBJECT) (marshal_data ? marshal_data : cc->callback);
3376
3377 callback (data1,
3378 g_marshal_value_peek_boxed (param_values + 1),
3379 g_marshal_value_peek_object (param_values + 2),
3380 data2);
3381 }
3382
3383 void
_gtk_marshal_VOID__BOXED_OBJECTv(GClosure * closure,GValue * return_value G_GNUC_UNUSED,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)3384 _gtk_marshal_VOID__BOXED_OBJECTv (GClosure *closure,
3385 GValue *return_value G_GNUC_UNUSED,
3386 gpointer instance,
3387 va_list args,
3388 gpointer marshal_data,
3389 int n_params,
3390 GType *param_types)
3391 {
3392 typedef void (*GMarshalFunc_VOID__BOXED_OBJECT) (gpointer data1,
3393 gpointer arg1,
3394 gpointer arg2,
3395 gpointer data2);
3396 GCClosure *cc = (GCClosure *) closure;
3397 gpointer data1, data2;
3398 GMarshalFunc_VOID__BOXED_OBJECT callback;
3399 gpointer arg0;
3400 gpointer arg1;
3401 va_list args_copy;
3402
3403 G_VA_COPY (args_copy, args);
3404 arg0 = (gpointer) va_arg (args_copy, gpointer);
3405 if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
3406 arg0 = g_boxed_copy (param_types[0] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg0);
3407 arg1 = (gpointer) va_arg (args_copy, gpointer);
3408 if (arg1 != NULL)
3409 arg1 = g_object_ref (arg1);
3410 va_end (args_copy);
3411
3412
3413 if (G_CCLOSURE_SWAP_DATA (closure))
3414 {
3415 data1 = closure->data;
3416 data2 = instance;
3417 }
3418 else
3419 {
3420 data1 = instance;
3421 data2 = closure->data;
3422 }
3423 callback = (GMarshalFunc_VOID__BOXED_OBJECT) (marshal_data ? marshal_data : cc->callback);
3424
3425 callback (data1,
3426 arg0,
3427 arg1,
3428 data2);
3429 if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
3430 g_boxed_free (param_types[0] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg0);
3431 if (arg1 != NULL)
3432 g_object_unref (arg1);
3433 }
3434
3435 /* VOID:BOXED,STRING,INT (./gtkmarshalers.list:63) */
3436 void
_gtk_marshal_VOID__BOXED_STRING_INT(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)3437 _gtk_marshal_VOID__BOXED_STRING_INT (GClosure *closure,
3438 GValue *return_value G_GNUC_UNUSED,
3439 guint n_param_values,
3440 const GValue *param_values,
3441 gpointer invocation_hint G_GNUC_UNUSED,
3442 gpointer marshal_data)
3443 {
3444 typedef void (*GMarshalFunc_VOID__BOXED_STRING_INT) (gpointer data1,
3445 gpointer arg1,
3446 gpointer arg2,
3447 gint arg3,
3448 gpointer data2);
3449 GCClosure *cc = (GCClosure *) closure;
3450 gpointer data1, data2;
3451 GMarshalFunc_VOID__BOXED_STRING_INT callback;
3452
3453 g_return_if_fail (n_param_values == 4);
3454
3455 if (G_CCLOSURE_SWAP_DATA (closure))
3456 {
3457 data1 = closure->data;
3458 data2 = g_value_peek_pointer (param_values + 0);
3459 }
3460 else
3461 {
3462 data1 = g_value_peek_pointer (param_values + 0);
3463 data2 = closure->data;
3464 }
3465 callback = (GMarshalFunc_VOID__BOXED_STRING_INT) (marshal_data ? marshal_data : cc->callback);
3466
3467 callback (data1,
3468 g_marshal_value_peek_boxed (param_values + 1),
3469 g_marshal_value_peek_string (param_values + 2),
3470 g_marshal_value_peek_int (param_values + 3),
3471 data2);
3472 }
3473
3474 void
_gtk_marshal_VOID__BOXED_STRING_INTv(GClosure * closure,GValue * return_value G_GNUC_UNUSED,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)3475 _gtk_marshal_VOID__BOXED_STRING_INTv (GClosure *closure,
3476 GValue *return_value G_GNUC_UNUSED,
3477 gpointer instance,
3478 va_list args,
3479 gpointer marshal_data,
3480 int n_params,
3481 GType *param_types)
3482 {
3483 typedef void (*GMarshalFunc_VOID__BOXED_STRING_INT) (gpointer data1,
3484 gpointer arg1,
3485 gpointer arg2,
3486 gint arg3,
3487 gpointer data2);
3488 GCClosure *cc = (GCClosure *) closure;
3489 gpointer data1, data2;
3490 GMarshalFunc_VOID__BOXED_STRING_INT callback;
3491 gpointer arg0;
3492 gpointer arg1;
3493 gint arg2;
3494 va_list args_copy;
3495
3496 G_VA_COPY (args_copy, args);
3497 arg0 = (gpointer) va_arg (args_copy, gpointer);
3498 if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
3499 arg0 = g_boxed_copy (param_types[0] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg0);
3500 arg1 = (gpointer) va_arg (args_copy, gpointer);
3501 if ((param_types[1] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg1 != NULL)
3502 arg1 = g_strdup (arg1);
3503 arg2 = (gint) va_arg (args_copy, gint);
3504 va_end (args_copy);
3505
3506
3507 if (G_CCLOSURE_SWAP_DATA (closure))
3508 {
3509 data1 = closure->data;
3510 data2 = instance;
3511 }
3512 else
3513 {
3514 data1 = instance;
3515 data2 = closure->data;
3516 }
3517 callback = (GMarshalFunc_VOID__BOXED_STRING_INT) (marshal_data ? marshal_data : cc->callback);
3518
3519 callback (data1,
3520 arg0,
3521 arg1,
3522 arg2,
3523 data2);
3524 if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
3525 g_boxed_free (param_types[0] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg0);
3526 if ((param_types[1] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg1 != NULL)
3527 g_free (arg1);
3528 }
3529
3530 /* VOID:BOXED,UINT (./gtkmarshalers.list:64) */
3531 void
_gtk_marshal_VOID__BOXED_UINT(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)3532 _gtk_marshal_VOID__BOXED_UINT (GClosure *closure,
3533 GValue *return_value G_GNUC_UNUSED,
3534 guint n_param_values,
3535 const GValue *param_values,
3536 gpointer invocation_hint G_GNUC_UNUSED,
3537 gpointer marshal_data)
3538 {
3539 typedef void (*GMarshalFunc_VOID__BOXED_UINT) (gpointer data1,
3540 gpointer arg1,
3541 guint arg2,
3542 gpointer data2);
3543 GCClosure *cc = (GCClosure *) closure;
3544 gpointer data1, data2;
3545 GMarshalFunc_VOID__BOXED_UINT callback;
3546
3547 g_return_if_fail (n_param_values == 3);
3548
3549 if (G_CCLOSURE_SWAP_DATA (closure))
3550 {
3551 data1 = closure->data;
3552 data2 = g_value_peek_pointer (param_values + 0);
3553 }
3554 else
3555 {
3556 data1 = g_value_peek_pointer (param_values + 0);
3557 data2 = closure->data;
3558 }
3559 callback = (GMarshalFunc_VOID__BOXED_UINT) (marshal_data ? marshal_data : cc->callback);
3560
3561 callback (data1,
3562 g_marshal_value_peek_boxed (param_values + 1),
3563 g_marshal_value_peek_uint (param_values + 2),
3564 data2);
3565 }
3566
3567 void
_gtk_marshal_VOID__BOXED_UINTv(GClosure * closure,GValue * return_value G_GNUC_UNUSED,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)3568 _gtk_marshal_VOID__BOXED_UINTv (GClosure *closure,
3569 GValue *return_value G_GNUC_UNUSED,
3570 gpointer instance,
3571 va_list args,
3572 gpointer marshal_data,
3573 int n_params,
3574 GType *param_types)
3575 {
3576 typedef void (*GMarshalFunc_VOID__BOXED_UINT) (gpointer data1,
3577 gpointer arg1,
3578 guint arg2,
3579 gpointer data2);
3580 GCClosure *cc = (GCClosure *) closure;
3581 gpointer data1, data2;
3582 GMarshalFunc_VOID__BOXED_UINT callback;
3583 gpointer arg0;
3584 guint arg1;
3585 va_list args_copy;
3586
3587 G_VA_COPY (args_copy, args);
3588 arg0 = (gpointer) va_arg (args_copy, gpointer);
3589 if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
3590 arg0 = g_boxed_copy (param_types[0] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg0);
3591 arg1 = (guint) va_arg (args_copy, guint);
3592 va_end (args_copy);
3593
3594
3595 if (G_CCLOSURE_SWAP_DATA (closure))
3596 {
3597 data1 = closure->data;
3598 data2 = instance;
3599 }
3600 else
3601 {
3602 data1 = instance;
3603 data2 = closure->data;
3604 }
3605 callback = (GMarshalFunc_VOID__BOXED_UINT) (marshal_data ? marshal_data : cc->callback);
3606
3607 callback (data1,
3608 arg0,
3609 arg1,
3610 data2);
3611 if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
3612 g_boxed_free (param_types[0] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg0);
3613 }
3614
3615 /* VOID:BOXED,UINT,FLAGS (./gtkmarshalers.list:65) */
3616 void
_gtk_marshal_VOID__BOXED_UINT_FLAGS(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)3617 _gtk_marshal_VOID__BOXED_UINT_FLAGS (GClosure *closure,
3618 GValue *return_value G_GNUC_UNUSED,
3619 guint n_param_values,
3620 const GValue *param_values,
3621 gpointer invocation_hint G_GNUC_UNUSED,
3622 gpointer marshal_data)
3623 {
3624 typedef void (*GMarshalFunc_VOID__BOXED_UINT_FLAGS) (gpointer data1,
3625 gpointer arg1,
3626 guint arg2,
3627 guint arg3,
3628 gpointer data2);
3629 GCClosure *cc = (GCClosure *) closure;
3630 gpointer data1, data2;
3631 GMarshalFunc_VOID__BOXED_UINT_FLAGS callback;
3632
3633 g_return_if_fail (n_param_values == 4);
3634
3635 if (G_CCLOSURE_SWAP_DATA (closure))
3636 {
3637 data1 = closure->data;
3638 data2 = g_value_peek_pointer (param_values + 0);
3639 }
3640 else
3641 {
3642 data1 = g_value_peek_pointer (param_values + 0);
3643 data2 = closure->data;
3644 }
3645 callback = (GMarshalFunc_VOID__BOXED_UINT_FLAGS) (marshal_data ? marshal_data : cc->callback);
3646
3647 callback (data1,
3648 g_marshal_value_peek_boxed (param_values + 1),
3649 g_marshal_value_peek_uint (param_values + 2),
3650 g_marshal_value_peek_flags (param_values + 3),
3651 data2);
3652 }
3653
3654 void
_gtk_marshal_VOID__BOXED_UINT_FLAGSv(GClosure * closure,GValue * return_value G_GNUC_UNUSED,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)3655 _gtk_marshal_VOID__BOXED_UINT_FLAGSv (GClosure *closure,
3656 GValue *return_value G_GNUC_UNUSED,
3657 gpointer instance,
3658 va_list args,
3659 gpointer marshal_data,
3660 int n_params,
3661 GType *param_types)
3662 {
3663 typedef void (*GMarshalFunc_VOID__BOXED_UINT_FLAGS) (gpointer data1,
3664 gpointer arg1,
3665 guint arg2,
3666 guint arg3,
3667 gpointer data2);
3668 GCClosure *cc = (GCClosure *) closure;
3669 gpointer data1, data2;
3670 GMarshalFunc_VOID__BOXED_UINT_FLAGS callback;
3671 gpointer arg0;
3672 guint arg1;
3673 guint arg2;
3674 va_list args_copy;
3675
3676 G_VA_COPY (args_copy, args);
3677 arg0 = (gpointer) va_arg (args_copy, gpointer);
3678 if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
3679 arg0 = g_boxed_copy (param_types[0] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg0);
3680 arg1 = (guint) va_arg (args_copy, guint);
3681 arg2 = (guint) va_arg (args_copy, guint);
3682 va_end (args_copy);
3683
3684
3685 if (G_CCLOSURE_SWAP_DATA (closure))
3686 {
3687 data1 = closure->data;
3688 data2 = instance;
3689 }
3690 else
3691 {
3692 data1 = instance;
3693 data2 = closure->data;
3694 }
3695 callback = (GMarshalFunc_VOID__BOXED_UINT_FLAGS) (marshal_data ? marshal_data : cc->callback);
3696
3697 callback (data1,
3698 arg0,
3699 arg1,
3700 arg2,
3701 data2);
3702 if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
3703 g_boxed_free (param_types[0] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg0);
3704 }
3705
3706 /* VOID:BOXED,UINT,UINT (./gtkmarshalers.list:66) */
3707 void
_gtk_marshal_VOID__BOXED_UINT_UINT(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)3708 _gtk_marshal_VOID__BOXED_UINT_UINT (GClosure *closure,
3709 GValue *return_value G_GNUC_UNUSED,
3710 guint n_param_values,
3711 const GValue *param_values,
3712 gpointer invocation_hint G_GNUC_UNUSED,
3713 gpointer marshal_data)
3714 {
3715 typedef void (*GMarshalFunc_VOID__BOXED_UINT_UINT) (gpointer data1,
3716 gpointer arg1,
3717 guint arg2,
3718 guint arg3,
3719 gpointer data2);
3720 GCClosure *cc = (GCClosure *) closure;
3721 gpointer data1, data2;
3722 GMarshalFunc_VOID__BOXED_UINT_UINT callback;
3723
3724 g_return_if_fail (n_param_values == 4);
3725
3726 if (G_CCLOSURE_SWAP_DATA (closure))
3727 {
3728 data1 = closure->data;
3729 data2 = g_value_peek_pointer (param_values + 0);
3730 }
3731 else
3732 {
3733 data1 = g_value_peek_pointer (param_values + 0);
3734 data2 = closure->data;
3735 }
3736 callback = (GMarshalFunc_VOID__BOXED_UINT_UINT) (marshal_data ? marshal_data : cc->callback);
3737
3738 callback (data1,
3739 g_marshal_value_peek_boxed (param_values + 1),
3740 g_marshal_value_peek_uint (param_values + 2),
3741 g_marshal_value_peek_uint (param_values + 3),
3742 data2);
3743 }
3744
3745 void
_gtk_marshal_VOID__BOXED_UINT_UINTv(GClosure * closure,GValue * return_value G_GNUC_UNUSED,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)3746 _gtk_marshal_VOID__BOXED_UINT_UINTv (GClosure *closure,
3747 GValue *return_value G_GNUC_UNUSED,
3748 gpointer instance,
3749 va_list args,
3750 gpointer marshal_data,
3751 int n_params,
3752 GType *param_types)
3753 {
3754 typedef void (*GMarshalFunc_VOID__BOXED_UINT_UINT) (gpointer data1,
3755 gpointer arg1,
3756 guint arg2,
3757 guint arg3,
3758 gpointer data2);
3759 GCClosure *cc = (GCClosure *) closure;
3760 gpointer data1, data2;
3761 GMarshalFunc_VOID__BOXED_UINT_UINT callback;
3762 gpointer arg0;
3763 guint arg1;
3764 guint arg2;
3765 va_list args_copy;
3766
3767 G_VA_COPY (args_copy, args);
3768 arg0 = (gpointer) va_arg (args_copy, gpointer);
3769 if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
3770 arg0 = g_boxed_copy (param_types[0] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg0);
3771 arg1 = (guint) va_arg (args_copy, guint);
3772 arg2 = (guint) va_arg (args_copy, guint);
3773 va_end (args_copy);
3774
3775
3776 if (G_CCLOSURE_SWAP_DATA (closure))
3777 {
3778 data1 = closure->data;
3779 data2 = instance;
3780 }
3781 else
3782 {
3783 data1 = instance;
3784 data2 = closure->data;
3785 }
3786 callback = (GMarshalFunc_VOID__BOXED_UINT_UINT) (marshal_data ? marshal_data : cc->callback);
3787
3788 callback (data1,
3789 arg0,
3790 arg1,
3791 arg2,
3792 data2);
3793 if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
3794 g_boxed_free (param_types[0] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg0);
3795 }
3796
3797 /* VOID:ENUM,BOOLEAN (./gtkmarshalers.list:67) */
3798 void
_gtk_marshal_VOID__ENUM_BOOLEAN(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)3799 _gtk_marshal_VOID__ENUM_BOOLEAN (GClosure *closure,
3800 GValue *return_value G_GNUC_UNUSED,
3801 guint n_param_values,
3802 const GValue *param_values,
3803 gpointer invocation_hint G_GNUC_UNUSED,
3804 gpointer marshal_data)
3805 {
3806 typedef void (*GMarshalFunc_VOID__ENUM_BOOLEAN) (gpointer data1,
3807 gint arg1,
3808 gboolean arg2,
3809 gpointer data2);
3810 GCClosure *cc = (GCClosure *) closure;
3811 gpointer data1, data2;
3812 GMarshalFunc_VOID__ENUM_BOOLEAN callback;
3813
3814 g_return_if_fail (n_param_values == 3);
3815
3816 if (G_CCLOSURE_SWAP_DATA (closure))
3817 {
3818 data1 = closure->data;
3819 data2 = g_value_peek_pointer (param_values + 0);
3820 }
3821 else
3822 {
3823 data1 = g_value_peek_pointer (param_values + 0);
3824 data2 = closure->data;
3825 }
3826 callback = (GMarshalFunc_VOID__ENUM_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
3827
3828 callback (data1,
3829 g_marshal_value_peek_enum (param_values + 1),
3830 g_marshal_value_peek_boolean (param_values + 2),
3831 data2);
3832 }
3833
3834 void
_gtk_marshal_VOID__ENUM_BOOLEANv(GClosure * closure,GValue * return_value G_GNUC_UNUSED,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)3835 _gtk_marshal_VOID__ENUM_BOOLEANv (GClosure *closure,
3836 GValue *return_value G_GNUC_UNUSED,
3837 gpointer instance,
3838 va_list args,
3839 gpointer marshal_data,
3840 int n_params,
3841 GType *param_types)
3842 {
3843 typedef void (*GMarshalFunc_VOID__ENUM_BOOLEAN) (gpointer data1,
3844 gint arg1,
3845 gboolean arg2,
3846 gpointer data2);
3847 GCClosure *cc = (GCClosure *) closure;
3848 gpointer data1, data2;
3849 GMarshalFunc_VOID__ENUM_BOOLEAN callback;
3850 gint arg0;
3851 gboolean arg1;
3852 va_list args_copy;
3853
3854 G_VA_COPY (args_copy, args);
3855 arg0 = (gint) va_arg (args_copy, gint);
3856 arg1 = (gboolean) va_arg (args_copy, gboolean);
3857 va_end (args_copy);
3858
3859
3860 if (G_CCLOSURE_SWAP_DATA (closure))
3861 {
3862 data1 = closure->data;
3863 data2 = instance;
3864 }
3865 else
3866 {
3867 data1 = instance;
3868 data2 = closure->data;
3869 }
3870 callback = (GMarshalFunc_VOID__ENUM_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
3871
3872 callback (data1,
3873 arg0,
3874 arg1,
3875 data2);
3876
3877 }
3878
3879 /* VOID:ENUM,DOUBLE (./gtkmarshalers.list:68) */
3880 void
_gtk_marshal_VOID__ENUM_DOUBLE(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)3881 _gtk_marshal_VOID__ENUM_DOUBLE (GClosure *closure,
3882 GValue *return_value G_GNUC_UNUSED,
3883 guint n_param_values,
3884 const GValue *param_values,
3885 gpointer invocation_hint G_GNUC_UNUSED,
3886 gpointer marshal_data)
3887 {
3888 typedef void (*GMarshalFunc_VOID__ENUM_DOUBLE) (gpointer data1,
3889 gint arg1,
3890 gdouble arg2,
3891 gpointer data2);
3892 GCClosure *cc = (GCClosure *) closure;
3893 gpointer data1, data2;
3894 GMarshalFunc_VOID__ENUM_DOUBLE callback;
3895
3896 g_return_if_fail (n_param_values == 3);
3897
3898 if (G_CCLOSURE_SWAP_DATA (closure))
3899 {
3900 data1 = closure->data;
3901 data2 = g_value_peek_pointer (param_values + 0);
3902 }
3903 else
3904 {
3905 data1 = g_value_peek_pointer (param_values + 0);
3906 data2 = closure->data;
3907 }
3908 callback = (GMarshalFunc_VOID__ENUM_DOUBLE) (marshal_data ? marshal_data : cc->callback);
3909
3910 callback (data1,
3911 g_marshal_value_peek_enum (param_values + 1),
3912 g_marshal_value_peek_double (param_values + 2),
3913 data2);
3914 }
3915
3916 void
_gtk_marshal_VOID__ENUM_DOUBLEv(GClosure * closure,GValue * return_value G_GNUC_UNUSED,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)3917 _gtk_marshal_VOID__ENUM_DOUBLEv (GClosure *closure,
3918 GValue *return_value G_GNUC_UNUSED,
3919 gpointer instance,
3920 va_list args,
3921 gpointer marshal_data,
3922 int n_params,
3923 GType *param_types)
3924 {
3925 typedef void (*GMarshalFunc_VOID__ENUM_DOUBLE) (gpointer data1,
3926 gint arg1,
3927 gdouble arg2,
3928 gpointer data2);
3929 GCClosure *cc = (GCClosure *) closure;
3930 gpointer data1, data2;
3931 GMarshalFunc_VOID__ENUM_DOUBLE callback;
3932 gint arg0;
3933 gdouble arg1;
3934 va_list args_copy;
3935
3936 G_VA_COPY (args_copy, args);
3937 arg0 = (gint) va_arg (args_copy, gint);
3938 arg1 = (gdouble) va_arg (args_copy, gdouble);
3939 va_end (args_copy);
3940
3941
3942 if (G_CCLOSURE_SWAP_DATA (closure))
3943 {
3944 data1 = closure->data;
3945 data2 = instance;
3946 }
3947 else
3948 {
3949 data1 = instance;
3950 data2 = closure->data;
3951 }
3952 callback = (GMarshalFunc_VOID__ENUM_DOUBLE) (marshal_data ? marshal_data : cc->callback);
3953
3954 callback (data1,
3955 arg0,
3956 arg1,
3957 data2);
3958
3959 }
3960
3961 /* VOID:ENUM,ENUM (./gtkmarshalers.list:69) */
3962 void
_gtk_marshal_VOID__ENUM_ENUM(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)3963 _gtk_marshal_VOID__ENUM_ENUM (GClosure *closure,
3964 GValue *return_value G_GNUC_UNUSED,
3965 guint n_param_values,
3966 const GValue *param_values,
3967 gpointer invocation_hint G_GNUC_UNUSED,
3968 gpointer marshal_data)
3969 {
3970 typedef void (*GMarshalFunc_VOID__ENUM_ENUM) (gpointer data1,
3971 gint arg1,
3972 gint arg2,
3973 gpointer data2);
3974 GCClosure *cc = (GCClosure *) closure;
3975 gpointer data1, data2;
3976 GMarshalFunc_VOID__ENUM_ENUM callback;
3977
3978 g_return_if_fail (n_param_values == 3);
3979
3980 if (G_CCLOSURE_SWAP_DATA (closure))
3981 {
3982 data1 = closure->data;
3983 data2 = g_value_peek_pointer (param_values + 0);
3984 }
3985 else
3986 {
3987 data1 = g_value_peek_pointer (param_values + 0);
3988 data2 = closure->data;
3989 }
3990 callback = (GMarshalFunc_VOID__ENUM_ENUM) (marshal_data ? marshal_data : cc->callback);
3991
3992 callback (data1,
3993 g_marshal_value_peek_enum (param_values + 1),
3994 g_marshal_value_peek_enum (param_values + 2),
3995 data2);
3996 }
3997
3998 void
_gtk_marshal_VOID__ENUM_ENUMv(GClosure * closure,GValue * return_value G_GNUC_UNUSED,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)3999 _gtk_marshal_VOID__ENUM_ENUMv (GClosure *closure,
4000 GValue *return_value G_GNUC_UNUSED,
4001 gpointer instance,
4002 va_list args,
4003 gpointer marshal_data,
4004 int n_params,
4005 GType *param_types)
4006 {
4007 typedef void (*GMarshalFunc_VOID__ENUM_ENUM) (gpointer data1,
4008 gint arg1,
4009 gint arg2,
4010 gpointer data2);
4011 GCClosure *cc = (GCClosure *) closure;
4012 gpointer data1, data2;
4013 GMarshalFunc_VOID__ENUM_ENUM callback;
4014 gint arg0;
4015 gint arg1;
4016 va_list args_copy;
4017
4018 G_VA_COPY (args_copy, args);
4019 arg0 = (gint) va_arg (args_copy, gint);
4020 arg1 = (gint) va_arg (args_copy, gint);
4021 va_end (args_copy);
4022
4023
4024 if (G_CCLOSURE_SWAP_DATA (closure))
4025 {
4026 data1 = closure->data;
4027 data2 = instance;
4028 }
4029 else
4030 {
4031 data1 = instance;
4032 data2 = closure->data;
4033 }
4034 callback = (GMarshalFunc_VOID__ENUM_ENUM) (marshal_data ? marshal_data : cc->callback);
4035
4036 callback (data1,
4037 arg0,
4038 arg1,
4039 data2);
4040
4041 }
4042
4043 /* VOID:ENUM,FLOAT (./gtkmarshalers.list:70) */
4044 void
_gtk_marshal_VOID__ENUM_FLOAT(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)4045 _gtk_marshal_VOID__ENUM_FLOAT (GClosure *closure,
4046 GValue *return_value G_GNUC_UNUSED,
4047 guint n_param_values,
4048 const GValue *param_values,
4049 gpointer invocation_hint G_GNUC_UNUSED,
4050 gpointer marshal_data)
4051 {
4052 typedef void (*GMarshalFunc_VOID__ENUM_FLOAT) (gpointer data1,
4053 gint arg1,
4054 gfloat arg2,
4055 gpointer data2);
4056 GCClosure *cc = (GCClosure *) closure;
4057 gpointer data1, data2;
4058 GMarshalFunc_VOID__ENUM_FLOAT callback;
4059
4060 g_return_if_fail (n_param_values == 3);
4061
4062 if (G_CCLOSURE_SWAP_DATA (closure))
4063 {
4064 data1 = closure->data;
4065 data2 = g_value_peek_pointer (param_values + 0);
4066 }
4067 else
4068 {
4069 data1 = g_value_peek_pointer (param_values + 0);
4070 data2 = closure->data;
4071 }
4072 callback = (GMarshalFunc_VOID__ENUM_FLOAT) (marshal_data ? marshal_data : cc->callback);
4073
4074 callback (data1,
4075 g_marshal_value_peek_enum (param_values + 1),
4076 g_marshal_value_peek_float (param_values + 2),
4077 data2);
4078 }
4079
4080 void
_gtk_marshal_VOID__ENUM_FLOATv(GClosure * closure,GValue * return_value G_GNUC_UNUSED,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)4081 _gtk_marshal_VOID__ENUM_FLOATv (GClosure *closure,
4082 GValue *return_value G_GNUC_UNUSED,
4083 gpointer instance,
4084 va_list args,
4085 gpointer marshal_data,
4086 int n_params,
4087 GType *param_types)
4088 {
4089 typedef void (*GMarshalFunc_VOID__ENUM_FLOAT) (gpointer data1,
4090 gint arg1,
4091 gfloat arg2,
4092 gpointer data2);
4093 GCClosure *cc = (GCClosure *) closure;
4094 gpointer data1, data2;
4095 GMarshalFunc_VOID__ENUM_FLOAT callback;
4096 gint arg0;
4097 gfloat arg1;
4098 va_list args_copy;
4099
4100 G_VA_COPY (args_copy, args);
4101 arg0 = (gint) va_arg (args_copy, gint);
4102 arg1 = (gfloat) va_arg (args_copy, gdouble);
4103 va_end (args_copy);
4104
4105
4106 if (G_CCLOSURE_SWAP_DATA (closure))
4107 {
4108 data1 = closure->data;
4109 data2 = instance;
4110 }
4111 else
4112 {
4113 data1 = instance;
4114 data2 = closure->data;
4115 }
4116 callback = (GMarshalFunc_VOID__ENUM_FLOAT) (marshal_data ? marshal_data : cc->callback);
4117
4118 callback (data1,
4119 arg0,
4120 arg1,
4121 data2);
4122
4123 }
4124
4125 /* VOID:ENUM,FLOAT,BOOLEAN (./gtkmarshalers.list:71) */
4126 void
_gtk_marshal_VOID__ENUM_FLOAT_BOOLEAN(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)4127 _gtk_marshal_VOID__ENUM_FLOAT_BOOLEAN (GClosure *closure,
4128 GValue *return_value G_GNUC_UNUSED,
4129 guint n_param_values,
4130 const GValue *param_values,
4131 gpointer invocation_hint G_GNUC_UNUSED,
4132 gpointer marshal_data)
4133 {
4134 typedef void (*GMarshalFunc_VOID__ENUM_FLOAT_BOOLEAN) (gpointer data1,
4135 gint arg1,
4136 gfloat arg2,
4137 gboolean arg3,
4138 gpointer data2);
4139 GCClosure *cc = (GCClosure *) closure;
4140 gpointer data1, data2;
4141 GMarshalFunc_VOID__ENUM_FLOAT_BOOLEAN callback;
4142
4143 g_return_if_fail (n_param_values == 4);
4144
4145 if (G_CCLOSURE_SWAP_DATA (closure))
4146 {
4147 data1 = closure->data;
4148 data2 = g_value_peek_pointer (param_values + 0);
4149 }
4150 else
4151 {
4152 data1 = g_value_peek_pointer (param_values + 0);
4153 data2 = closure->data;
4154 }
4155 callback = (GMarshalFunc_VOID__ENUM_FLOAT_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
4156
4157 callback (data1,
4158 g_marshal_value_peek_enum (param_values + 1),
4159 g_marshal_value_peek_float (param_values + 2),
4160 g_marshal_value_peek_boolean (param_values + 3),
4161 data2);
4162 }
4163
4164 void
_gtk_marshal_VOID__ENUM_FLOAT_BOOLEANv(GClosure * closure,GValue * return_value G_GNUC_UNUSED,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)4165 _gtk_marshal_VOID__ENUM_FLOAT_BOOLEANv (GClosure *closure,
4166 GValue *return_value G_GNUC_UNUSED,
4167 gpointer instance,
4168 va_list args,
4169 gpointer marshal_data,
4170 int n_params,
4171 GType *param_types)
4172 {
4173 typedef void (*GMarshalFunc_VOID__ENUM_FLOAT_BOOLEAN) (gpointer data1,
4174 gint arg1,
4175 gfloat arg2,
4176 gboolean arg3,
4177 gpointer data2);
4178 GCClosure *cc = (GCClosure *) closure;
4179 gpointer data1, data2;
4180 GMarshalFunc_VOID__ENUM_FLOAT_BOOLEAN callback;
4181 gint arg0;
4182 gfloat arg1;
4183 gboolean arg2;
4184 va_list args_copy;
4185
4186 G_VA_COPY (args_copy, args);
4187 arg0 = (gint) va_arg (args_copy, gint);
4188 arg1 = (gfloat) va_arg (args_copy, gdouble);
4189 arg2 = (gboolean) va_arg (args_copy, gboolean);
4190 va_end (args_copy);
4191
4192
4193 if (G_CCLOSURE_SWAP_DATA (closure))
4194 {
4195 data1 = closure->data;
4196 data2 = instance;
4197 }
4198 else
4199 {
4200 data1 = instance;
4201 data2 = closure->data;
4202 }
4203 callback = (GMarshalFunc_VOID__ENUM_FLOAT_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
4204
4205 callback (data1,
4206 arg0,
4207 arg1,
4208 arg2,
4209 data2);
4210
4211 }
4212
4213 /* VOID:ENUM,INT (./gtkmarshalers.list:72) */
4214 void
_gtk_marshal_VOID__ENUM_INT(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)4215 _gtk_marshal_VOID__ENUM_INT (GClosure *closure,
4216 GValue *return_value G_GNUC_UNUSED,
4217 guint n_param_values,
4218 const GValue *param_values,
4219 gpointer invocation_hint G_GNUC_UNUSED,
4220 gpointer marshal_data)
4221 {
4222 typedef void (*GMarshalFunc_VOID__ENUM_INT) (gpointer data1,
4223 gint arg1,
4224 gint arg2,
4225 gpointer data2);
4226 GCClosure *cc = (GCClosure *) closure;
4227 gpointer data1, data2;
4228 GMarshalFunc_VOID__ENUM_INT callback;
4229
4230 g_return_if_fail (n_param_values == 3);
4231
4232 if (G_CCLOSURE_SWAP_DATA (closure))
4233 {
4234 data1 = closure->data;
4235 data2 = g_value_peek_pointer (param_values + 0);
4236 }
4237 else
4238 {
4239 data1 = g_value_peek_pointer (param_values + 0);
4240 data2 = closure->data;
4241 }
4242 callback = (GMarshalFunc_VOID__ENUM_INT) (marshal_data ? marshal_data : cc->callback);
4243
4244 callback (data1,
4245 g_marshal_value_peek_enum (param_values + 1),
4246 g_marshal_value_peek_int (param_values + 2),
4247 data2);
4248 }
4249
4250 void
_gtk_marshal_VOID__ENUM_INTv(GClosure * closure,GValue * return_value G_GNUC_UNUSED,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)4251 _gtk_marshal_VOID__ENUM_INTv (GClosure *closure,
4252 GValue *return_value G_GNUC_UNUSED,
4253 gpointer instance,
4254 va_list args,
4255 gpointer marshal_data,
4256 int n_params,
4257 GType *param_types)
4258 {
4259 typedef void (*GMarshalFunc_VOID__ENUM_INT) (gpointer data1,
4260 gint arg1,
4261 gint arg2,
4262 gpointer data2);
4263 GCClosure *cc = (GCClosure *) closure;
4264 gpointer data1, data2;
4265 GMarshalFunc_VOID__ENUM_INT callback;
4266 gint arg0;
4267 gint arg1;
4268 va_list args_copy;
4269
4270 G_VA_COPY (args_copy, args);
4271 arg0 = (gint) va_arg (args_copy, gint);
4272 arg1 = (gint) va_arg (args_copy, gint);
4273 va_end (args_copy);
4274
4275
4276 if (G_CCLOSURE_SWAP_DATA (closure))
4277 {
4278 data1 = closure->data;
4279 data2 = instance;
4280 }
4281 else
4282 {
4283 data1 = instance;
4284 data2 = closure->data;
4285 }
4286 callback = (GMarshalFunc_VOID__ENUM_INT) (marshal_data ? marshal_data : cc->callback);
4287
4288 callback (data1,
4289 arg0,
4290 arg1,
4291 data2);
4292
4293 }
4294
4295 /* VOID:ENUM,INT,BOOLEAN (./gtkmarshalers.list:73) */
4296 void
_gtk_marshal_VOID__ENUM_INT_BOOLEAN(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)4297 _gtk_marshal_VOID__ENUM_INT_BOOLEAN (GClosure *closure,
4298 GValue *return_value G_GNUC_UNUSED,
4299 guint n_param_values,
4300 const GValue *param_values,
4301 gpointer invocation_hint G_GNUC_UNUSED,
4302 gpointer marshal_data)
4303 {
4304 typedef void (*GMarshalFunc_VOID__ENUM_INT_BOOLEAN) (gpointer data1,
4305 gint arg1,
4306 gint arg2,
4307 gboolean arg3,
4308 gpointer data2);
4309 GCClosure *cc = (GCClosure *) closure;
4310 gpointer data1, data2;
4311 GMarshalFunc_VOID__ENUM_INT_BOOLEAN callback;
4312
4313 g_return_if_fail (n_param_values == 4);
4314
4315 if (G_CCLOSURE_SWAP_DATA (closure))
4316 {
4317 data1 = closure->data;
4318 data2 = g_value_peek_pointer (param_values + 0);
4319 }
4320 else
4321 {
4322 data1 = g_value_peek_pointer (param_values + 0);
4323 data2 = closure->data;
4324 }
4325 callback = (GMarshalFunc_VOID__ENUM_INT_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
4326
4327 callback (data1,
4328 g_marshal_value_peek_enum (param_values + 1),
4329 g_marshal_value_peek_int (param_values + 2),
4330 g_marshal_value_peek_boolean (param_values + 3),
4331 data2);
4332 }
4333
4334 void
_gtk_marshal_VOID__ENUM_INT_BOOLEANv(GClosure * closure,GValue * return_value G_GNUC_UNUSED,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)4335 _gtk_marshal_VOID__ENUM_INT_BOOLEANv (GClosure *closure,
4336 GValue *return_value G_GNUC_UNUSED,
4337 gpointer instance,
4338 va_list args,
4339 gpointer marshal_data,
4340 int n_params,
4341 GType *param_types)
4342 {
4343 typedef void (*GMarshalFunc_VOID__ENUM_INT_BOOLEAN) (gpointer data1,
4344 gint arg1,
4345 gint arg2,
4346 gboolean arg3,
4347 gpointer data2);
4348 GCClosure *cc = (GCClosure *) closure;
4349 gpointer data1, data2;
4350 GMarshalFunc_VOID__ENUM_INT_BOOLEAN callback;
4351 gint arg0;
4352 gint arg1;
4353 gboolean arg2;
4354 va_list args_copy;
4355
4356 G_VA_COPY (args_copy, args);
4357 arg0 = (gint) va_arg (args_copy, gint);
4358 arg1 = (gint) va_arg (args_copy, gint);
4359 arg2 = (gboolean) va_arg (args_copy, gboolean);
4360 va_end (args_copy);
4361
4362
4363 if (G_CCLOSURE_SWAP_DATA (closure))
4364 {
4365 data1 = closure->data;
4366 data2 = instance;
4367 }
4368 else
4369 {
4370 data1 = instance;
4371 data2 = closure->data;
4372 }
4373 callback = (GMarshalFunc_VOID__ENUM_INT_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
4374
4375 callback (data1,
4376 arg0,
4377 arg1,
4378 arg2,
4379 data2);
4380
4381 }
4382
4383 /* VOID:ENUM,INT,INT (./gtkmarshalers.list:74) */
4384 void
_gtk_marshal_VOID__ENUM_INT_INT(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)4385 _gtk_marshal_VOID__ENUM_INT_INT (GClosure *closure,
4386 GValue *return_value G_GNUC_UNUSED,
4387 guint n_param_values,
4388 const GValue *param_values,
4389 gpointer invocation_hint G_GNUC_UNUSED,
4390 gpointer marshal_data)
4391 {
4392 typedef void (*GMarshalFunc_VOID__ENUM_INT_INT) (gpointer data1,
4393 gint arg1,
4394 gint arg2,
4395 gint arg3,
4396 gpointer data2);
4397 GCClosure *cc = (GCClosure *) closure;
4398 gpointer data1, data2;
4399 GMarshalFunc_VOID__ENUM_INT_INT callback;
4400
4401 g_return_if_fail (n_param_values == 4);
4402
4403 if (G_CCLOSURE_SWAP_DATA (closure))
4404 {
4405 data1 = closure->data;
4406 data2 = g_value_peek_pointer (param_values + 0);
4407 }
4408 else
4409 {
4410 data1 = g_value_peek_pointer (param_values + 0);
4411 data2 = closure->data;
4412 }
4413 callback = (GMarshalFunc_VOID__ENUM_INT_INT) (marshal_data ? marshal_data : cc->callback);
4414
4415 callback (data1,
4416 g_marshal_value_peek_enum (param_values + 1),
4417 g_marshal_value_peek_int (param_values + 2),
4418 g_marshal_value_peek_int (param_values + 3),
4419 data2);
4420 }
4421
4422 void
_gtk_marshal_VOID__ENUM_INT_INTv(GClosure * closure,GValue * return_value G_GNUC_UNUSED,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)4423 _gtk_marshal_VOID__ENUM_INT_INTv (GClosure *closure,
4424 GValue *return_value G_GNUC_UNUSED,
4425 gpointer instance,
4426 va_list args,
4427 gpointer marshal_data,
4428 int n_params,
4429 GType *param_types)
4430 {
4431 typedef void (*GMarshalFunc_VOID__ENUM_INT_INT) (gpointer data1,
4432 gint arg1,
4433 gint arg2,
4434 gint arg3,
4435 gpointer data2);
4436 GCClosure *cc = (GCClosure *) closure;
4437 gpointer data1, data2;
4438 GMarshalFunc_VOID__ENUM_INT_INT callback;
4439 gint arg0;
4440 gint arg1;
4441 gint arg2;
4442 va_list args_copy;
4443
4444 G_VA_COPY (args_copy, args);
4445 arg0 = (gint) va_arg (args_copy, gint);
4446 arg1 = (gint) va_arg (args_copy, gint);
4447 arg2 = (gint) va_arg (args_copy, gint);
4448 va_end (args_copy);
4449
4450
4451 if (G_CCLOSURE_SWAP_DATA (closure))
4452 {
4453 data1 = closure->data;
4454 data2 = instance;
4455 }
4456 else
4457 {
4458 data1 = instance;
4459 data2 = closure->data;
4460 }
4461 callback = (GMarshalFunc_VOID__ENUM_INT_INT) (marshal_data ? marshal_data : cc->callback);
4462
4463 callback (data1,
4464 arg0,
4465 arg1,
4466 arg2,
4467 data2);
4468
4469 }
4470
4471 /* VOID:ENUM,BOXED (./gtkmarshalers.list:75) */
4472 void
_gtk_marshal_VOID__ENUM_BOXED(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)4473 _gtk_marshal_VOID__ENUM_BOXED (GClosure *closure,
4474 GValue *return_value G_GNUC_UNUSED,
4475 guint n_param_values,
4476 const GValue *param_values,
4477 gpointer invocation_hint G_GNUC_UNUSED,
4478 gpointer marshal_data)
4479 {
4480 typedef void (*GMarshalFunc_VOID__ENUM_BOXED) (gpointer data1,
4481 gint arg1,
4482 gpointer arg2,
4483 gpointer data2);
4484 GCClosure *cc = (GCClosure *) closure;
4485 gpointer data1, data2;
4486 GMarshalFunc_VOID__ENUM_BOXED callback;
4487
4488 g_return_if_fail (n_param_values == 3);
4489
4490 if (G_CCLOSURE_SWAP_DATA (closure))
4491 {
4492 data1 = closure->data;
4493 data2 = g_value_peek_pointer (param_values + 0);
4494 }
4495 else
4496 {
4497 data1 = g_value_peek_pointer (param_values + 0);
4498 data2 = closure->data;
4499 }
4500 callback = (GMarshalFunc_VOID__ENUM_BOXED) (marshal_data ? marshal_data : cc->callback);
4501
4502 callback (data1,
4503 g_marshal_value_peek_enum (param_values + 1),
4504 g_marshal_value_peek_boxed (param_values + 2),
4505 data2);
4506 }
4507
4508 void
_gtk_marshal_VOID__ENUM_BOXEDv(GClosure * closure,GValue * return_value G_GNUC_UNUSED,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)4509 _gtk_marshal_VOID__ENUM_BOXEDv (GClosure *closure,
4510 GValue *return_value G_GNUC_UNUSED,
4511 gpointer instance,
4512 va_list args,
4513 gpointer marshal_data,
4514 int n_params,
4515 GType *param_types)
4516 {
4517 typedef void (*GMarshalFunc_VOID__ENUM_BOXED) (gpointer data1,
4518 gint arg1,
4519 gpointer arg2,
4520 gpointer data2);
4521 GCClosure *cc = (GCClosure *) closure;
4522 gpointer data1, data2;
4523 GMarshalFunc_VOID__ENUM_BOXED callback;
4524 gint arg0;
4525 gpointer arg1;
4526 va_list args_copy;
4527
4528 G_VA_COPY (args_copy, args);
4529 arg0 = (gint) va_arg (args_copy, gint);
4530 arg1 = (gpointer) va_arg (args_copy, gpointer);
4531 if ((param_types[1] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg1 != NULL)
4532 arg1 = g_boxed_copy (param_types[1] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg1);
4533 va_end (args_copy);
4534
4535
4536 if (G_CCLOSURE_SWAP_DATA (closure))
4537 {
4538 data1 = closure->data;
4539 data2 = instance;
4540 }
4541 else
4542 {
4543 data1 = instance;
4544 data2 = closure->data;
4545 }
4546 callback = (GMarshalFunc_VOID__ENUM_BOXED) (marshal_data ? marshal_data : cc->callback);
4547
4548 callback (data1,
4549 arg0,
4550 arg1,
4551 data2);
4552 if ((param_types[1] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg1 != NULL)
4553 g_boxed_free (param_types[1] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg1);
4554 }
4555
4556 /* VOID:ENUM,STRING (./gtkmarshalers.list:76) */
4557 void
_gtk_marshal_VOID__ENUM_STRING(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)4558 _gtk_marshal_VOID__ENUM_STRING (GClosure *closure,
4559 GValue *return_value G_GNUC_UNUSED,
4560 guint n_param_values,
4561 const GValue *param_values,
4562 gpointer invocation_hint G_GNUC_UNUSED,
4563 gpointer marshal_data)
4564 {
4565 typedef void (*GMarshalFunc_VOID__ENUM_STRING) (gpointer data1,
4566 gint arg1,
4567 gpointer arg2,
4568 gpointer data2);
4569 GCClosure *cc = (GCClosure *) closure;
4570 gpointer data1, data2;
4571 GMarshalFunc_VOID__ENUM_STRING callback;
4572
4573 g_return_if_fail (n_param_values == 3);
4574
4575 if (G_CCLOSURE_SWAP_DATA (closure))
4576 {
4577 data1 = closure->data;
4578 data2 = g_value_peek_pointer (param_values + 0);
4579 }
4580 else
4581 {
4582 data1 = g_value_peek_pointer (param_values + 0);
4583 data2 = closure->data;
4584 }
4585 callback = (GMarshalFunc_VOID__ENUM_STRING) (marshal_data ? marshal_data : cc->callback);
4586
4587 callback (data1,
4588 g_marshal_value_peek_enum (param_values + 1),
4589 g_marshal_value_peek_string (param_values + 2),
4590 data2);
4591 }
4592
4593 void
_gtk_marshal_VOID__ENUM_STRINGv(GClosure * closure,GValue * return_value G_GNUC_UNUSED,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)4594 _gtk_marshal_VOID__ENUM_STRINGv (GClosure *closure,
4595 GValue *return_value G_GNUC_UNUSED,
4596 gpointer instance,
4597 va_list args,
4598 gpointer marshal_data,
4599 int n_params,
4600 GType *param_types)
4601 {
4602 typedef void (*GMarshalFunc_VOID__ENUM_STRING) (gpointer data1,
4603 gint arg1,
4604 gpointer arg2,
4605 gpointer data2);
4606 GCClosure *cc = (GCClosure *) closure;
4607 gpointer data1, data2;
4608 GMarshalFunc_VOID__ENUM_STRING callback;
4609 gint arg0;
4610 gpointer arg1;
4611 va_list args_copy;
4612
4613 G_VA_COPY (args_copy, args);
4614 arg0 = (gint) va_arg (args_copy, gint);
4615 arg1 = (gpointer) va_arg (args_copy, gpointer);
4616 if ((param_types[1] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg1 != NULL)
4617 arg1 = g_strdup (arg1);
4618 va_end (args_copy);
4619
4620
4621 if (G_CCLOSURE_SWAP_DATA (closure))
4622 {
4623 data1 = closure->data;
4624 data2 = instance;
4625 }
4626 else
4627 {
4628 data1 = instance;
4629 data2 = closure->data;
4630 }
4631 callback = (GMarshalFunc_VOID__ENUM_STRING) (marshal_data ? marshal_data : cc->callback);
4632
4633 callback (data1,
4634 arg0,
4635 arg1,
4636 data2);
4637 if ((param_types[1] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg1 != NULL)
4638 g_free (arg1);
4639 }
4640
4641 /* VOID:INT,BOOLEAN (./gtkmarshalers.list:77) */
4642 void
_gtk_marshal_VOID__INT_BOOLEAN(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)4643 _gtk_marshal_VOID__INT_BOOLEAN (GClosure *closure,
4644 GValue *return_value G_GNUC_UNUSED,
4645 guint n_param_values,
4646 const GValue *param_values,
4647 gpointer invocation_hint G_GNUC_UNUSED,
4648 gpointer marshal_data)
4649 {
4650 typedef void (*GMarshalFunc_VOID__INT_BOOLEAN) (gpointer data1,
4651 gint arg1,
4652 gboolean arg2,
4653 gpointer data2);
4654 GCClosure *cc = (GCClosure *) closure;
4655 gpointer data1, data2;
4656 GMarshalFunc_VOID__INT_BOOLEAN callback;
4657
4658 g_return_if_fail (n_param_values == 3);
4659
4660 if (G_CCLOSURE_SWAP_DATA (closure))
4661 {
4662 data1 = closure->data;
4663 data2 = g_value_peek_pointer (param_values + 0);
4664 }
4665 else
4666 {
4667 data1 = g_value_peek_pointer (param_values + 0);
4668 data2 = closure->data;
4669 }
4670 callback = (GMarshalFunc_VOID__INT_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
4671
4672 callback (data1,
4673 g_marshal_value_peek_int (param_values + 1),
4674 g_marshal_value_peek_boolean (param_values + 2),
4675 data2);
4676 }
4677
4678 void
_gtk_marshal_VOID__INT_BOOLEANv(GClosure * closure,GValue * return_value G_GNUC_UNUSED,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)4679 _gtk_marshal_VOID__INT_BOOLEANv (GClosure *closure,
4680 GValue *return_value G_GNUC_UNUSED,
4681 gpointer instance,
4682 va_list args,
4683 gpointer marshal_data,
4684 int n_params,
4685 GType *param_types)
4686 {
4687 typedef void (*GMarshalFunc_VOID__INT_BOOLEAN) (gpointer data1,
4688 gint arg1,
4689 gboolean arg2,
4690 gpointer data2);
4691 GCClosure *cc = (GCClosure *) closure;
4692 gpointer data1, data2;
4693 GMarshalFunc_VOID__INT_BOOLEAN callback;
4694 gint arg0;
4695 gboolean arg1;
4696 va_list args_copy;
4697
4698 G_VA_COPY (args_copy, args);
4699 arg0 = (gint) va_arg (args_copy, gint);
4700 arg1 = (gboolean) va_arg (args_copy, gboolean);
4701 va_end (args_copy);
4702
4703
4704 if (G_CCLOSURE_SWAP_DATA (closure))
4705 {
4706 data1 = closure->data;
4707 data2 = instance;
4708 }
4709 else
4710 {
4711 data1 = instance;
4712 data2 = closure->data;
4713 }
4714 callback = (GMarshalFunc_VOID__INT_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
4715
4716 callback (data1,
4717 arg0,
4718 arg1,
4719 data2);
4720
4721 }
4722
4723 /* VOID:INT,DOUBLE,DOUBLE (./gtkmarshalers.list:78) */
4724 void
_gtk_marshal_VOID__INT_DOUBLE_DOUBLE(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)4725 _gtk_marshal_VOID__INT_DOUBLE_DOUBLE (GClosure *closure,
4726 GValue *return_value G_GNUC_UNUSED,
4727 guint n_param_values,
4728 const GValue *param_values,
4729 gpointer invocation_hint G_GNUC_UNUSED,
4730 gpointer marshal_data)
4731 {
4732 typedef void (*GMarshalFunc_VOID__INT_DOUBLE_DOUBLE) (gpointer data1,
4733 gint arg1,
4734 gdouble arg2,
4735 gdouble arg3,
4736 gpointer data2);
4737 GCClosure *cc = (GCClosure *) closure;
4738 gpointer data1, data2;
4739 GMarshalFunc_VOID__INT_DOUBLE_DOUBLE callback;
4740
4741 g_return_if_fail (n_param_values == 4);
4742
4743 if (G_CCLOSURE_SWAP_DATA (closure))
4744 {
4745 data1 = closure->data;
4746 data2 = g_value_peek_pointer (param_values + 0);
4747 }
4748 else
4749 {
4750 data1 = g_value_peek_pointer (param_values + 0);
4751 data2 = closure->data;
4752 }
4753 callback = (GMarshalFunc_VOID__INT_DOUBLE_DOUBLE) (marshal_data ? marshal_data : cc->callback);
4754
4755 callback (data1,
4756 g_marshal_value_peek_int (param_values + 1),
4757 g_marshal_value_peek_double (param_values + 2),
4758 g_marshal_value_peek_double (param_values + 3),
4759 data2);
4760 }
4761
4762 void
_gtk_marshal_VOID__INT_DOUBLE_DOUBLEv(GClosure * closure,GValue * return_value G_GNUC_UNUSED,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)4763 _gtk_marshal_VOID__INT_DOUBLE_DOUBLEv (GClosure *closure,
4764 GValue *return_value G_GNUC_UNUSED,
4765 gpointer instance,
4766 va_list args,
4767 gpointer marshal_data,
4768 int n_params,
4769 GType *param_types)
4770 {
4771 typedef void (*GMarshalFunc_VOID__INT_DOUBLE_DOUBLE) (gpointer data1,
4772 gint arg1,
4773 gdouble arg2,
4774 gdouble arg3,
4775 gpointer data2);
4776 GCClosure *cc = (GCClosure *) closure;
4777 gpointer data1, data2;
4778 GMarshalFunc_VOID__INT_DOUBLE_DOUBLE callback;
4779 gint arg0;
4780 gdouble arg1;
4781 gdouble arg2;
4782 va_list args_copy;
4783
4784 G_VA_COPY (args_copy, args);
4785 arg0 = (gint) va_arg (args_copy, gint);
4786 arg1 = (gdouble) va_arg (args_copy, gdouble);
4787 arg2 = (gdouble) va_arg (args_copy, gdouble);
4788 va_end (args_copy);
4789
4790
4791 if (G_CCLOSURE_SWAP_DATA (closure))
4792 {
4793 data1 = closure->data;
4794 data2 = instance;
4795 }
4796 else
4797 {
4798 data1 = instance;
4799 data2 = closure->data;
4800 }
4801 callback = (GMarshalFunc_VOID__INT_DOUBLE_DOUBLE) (marshal_data ? marshal_data : cc->callback);
4802
4803 callback (data1,
4804 arg0,
4805 arg1,
4806 arg2,
4807 data2);
4808
4809 }
4810
4811 /* VOID:INT,INT (./gtkmarshalers.list:79) */
4812 void
_gtk_marshal_VOID__INT_INT(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)4813 _gtk_marshal_VOID__INT_INT (GClosure *closure,
4814 GValue *return_value G_GNUC_UNUSED,
4815 guint n_param_values,
4816 const GValue *param_values,
4817 gpointer invocation_hint G_GNUC_UNUSED,
4818 gpointer marshal_data)
4819 {
4820 typedef void (*GMarshalFunc_VOID__INT_INT) (gpointer data1,
4821 gint arg1,
4822 gint arg2,
4823 gpointer data2);
4824 GCClosure *cc = (GCClosure *) closure;
4825 gpointer data1, data2;
4826 GMarshalFunc_VOID__INT_INT callback;
4827
4828 g_return_if_fail (n_param_values == 3);
4829
4830 if (G_CCLOSURE_SWAP_DATA (closure))
4831 {
4832 data1 = closure->data;
4833 data2 = g_value_peek_pointer (param_values + 0);
4834 }
4835 else
4836 {
4837 data1 = g_value_peek_pointer (param_values + 0);
4838 data2 = closure->data;
4839 }
4840 callback = (GMarshalFunc_VOID__INT_INT) (marshal_data ? marshal_data : cc->callback);
4841
4842 callback (data1,
4843 g_marshal_value_peek_int (param_values + 1),
4844 g_marshal_value_peek_int (param_values + 2),
4845 data2);
4846 }
4847
4848 void
_gtk_marshal_VOID__INT_INTv(GClosure * closure,GValue * return_value G_GNUC_UNUSED,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)4849 _gtk_marshal_VOID__INT_INTv (GClosure *closure,
4850 GValue *return_value G_GNUC_UNUSED,
4851 gpointer instance,
4852 va_list args,
4853 gpointer marshal_data,
4854 int n_params,
4855 GType *param_types)
4856 {
4857 typedef void (*GMarshalFunc_VOID__INT_INT) (gpointer data1,
4858 gint arg1,
4859 gint arg2,
4860 gpointer data2);
4861 GCClosure *cc = (GCClosure *) closure;
4862 gpointer data1, data2;
4863 GMarshalFunc_VOID__INT_INT callback;
4864 gint arg0;
4865 gint arg1;
4866 va_list args_copy;
4867
4868 G_VA_COPY (args_copy, args);
4869 arg0 = (gint) va_arg (args_copy, gint);
4870 arg1 = (gint) va_arg (args_copy, gint);
4871 va_end (args_copy);
4872
4873
4874 if (G_CCLOSURE_SWAP_DATA (closure))
4875 {
4876 data1 = closure->data;
4877 data2 = instance;
4878 }
4879 else
4880 {
4881 data1 = instance;
4882 data2 = closure->data;
4883 }
4884 callback = (GMarshalFunc_VOID__INT_INT) (marshal_data ? marshal_data : cc->callback);
4885
4886 callback (data1,
4887 arg0,
4888 arg1,
4889 data2);
4890
4891 }
4892
4893 /* VOID:INT,INT,BOXED (./gtkmarshalers.list:80) */
4894 void
_gtk_marshal_VOID__INT_INT_BOXED(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)4895 _gtk_marshal_VOID__INT_INT_BOXED (GClosure *closure,
4896 GValue *return_value G_GNUC_UNUSED,
4897 guint n_param_values,
4898 const GValue *param_values,
4899 gpointer invocation_hint G_GNUC_UNUSED,
4900 gpointer marshal_data)
4901 {
4902 typedef void (*GMarshalFunc_VOID__INT_INT_BOXED) (gpointer data1,
4903 gint arg1,
4904 gint arg2,
4905 gpointer arg3,
4906 gpointer data2);
4907 GCClosure *cc = (GCClosure *) closure;
4908 gpointer data1, data2;
4909 GMarshalFunc_VOID__INT_INT_BOXED callback;
4910
4911 g_return_if_fail (n_param_values == 4);
4912
4913 if (G_CCLOSURE_SWAP_DATA (closure))
4914 {
4915 data1 = closure->data;
4916 data2 = g_value_peek_pointer (param_values + 0);
4917 }
4918 else
4919 {
4920 data1 = g_value_peek_pointer (param_values + 0);
4921 data2 = closure->data;
4922 }
4923 callback = (GMarshalFunc_VOID__INT_INT_BOXED) (marshal_data ? marshal_data : cc->callback);
4924
4925 callback (data1,
4926 g_marshal_value_peek_int (param_values + 1),
4927 g_marshal_value_peek_int (param_values + 2),
4928 g_marshal_value_peek_boxed (param_values + 3),
4929 data2);
4930 }
4931
4932 void
_gtk_marshal_VOID__INT_INT_BOXEDv(GClosure * closure,GValue * return_value G_GNUC_UNUSED,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)4933 _gtk_marshal_VOID__INT_INT_BOXEDv (GClosure *closure,
4934 GValue *return_value G_GNUC_UNUSED,
4935 gpointer instance,
4936 va_list args,
4937 gpointer marshal_data,
4938 int n_params,
4939 GType *param_types)
4940 {
4941 typedef void (*GMarshalFunc_VOID__INT_INT_BOXED) (gpointer data1,
4942 gint arg1,
4943 gint arg2,
4944 gpointer arg3,
4945 gpointer data2);
4946 GCClosure *cc = (GCClosure *) closure;
4947 gpointer data1, data2;
4948 GMarshalFunc_VOID__INT_INT_BOXED callback;
4949 gint arg0;
4950 gint arg1;
4951 gpointer arg2;
4952 va_list args_copy;
4953
4954 G_VA_COPY (args_copy, args);
4955 arg0 = (gint) va_arg (args_copy, gint);
4956 arg1 = (gint) va_arg (args_copy, gint);
4957 arg2 = (gpointer) va_arg (args_copy, gpointer);
4958 if ((param_types[2] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg2 != NULL)
4959 arg2 = g_boxed_copy (param_types[2] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg2);
4960 va_end (args_copy);
4961
4962
4963 if (G_CCLOSURE_SWAP_DATA (closure))
4964 {
4965 data1 = closure->data;
4966 data2 = instance;
4967 }
4968 else
4969 {
4970 data1 = instance;
4971 data2 = closure->data;
4972 }
4973 callback = (GMarshalFunc_VOID__INT_INT_BOXED) (marshal_data ? marshal_data : cc->callback);
4974
4975 callback (data1,
4976 arg0,
4977 arg1,
4978 arg2,
4979 data2);
4980 if ((param_types[2] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg2 != NULL)
4981 g_boxed_free (param_types[2] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg2);
4982 }
4983
4984 /* VOID:INT,INT,INT (./gtkmarshalers.list:81) */
4985 void
_gtk_marshal_VOID__INT_INT_INT(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)4986 _gtk_marshal_VOID__INT_INT_INT (GClosure *closure,
4987 GValue *return_value G_GNUC_UNUSED,
4988 guint n_param_values,
4989 const GValue *param_values,
4990 gpointer invocation_hint G_GNUC_UNUSED,
4991 gpointer marshal_data)
4992 {
4993 typedef void (*GMarshalFunc_VOID__INT_INT_INT) (gpointer data1,
4994 gint arg1,
4995 gint arg2,
4996 gint arg3,
4997 gpointer data2);
4998 GCClosure *cc = (GCClosure *) closure;
4999 gpointer data1, data2;
5000 GMarshalFunc_VOID__INT_INT_INT callback;
5001
5002 g_return_if_fail (n_param_values == 4);
5003
5004 if (G_CCLOSURE_SWAP_DATA (closure))
5005 {
5006 data1 = closure->data;
5007 data2 = g_value_peek_pointer (param_values + 0);
5008 }
5009 else
5010 {
5011 data1 = g_value_peek_pointer (param_values + 0);
5012 data2 = closure->data;
5013 }
5014 callback = (GMarshalFunc_VOID__INT_INT_INT) (marshal_data ? marshal_data : cc->callback);
5015
5016 callback (data1,
5017 g_marshal_value_peek_int (param_values + 1),
5018 g_marshal_value_peek_int (param_values + 2),
5019 g_marshal_value_peek_int (param_values + 3),
5020 data2);
5021 }
5022
5023 void
_gtk_marshal_VOID__INT_INT_INTv(GClosure * closure,GValue * return_value G_GNUC_UNUSED,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)5024 _gtk_marshal_VOID__INT_INT_INTv (GClosure *closure,
5025 GValue *return_value G_GNUC_UNUSED,
5026 gpointer instance,
5027 va_list args,
5028 gpointer marshal_data,
5029 int n_params,
5030 GType *param_types)
5031 {
5032 typedef void (*GMarshalFunc_VOID__INT_INT_INT) (gpointer data1,
5033 gint arg1,
5034 gint arg2,
5035 gint arg3,
5036 gpointer data2);
5037 GCClosure *cc = (GCClosure *) closure;
5038 gpointer data1, data2;
5039 GMarshalFunc_VOID__INT_INT_INT callback;
5040 gint arg0;
5041 gint arg1;
5042 gint arg2;
5043 va_list args_copy;
5044
5045 G_VA_COPY (args_copy, args);
5046 arg0 = (gint) va_arg (args_copy, gint);
5047 arg1 = (gint) va_arg (args_copy, gint);
5048 arg2 = (gint) va_arg (args_copy, gint);
5049 va_end (args_copy);
5050
5051
5052 if (G_CCLOSURE_SWAP_DATA (closure))
5053 {
5054 data1 = closure->data;
5055 data2 = instance;
5056 }
5057 else
5058 {
5059 data1 = instance;
5060 data2 = closure->data;
5061 }
5062 callback = (GMarshalFunc_VOID__INT_INT_INT) (marshal_data ? marshal_data : cc->callback);
5063
5064 callback (data1,
5065 arg0,
5066 arg1,
5067 arg2,
5068 data2);
5069
5070 }
5071
5072 /* VOID:OBJECT,BOOLEAN (./gtkmarshalers.list:82) */
5073 void
_gtk_marshal_VOID__OBJECT_BOOLEAN(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)5074 _gtk_marshal_VOID__OBJECT_BOOLEAN (GClosure *closure,
5075 GValue *return_value G_GNUC_UNUSED,
5076 guint n_param_values,
5077 const GValue *param_values,
5078 gpointer invocation_hint G_GNUC_UNUSED,
5079 gpointer marshal_data)
5080 {
5081 typedef void (*GMarshalFunc_VOID__OBJECT_BOOLEAN) (gpointer data1,
5082 gpointer arg1,
5083 gboolean arg2,
5084 gpointer data2);
5085 GCClosure *cc = (GCClosure *) closure;
5086 gpointer data1, data2;
5087 GMarshalFunc_VOID__OBJECT_BOOLEAN callback;
5088
5089 g_return_if_fail (n_param_values == 3);
5090
5091 if (G_CCLOSURE_SWAP_DATA (closure))
5092 {
5093 data1 = closure->data;
5094 data2 = g_value_peek_pointer (param_values + 0);
5095 }
5096 else
5097 {
5098 data1 = g_value_peek_pointer (param_values + 0);
5099 data2 = closure->data;
5100 }
5101 callback = (GMarshalFunc_VOID__OBJECT_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
5102
5103 callback (data1,
5104 g_marshal_value_peek_object (param_values + 1),
5105 g_marshal_value_peek_boolean (param_values + 2),
5106 data2);
5107 }
5108
5109 void
_gtk_marshal_VOID__OBJECT_BOOLEANv(GClosure * closure,GValue * return_value G_GNUC_UNUSED,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)5110 _gtk_marshal_VOID__OBJECT_BOOLEANv (GClosure *closure,
5111 GValue *return_value G_GNUC_UNUSED,
5112 gpointer instance,
5113 va_list args,
5114 gpointer marshal_data,
5115 int n_params,
5116 GType *param_types)
5117 {
5118 typedef void (*GMarshalFunc_VOID__OBJECT_BOOLEAN) (gpointer data1,
5119 gpointer arg1,
5120 gboolean arg2,
5121 gpointer data2);
5122 GCClosure *cc = (GCClosure *) closure;
5123 gpointer data1, data2;
5124 GMarshalFunc_VOID__OBJECT_BOOLEAN callback;
5125 gpointer arg0;
5126 gboolean arg1;
5127 va_list args_copy;
5128
5129 G_VA_COPY (args_copy, args);
5130 arg0 = (gpointer) va_arg (args_copy, gpointer);
5131 if (arg0 != NULL)
5132 arg0 = g_object_ref (arg0);
5133 arg1 = (gboolean) va_arg (args_copy, gboolean);
5134 va_end (args_copy);
5135
5136
5137 if (G_CCLOSURE_SWAP_DATA (closure))
5138 {
5139 data1 = closure->data;
5140 data2 = instance;
5141 }
5142 else
5143 {
5144 data1 = instance;
5145 data2 = closure->data;
5146 }
5147 callback = (GMarshalFunc_VOID__OBJECT_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
5148
5149 callback (data1,
5150 arg0,
5151 arg1,
5152 data2);
5153 if (arg0 != NULL)
5154 g_object_unref (arg0);
5155 }
5156
5157 /* VOID:OBJECT,BOXED,BOXED (./gtkmarshalers.list:83) */
5158 void
_gtk_marshal_VOID__OBJECT_BOXED_BOXED(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)5159 _gtk_marshal_VOID__OBJECT_BOXED_BOXED (GClosure *closure,
5160 GValue *return_value G_GNUC_UNUSED,
5161 guint n_param_values,
5162 const GValue *param_values,
5163 gpointer invocation_hint G_GNUC_UNUSED,
5164 gpointer marshal_data)
5165 {
5166 typedef void (*GMarshalFunc_VOID__OBJECT_BOXED_BOXED) (gpointer data1,
5167 gpointer arg1,
5168 gpointer arg2,
5169 gpointer arg3,
5170 gpointer data2);
5171 GCClosure *cc = (GCClosure *) closure;
5172 gpointer data1, data2;
5173 GMarshalFunc_VOID__OBJECT_BOXED_BOXED callback;
5174
5175 g_return_if_fail (n_param_values == 4);
5176
5177 if (G_CCLOSURE_SWAP_DATA (closure))
5178 {
5179 data1 = closure->data;
5180 data2 = g_value_peek_pointer (param_values + 0);
5181 }
5182 else
5183 {
5184 data1 = g_value_peek_pointer (param_values + 0);
5185 data2 = closure->data;
5186 }
5187 callback = (GMarshalFunc_VOID__OBJECT_BOXED_BOXED) (marshal_data ? marshal_data : cc->callback);
5188
5189 callback (data1,
5190 g_marshal_value_peek_object (param_values + 1),
5191 g_marshal_value_peek_boxed (param_values + 2),
5192 g_marshal_value_peek_boxed (param_values + 3),
5193 data2);
5194 }
5195
5196 void
_gtk_marshal_VOID__OBJECT_BOXED_BOXEDv(GClosure * closure,GValue * return_value G_GNUC_UNUSED,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)5197 _gtk_marshal_VOID__OBJECT_BOXED_BOXEDv (GClosure *closure,
5198 GValue *return_value G_GNUC_UNUSED,
5199 gpointer instance,
5200 va_list args,
5201 gpointer marshal_data,
5202 int n_params,
5203 GType *param_types)
5204 {
5205 typedef void (*GMarshalFunc_VOID__OBJECT_BOXED_BOXED) (gpointer data1,
5206 gpointer arg1,
5207 gpointer arg2,
5208 gpointer arg3,
5209 gpointer data2);
5210 GCClosure *cc = (GCClosure *) closure;
5211 gpointer data1, data2;
5212 GMarshalFunc_VOID__OBJECT_BOXED_BOXED callback;
5213 gpointer arg0;
5214 gpointer arg1;
5215 gpointer arg2;
5216 va_list args_copy;
5217
5218 G_VA_COPY (args_copy, args);
5219 arg0 = (gpointer) va_arg (args_copy, gpointer);
5220 if (arg0 != NULL)
5221 arg0 = g_object_ref (arg0);
5222 arg1 = (gpointer) va_arg (args_copy, gpointer);
5223 if ((param_types[1] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg1 != NULL)
5224 arg1 = g_boxed_copy (param_types[1] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg1);
5225 arg2 = (gpointer) va_arg (args_copy, gpointer);
5226 if ((param_types[2] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg2 != NULL)
5227 arg2 = g_boxed_copy (param_types[2] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg2);
5228 va_end (args_copy);
5229
5230
5231 if (G_CCLOSURE_SWAP_DATA (closure))
5232 {
5233 data1 = closure->data;
5234 data2 = instance;
5235 }
5236 else
5237 {
5238 data1 = instance;
5239 data2 = closure->data;
5240 }
5241 callback = (GMarshalFunc_VOID__OBJECT_BOXED_BOXED) (marshal_data ? marshal_data : cc->callback);
5242
5243 callback (data1,
5244 arg0,
5245 arg1,
5246 arg2,
5247 data2);
5248 if (arg0 != NULL)
5249 g_object_unref (arg0);
5250 if ((param_types[1] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg1 != NULL)
5251 g_boxed_free (param_types[1] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg1);
5252 if ((param_types[2] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg2 != NULL)
5253 g_boxed_free (param_types[2] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg2);
5254 }
5255
5256 /* VOID:OBJECT,BOXED,UINT,UINT (./gtkmarshalers.list:84) */
5257 void
_gtk_marshal_VOID__OBJECT_BOXED_UINT_UINT(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)5258 _gtk_marshal_VOID__OBJECT_BOXED_UINT_UINT (GClosure *closure,
5259 GValue *return_value G_GNUC_UNUSED,
5260 guint n_param_values,
5261 const GValue *param_values,
5262 gpointer invocation_hint G_GNUC_UNUSED,
5263 gpointer marshal_data)
5264 {
5265 typedef void (*GMarshalFunc_VOID__OBJECT_BOXED_UINT_UINT) (gpointer data1,
5266 gpointer arg1,
5267 gpointer arg2,
5268 guint arg3,
5269 guint arg4,
5270 gpointer data2);
5271 GCClosure *cc = (GCClosure *) closure;
5272 gpointer data1, data2;
5273 GMarshalFunc_VOID__OBJECT_BOXED_UINT_UINT callback;
5274
5275 g_return_if_fail (n_param_values == 5);
5276
5277 if (G_CCLOSURE_SWAP_DATA (closure))
5278 {
5279 data1 = closure->data;
5280 data2 = g_value_peek_pointer (param_values + 0);
5281 }
5282 else
5283 {
5284 data1 = g_value_peek_pointer (param_values + 0);
5285 data2 = closure->data;
5286 }
5287 callback = (GMarshalFunc_VOID__OBJECT_BOXED_UINT_UINT) (marshal_data ? marshal_data : cc->callback);
5288
5289 callback (data1,
5290 g_marshal_value_peek_object (param_values + 1),
5291 g_marshal_value_peek_boxed (param_values + 2),
5292 g_marshal_value_peek_uint (param_values + 3),
5293 g_marshal_value_peek_uint (param_values + 4),
5294 data2);
5295 }
5296
5297 void
_gtk_marshal_VOID__OBJECT_BOXED_UINT_UINTv(GClosure * closure,GValue * return_value G_GNUC_UNUSED,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)5298 _gtk_marshal_VOID__OBJECT_BOXED_UINT_UINTv (GClosure *closure,
5299 GValue *return_value G_GNUC_UNUSED,
5300 gpointer instance,
5301 va_list args,
5302 gpointer marshal_data,
5303 int n_params,
5304 GType *param_types)
5305 {
5306 typedef void (*GMarshalFunc_VOID__OBJECT_BOXED_UINT_UINT) (gpointer data1,
5307 gpointer arg1,
5308 gpointer arg2,
5309 guint arg3,
5310 guint arg4,
5311 gpointer data2);
5312 GCClosure *cc = (GCClosure *) closure;
5313 gpointer data1, data2;
5314 GMarshalFunc_VOID__OBJECT_BOXED_UINT_UINT callback;
5315 gpointer arg0;
5316 gpointer arg1;
5317 guint arg2;
5318 guint arg3;
5319 va_list args_copy;
5320
5321 G_VA_COPY (args_copy, args);
5322 arg0 = (gpointer) va_arg (args_copy, gpointer);
5323 if (arg0 != NULL)
5324 arg0 = g_object_ref (arg0);
5325 arg1 = (gpointer) va_arg (args_copy, gpointer);
5326 if ((param_types[1] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg1 != NULL)
5327 arg1 = g_boxed_copy (param_types[1] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg1);
5328 arg2 = (guint) va_arg (args_copy, guint);
5329 arg3 = (guint) va_arg (args_copy, guint);
5330 va_end (args_copy);
5331
5332
5333 if (G_CCLOSURE_SWAP_DATA (closure))
5334 {
5335 data1 = closure->data;
5336 data2 = instance;
5337 }
5338 else
5339 {
5340 data1 = instance;
5341 data2 = closure->data;
5342 }
5343 callback = (GMarshalFunc_VOID__OBJECT_BOXED_UINT_UINT) (marshal_data ? marshal_data : cc->callback);
5344
5345 callback (data1,
5346 arg0,
5347 arg1,
5348 arg2,
5349 arg3,
5350 data2);
5351 if (arg0 != NULL)
5352 g_object_unref (arg0);
5353 if ((param_types[1] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg1 != NULL)
5354 g_boxed_free (param_types[1] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg1);
5355 }
5356
5357 /* VOID:OBJECT,BOXED,BOOLEAN,BOOLEAN (./gtkmarshalers.list:85) */
5358 void
_gtk_marshal_VOID__OBJECT_BOXED_BOOLEAN_BOOLEAN(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)5359 _gtk_marshal_VOID__OBJECT_BOXED_BOOLEAN_BOOLEAN (GClosure *closure,
5360 GValue *return_value G_GNUC_UNUSED,
5361 guint n_param_values,
5362 const GValue *param_values,
5363 gpointer invocation_hint G_GNUC_UNUSED,
5364 gpointer marshal_data)
5365 {
5366 typedef void (*GMarshalFunc_VOID__OBJECT_BOXED_BOOLEAN_BOOLEAN) (gpointer data1,
5367 gpointer arg1,
5368 gpointer arg2,
5369 gboolean arg3,
5370 gboolean arg4,
5371 gpointer data2);
5372 GCClosure *cc = (GCClosure *) closure;
5373 gpointer data1, data2;
5374 GMarshalFunc_VOID__OBJECT_BOXED_BOOLEAN_BOOLEAN callback;
5375
5376 g_return_if_fail (n_param_values == 5);
5377
5378 if (G_CCLOSURE_SWAP_DATA (closure))
5379 {
5380 data1 = closure->data;
5381 data2 = g_value_peek_pointer (param_values + 0);
5382 }
5383 else
5384 {
5385 data1 = g_value_peek_pointer (param_values + 0);
5386 data2 = closure->data;
5387 }
5388 callback = (GMarshalFunc_VOID__OBJECT_BOXED_BOOLEAN_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
5389
5390 callback (data1,
5391 g_marshal_value_peek_object (param_values + 1),
5392 g_marshal_value_peek_boxed (param_values + 2),
5393 g_marshal_value_peek_boolean (param_values + 3),
5394 g_marshal_value_peek_boolean (param_values + 4),
5395 data2);
5396 }
5397
5398 void
_gtk_marshal_VOID__OBJECT_BOXED_BOOLEAN_BOOLEANv(GClosure * closure,GValue * return_value G_GNUC_UNUSED,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)5399 _gtk_marshal_VOID__OBJECT_BOXED_BOOLEAN_BOOLEANv (GClosure *closure,
5400 GValue *return_value G_GNUC_UNUSED,
5401 gpointer instance,
5402 va_list args,
5403 gpointer marshal_data,
5404 int n_params,
5405 GType *param_types)
5406 {
5407 typedef void (*GMarshalFunc_VOID__OBJECT_BOXED_BOOLEAN_BOOLEAN) (gpointer data1,
5408 gpointer arg1,
5409 gpointer arg2,
5410 gboolean arg3,
5411 gboolean arg4,
5412 gpointer data2);
5413 GCClosure *cc = (GCClosure *) closure;
5414 gpointer data1, data2;
5415 GMarshalFunc_VOID__OBJECT_BOXED_BOOLEAN_BOOLEAN callback;
5416 gpointer arg0;
5417 gpointer arg1;
5418 gboolean arg2;
5419 gboolean arg3;
5420 va_list args_copy;
5421
5422 G_VA_COPY (args_copy, args);
5423 arg0 = (gpointer) va_arg (args_copy, gpointer);
5424 if (arg0 != NULL)
5425 arg0 = g_object_ref (arg0);
5426 arg1 = (gpointer) va_arg (args_copy, gpointer);
5427 if ((param_types[1] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg1 != NULL)
5428 arg1 = g_boxed_copy (param_types[1] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg1);
5429 arg2 = (gboolean) va_arg (args_copy, gboolean);
5430 arg3 = (gboolean) va_arg (args_copy, gboolean);
5431 va_end (args_copy);
5432
5433
5434 if (G_CCLOSURE_SWAP_DATA (closure))
5435 {
5436 data1 = closure->data;
5437 data2 = instance;
5438 }
5439 else
5440 {
5441 data1 = instance;
5442 data2 = closure->data;
5443 }
5444 callback = (GMarshalFunc_VOID__OBJECT_BOXED_BOOLEAN_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
5445
5446 callback (data1,
5447 arg0,
5448 arg1,
5449 arg2,
5450 arg3,
5451 data2);
5452 if (arg0 != NULL)
5453 g_object_unref (arg0);
5454 if ((param_types[1] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg1 != NULL)
5455 g_boxed_free (param_types[1] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg1);
5456 }
5457
5458 /* VOID:OBJECT,ENUM (./gtkmarshalers.list:86) */
5459 void
_gtk_marshal_VOID__OBJECT_ENUM(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)5460 _gtk_marshal_VOID__OBJECT_ENUM (GClosure *closure,
5461 GValue *return_value G_GNUC_UNUSED,
5462 guint n_param_values,
5463 const GValue *param_values,
5464 gpointer invocation_hint G_GNUC_UNUSED,
5465 gpointer marshal_data)
5466 {
5467 typedef void (*GMarshalFunc_VOID__OBJECT_ENUM) (gpointer data1,
5468 gpointer arg1,
5469 gint arg2,
5470 gpointer data2);
5471 GCClosure *cc = (GCClosure *) closure;
5472 gpointer data1, data2;
5473 GMarshalFunc_VOID__OBJECT_ENUM callback;
5474
5475 g_return_if_fail (n_param_values == 3);
5476
5477 if (G_CCLOSURE_SWAP_DATA (closure))
5478 {
5479 data1 = closure->data;
5480 data2 = g_value_peek_pointer (param_values + 0);
5481 }
5482 else
5483 {
5484 data1 = g_value_peek_pointer (param_values + 0);
5485 data2 = closure->data;
5486 }
5487 callback = (GMarshalFunc_VOID__OBJECT_ENUM) (marshal_data ? marshal_data : cc->callback);
5488
5489 callback (data1,
5490 g_marshal_value_peek_object (param_values + 1),
5491 g_marshal_value_peek_enum (param_values + 2),
5492 data2);
5493 }
5494
5495 void
_gtk_marshal_VOID__OBJECT_ENUMv(GClosure * closure,GValue * return_value G_GNUC_UNUSED,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)5496 _gtk_marshal_VOID__OBJECT_ENUMv (GClosure *closure,
5497 GValue *return_value G_GNUC_UNUSED,
5498 gpointer instance,
5499 va_list args,
5500 gpointer marshal_data,
5501 int n_params,
5502 GType *param_types)
5503 {
5504 typedef void (*GMarshalFunc_VOID__OBJECT_ENUM) (gpointer data1,
5505 gpointer arg1,
5506 gint arg2,
5507 gpointer data2);
5508 GCClosure *cc = (GCClosure *) closure;
5509 gpointer data1, data2;
5510 GMarshalFunc_VOID__OBJECT_ENUM callback;
5511 gpointer arg0;
5512 gint arg1;
5513 va_list args_copy;
5514
5515 G_VA_COPY (args_copy, args);
5516 arg0 = (gpointer) va_arg (args_copy, gpointer);
5517 if (arg0 != NULL)
5518 arg0 = g_object_ref (arg0);
5519 arg1 = (gint) va_arg (args_copy, gint);
5520 va_end (args_copy);
5521
5522
5523 if (G_CCLOSURE_SWAP_DATA (closure))
5524 {
5525 data1 = closure->data;
5526 data2 = instance;
5527 }
5528 else
5529 {
5530 data1 = instance;
5531 data2 = closure->data;
5532 }
5533 callback = (GMarshalFunc_VOID__OBJECT_ENUM) (marshal_data ? marshal_data : cc->callback);
5534
5535 callback (data1,
5536 arg0,
5537 arg1,
5538 data2);
5539 if (arg0 != NULL)
5540 g_object_unref (arg0);
5541 }
5542
5543 /* VOID:OBJECT,FLAGS (./gtkmarshalers.list:87) */
5544 void
_gtk_marshal_VOID__OBJECT_FLAGS(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)5545 _gtk_marshal_VOID__OBJECT_FLAGS (GClosure *closure,
5546 GValue *return_value G_GNUC_UNUSED,
5547 guint n_param_values,
5548 const GValue *param_values,
5549 gpointer invocation_hint G_GNUC_UNUSED,
5550 gpointer marshal_data)
5551 {
5552 typedef void (*GMarshalFunc_VOID__OBJECT_FLAGS) (gpointer data1,
5553 gpointer arg1,
5554 guint arg2,
5555 gpointer data2);
5556 GCClosure *cc = (GCClosure *) closure;
5557 gpointer data1, data2;
5558 GMarshalFunc_VOID__OBJECT_FLAGS callback;
5559
5560 g_return_if_fail (n_param_values == 3);
5561
5562 if (G_CCLOSURE_SWAP_DATA (closure))
5563 {
5564 data1 = closure->data;
5565 data2 = g_value_peek_pointer (param_values + 0);
5566 }
5567 else
5568 {
5569 data1 = g_value_peek_pointer (param_values + 0);
5570 data2 = closure->data;
5571 }
5572 callback = (GMarshalFunc_VOID__OBJECT_FLAGS) (marshal_data ? marshal_data : cc->callback);
5573
5574 callback (data1,
5575 g_marshal_value_peek_object (param_values + 1),
5576 g_marshal_value_peek_flags (param_values + 2),
5577 data2);
5578 }
5579
5580 void
_gtk_marshal_VOID__OBJECT_FLAGSv(GClosure * closure,GValue * return_value G_GNUC_UNUSED,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)5581 _gtk_marshal_VOID__OBJECT_FLAGSv (GClosure *closure,
5582 GValue *return_value G_GNUC_UNUSED,
5583 gpointer instance,
5584 va_list args,
5585 gpointer marshal_data,
5586 int n_params,
5587 GType *param_types)
5588 {
5589 typedef void (*GMarshalFunc_VOID__OBJECT_FLAGS) (gpointer data1,
5590 gpointer arg1,
5591 guint arg2,
5592 gpointer data2);
5593 GCClosure *cc = (GCClosure *) closure;
5594 gpointer data1, data2;
5595 GMarshalFunc_VOID__OBJECT_FLAGS callback;
5596 gpointer arg0;
5597 guint arg1;
5598 va_list args_copy;
5599
5600 G_VA_COPY (args_copy, args);
5601 arg0 = (gpointer) va_arg (args_copy, gpointer);
5602 if (arg0 != NULL)
5603 arg0 = g_object_ref (arg0);
5604 arg1 = (guint) va_arg (args_copy, guint);
5605 va_end (args_copy);
5606
5607
5608 if (G_CCLOSURE_SWAP_DATA (closure))
5609 {
5610 data1 = closure->data;
5611 data2 = instance;
5612 }
5613 else
5614 {
5615 data1 = instance;
5616 data2 = closure->data;
5617 }
5618 callback = (GMarshalFunc_VOID__OBJECT_FLAGS) (marshal_data ? marshal_data : cc->callback);
5619
5620 callback (data1,
5621 arg0,
5622 arg1,
5623 data2);
5624 if (arg0 != NULL)
5625 g_object_unref (arg0);
5626 }
5627
5628 /* VOID:OBJECT,INT (./gtkmarshalers.list:88) */
5629 void
_gtk_marshal_VOID__OBJECT_INT(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)5630 _gtk_marshal_VOID__OBJECT_INT (GClosure *closure,
5631 GValue *return_value G_GNUC_UNUSED,
5632 guint n_param_values,
5633 const GValue *param_values,
5634 gpointer invocation_hint G_GNUC_UNUSED,
5635 gpointer marshal_data)
5636 {
5637 typedef void (*GMarshalFunc_VOID__OBJECT_INT) (gpointer data1,
5638 gpointer arg1,
5639 gint arg2,
5640 gpointer data2);
5641 GCClosure *cc = (GCClosure *) closure;
5642 gpointer data1, data2;
5643 GMarshalFunc_VOID__OBJECT_INT callback;
5644
5645 g_return_if_fail (n_param_values == 3);
5646
5647 if (G_CCLOSURE_SWAP_DATA (closure))
5648 {
5649 data1 = closure->data;
5650 data2 = g_value_peek_pointer (param_values + 0);
5651 }
5652 else
5653 {
5654 data1 = g_value_peek_pointer (param_values + 0);
5655 data2 = closure->data;
5656 }
5657 callback = (GMarshalFunc_VOID__OBJECT_INT) (marshal_data ? marshal_data : cc->callback);
5658
5659 callback (data1,
5660 g_marshal_value_peek_object (param_values + 1),
5661 g_marshal_value_peek_int (param_values + 2),
5662 data2);
5663 }
5664
5665 void
_gtk_marshal_VOID__OBJECT_INTv(GClosure * closure,GValue * return_value G_GNUC_UNUSED,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)5666 _gtk_marshal_VOID__OBJECT_INTv (GClosure *closure,
5667 GValue *return_value G_GNUC_UNUSED,
5668 gpointer instance,
5669 va_list args,
5670 gpointer marshal_data,
5671 int n_params,
5672 GType *param_types)
5673 {
5674 typedef void (*GMarshalFunc_VOID__OBJECT_INT) (gpointer data1,
5675 gpointer arg1,
5676 gint arg2,
5677 gpointer data2);
5678 GCClosure *cc = (GCClosure *) closure;
5679 gpointer data1, data2;
5680 GMarshalFunc_VOID__OBJECT_INT callback;
5681 gpointer arg0;
5682 gint arg1;
5683 va_list args_copy;
5684
5685 G_VA_COPY (args_copy, args);
5686 arg0 = (gpointer) va_arg (args_copy, gpointer);
5687 if (arg0 != NULL)
5688 arg0 = g_object_ref (arg0);
5689 arg1 = (gint) va_arg (args_copy, gint);
5690 va_end (args_copy);
5691
5692
5693 if (G_CCLOSURE_SWAP_DATA (closure))
5694 {
5695 data1 = closure->data;
5696 data2 = instance;
5697 }
5698 else
5699 {
5700 data1 = instance;
5701 data2 = closure->data;
5702 }
5703 callback = (GMarshalFunc_VOID__OBJECT_INT) (marshal_data ? marshal_data : cc->callback);
5704
5705 callback (data1,
5706 arg0,
5707 arg1,
5708 data2);
5709 if (arg0 != NULL)
5710 g_object_unref (arg0);
5711 }
5712
5713 /* VOID:OBJECT,INT,OBJECT (./gtkmarshalers.list:89) */
5714 void
_gtk_marshal_VOID__OBJECT_INT_OBJECT(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)5715 _gtk_marshal_VOID__OBJECT_INT_OBJECT (GClosure *closure,
5716 GValue *return_value G_GNUC_UNUSED,
5717 guint n_param_values,
5718 const GValue *param_values,
5719 gpointer invocation_hint G_GNUC_UNUSED,
5720 gpointer marshal_data)
5721 {
5722 typedef void (*GMarshalFunc_VOID__OBJECT_INT_OBJECT) (gpointer data1,
5723 gpointer arg1,
5724 gint arg2,
5725 gpointer arg3,
5726 gpointer data2);
5727 GCClosure *cc = (GCClosure *) closure;
5728 gpointer data1, data2;
5729 GMarshalFunc_VOID__OBJECT_INT_OBJECT callback;
5730
5731 g_return_if_fail (n_param_values == 4);
5732
5733 if (G_CCLOSURE_SWAP_DATA (closure))
5734 {
5735 data1 = closure->data;
5736 data2 = g_value_peek_pointer (param_values + 0);
5737 }
5738 else
5739 {
5740 data1 = g_value_peek_pointer (param_values + 0);
5741 data2 = closure->data;
5742 }
5743 callback = (GMarshalFunc_VOID__OBJECT_INT_OBJECT) (marshal_data ? marshal_data : cc->callback);
5744
5745 callback (data1,
5746 g_marshal_value_peek_object (param_values + 1),
5747 g_marshal_value_peek_int (param_values + 2),
5748 g_marshal_value_peek_object (param_values + 3),
5749 data2);
5750 }
5751
5752 void
_gtk_marshal_VOID__OBJECT_INT_OBJECTv(GClosure * closure,GValue * return_value G_GNUC_UNUSED,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)5753 _gtk_marshal_VOID__OBJECT_INT_OBJECTv (GClosure *closure,
5754 GValue *return_value G_GNUC_UNUSED,
5755 gpointer instance,
5756 va_list args,
5757 gpointer marshal_data,
5758 int n_params,
5759 GType *param_types)
5760 {
5761 typedef void (*GMarshalFunc_VOID__OBJECT_INT_OBJECT) (gpointer data1,
5762 gpointer arg1,
5763 gint arg2,
5764 gpointer arg3,
5765 gpointer data2);
5766 GCClosure *cc = (GCClosure *) closure;
5767 gpointer data1, data2;
5768 GMarshalFunc_VOID__OBJECT_INT_OBJECT callback;
5769 gpointer arg0;
5770 gint arg1;
5771 gpointer arg2;
5772 va_list args_copy;
5773
5774 G_VA_COPY (args_copy, args);
5775 arg0 = (gpointer) va_arg (args_copy, gpointer);
5776 if (arg0 != NULL)
5777 arg0 = g_object_ref (arg0);
5778 arg1 = (gint) va_arg (args_copy, gint);
5779 arg2 = (gpointer) va_arg (args_copy, gpointer);
5780 if (arg2 != NULL)
5781 arg2 = g_object_ref (arg2);
5782 va_end (args_copy);
5783
5784
5785 if (G_CCLOSURE_SWAP_DATA (closure))
5786 {
5787 data1 = closure->data;
5788 data2 = instance;
5789 }
5790 else
5791 {
5792 data1 = instance;
5793 data2 = closure->data;
5794 }
5795 callback = (GMarshalFunc_VOID__OBJECT_INT_OBJECT) (marshal_data ? marshal_data : cc->callback);
5796
5797 callback (data1,
5798 arg0,
5799 arg1,
5800 arg2,
5801 data2);
5802 if (arg0 != NULL)
5803 g_object_unref (arg0);
5804 if (arg2 != NULL)
5805 g_object_unref (arg2);
5806 }
5807
5808 /* VOID:OBJECT,INT,INT (./gtkmarshalers.list:90) */
5809 void
_gtk_marshal_VOID__OBJECT_INT_INT(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)5810 _gtk_marshal_VOID__OBJECT_INT_INT (GClosure *closure,
5811 GValue *return_value G_GNUC_UNUSED,
5812 guint n_param_values,
5813 const GValue *param_values,
5814 gpointer invocation_hint G_GNUC_UNUSED,
5815 gpointer marshal_data)
5816 {
5817 typedef void (*GMarshalFunc_VOID__OBJECT_INT_INT) (gpointer data1,
5818 gpointer arg1,
5819 gint arg2,
5820 gint arg3,
5821 gpointer data2);
5822 GCClosure *cc = (GCClosure *) closure;
5823 gpointer data1, data2;
5824 GMarshalFunc_VOID__OBJECT_INT_INT callback;
5825
5826 g_return_if_fail (n_param_values == 4);
5827
5828 if (G_CCLOSURE_SWAP_DATA (closure))
5829 {
5830 data1 = closure->data;
5831 data2 = g_value_peek_pointer (param_values + 0);
5832 }
5833 else
5834 {
5835 data1 = g_value_peek_pointer (param_values + 0);
5836 data2 = closure->data;
5837 }
5838 callback = (GMarshalFunc_VOID__OBJECT_INT_INT) (marshal_data ? marshal_data : cc->callback);
5839
5840 callback (data1,
5841 g_marshal_value_peek_object (param_values + 1),
5842 g_marshal_value_peek_int (param_values + 2),
5843 g_marshal_value_peek_int (param_values + 3),
5844 data2);
5845 }
5846
5847 void
_gtk_marshal_VOID__OBJECT_INT_INTv(GClosure * closure,GValue * return_value G_GNUC_UNUSED,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)5848 _gtk_marshal_VOID__OBJECT_INT_INTv (GClosure *closure,
5849 GValue *return_value G_GNUC_UNUSED,
5850 gpointer instance,
5851 va_list args,
5852 gpointer marshal_data,
5853 int n_params,
5854 GType *param_types)
5855 {
5856 typedef void (*GMarshalFunc_VOID__OBJECT_INT_INT) (gpointer data1,
5857 gpointer arg1,
5858 gint arg2,
5859 gint arg3,
5860 gpointer data2);
5861 GCClosure *cc = (GCClosure *) closure;
5862 gpointer data1, data2;
5863 GMarshalFunc_VOID__OBJECT_INT_INT callback;
5864 gpointer arg0;
5865 gint arg1;
5866 gint arg2;
5867 va_list args_copy;
5868
5869 G_VA_COPY (args_copy, args);
5870 arg0 = (gpointer) va_arg (args_copy, gpointer);
5871 if (arg0 != NULL)
5872 arg0 = g_object_ref (arg0);
5873 arg1 = (gint) va_arg (args_copy, gint);
5874 arg2 = (gint) va_arg (args_copy, gint);
5875 va_end (args_copy);
5876
5877
5878 if (G_CCLOSURE_SWAP_DATA (closure))
5879 {
5880 data1 = closure->data;
5881 data2 = instance;
5882 }
5883 else
5884 {
5885 data1 = instance;
5886 data2 = closure->data;
5887 }
5888 callback = (GMarshalFunc_VOID__OBJECT_INT_INT) (marshal_data ? marshal_data : cc->callback);
5889
5890 callback (data1,
5891 arg0,
5892 arg1,
5893 arg2,
5894 data2);
5895 if (arg0 != NULL)
5896 g_object_unref (arg0);
5897 }
5898
5899 /* VOID:OBJECT,INT,INT,BOXED,UINT,UINT (./gtkmarshalers.list:91) */
5900 void
_gtk_marshal_VOID__OBJECT_INT_INT_BOXED_UINT_UINT(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)5901 _gtk_marshal_VOID__OBJECT_INT_INT_BOXED_UINT_UINT (GClosure *closure,
5902 GValue *return_value G_GNUC_UNUSED,
5903 guint n_param_values,
5904 const GValue *param_values,
5905 gpointer invocation_hint G_GNUC_UNUSED,
5906 gpointer marshal_data)
5907 {
5908 typedef void (*GMarshalFunc_VOID__OBJECT_INT_INT_BOXED_UINT_UINT) (gpointer data1,
5909 gpointer arg1,
5910 gint arg2,
5911 gint arg3,
5912 gpointer arg4,
5913 guint arg5,
5914 guint arg6,
5915 gpointer data2);
5916 GCClosure *cc = (GCClosure *) closure;
5917 gpointer data1, data2;
5918 GMarshalFunc_VOID__OBJECT_INT_INT_BOXED_UINT_UINT callback;
5919
5920 g_return_if_fail (n_param_values == 7);
5921
5922 if (G_CCLOSURE_SWAP_DATA (closure))
5923 {
5924 data1 = closure->data;
5925 data2 = g_value_peek_pointer (param_values + 0);
5926 }
5927 else
5928 {
5929 data1 = g_value_peek_pointer (param_values + 0);
5930 data2 = closure->data;
5931 }
5932 callback = (GMarshalFunc_VOID__OBJECT_INT_INT_BOXED_UINT_UINT) (marshal_data ? marshal_data : cc->callback);
5933
5934 callback (data1,
5935 g_marshal_value_peek_object (param_values + 1),
5936 g_marshal_value_peek_int (param_values + 2),
5937 g_marshal_value_peek_int (param_values + 3),
5938 g_marshal_value_peek_boxed (param_values + 4),
5939 g_marshal_value_peek_uint (param_values + 5),
5940 g_marshal_value_peek_uint (param_values + 6),
5941 data2);
5942 }
5943
5944 void
_gtk_marshal_VOID__OBJECT_INT_INT_BOXED_UINT_UINTv(GClosure * closure,GValue * return_value G_GNUC_UNUSED,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)5945 _gtk_marshal_VOID__OBJECT_INT_INT_BOXED_UINT_UINTv (GClosure *closure,
5946 GValue *return_value G_GNUC_UNUSED,
5947 gpointer instance,
5948 va_list args,
5949 gpointer marshal_data,
5950 int n_params,
5951 GType *param_types)
5952 {
5953 typedef void (*GMarshalFunc_VOID__OBJECT_INT_INT_BOXED_UINT_UINT) (gpointer data1,
5954 gpointer arg1,
5955 gint arg2,
5956 gint arg3,
5957 gpointer arg4,
5958 guint arg5,
5959 guint arg6,
5960 gpointer data2);
5961 GCClosure *cc = (GCClosure *) closure;
5962 gpointer data1, data2;
5963 GMarshalFunc_VOID__OBJECT_INT_INT_BOXED_UINT_UINT callback;
5964 gpointer arg0;
5965 gint arg1;
5966 gint arg2;
5967 gpointer arg3;
5968 guint arg4;
5969 guint arg5;
5970 va_list args_copy;
5971
5972 G_VA_COPY (args_copy, args);
5973 arg0 = (gpointer) va_arg (args_copy, gpointer);
5974 if (arg0 != NULL)
5975 arg0 = g_object_ref (arg0);
5976 arg1 = (gint) va_arg (args_copy, gint);
5977 arg2 = (gint) va_arg (args_copy, gint);
5978 arg3 = (gpointer) va_arg (args_copy, gpointer);
5979 if ((param_types[3] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg3 != NULL)
5980 arg3 = g_boxed_copy (param_types[3] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg3);
5981 arg4 = (guint) va_arg (args_copy, guint);
5982 arg5 = (guint) va_arg (args_copy, guint);
5983 va_end (args_copy);
5984
5985
5986 if (G_CCLOSURE_SWAP_DATA (closure))
5987 {
5988 data1 = closure->data;
5989 data2 = instance;
5990 }
5991 else
5992 {
5993 data1 = instance;
5994 data2 = closure->data;
5995 }
5996 callback = (GMarshalFunc_VOID__OBJECT_INT_INT_BOXED_UINT_UINT) (marshal_data ? marshal_data : cc->callback);
5997
5998 callback (data1,
5999 arg0,
6000 arg1,
6001 arg2,
6002 arg3,
6003 arg4,
6004 arg5,
6005 data2);
6006 if (arg0 != NULL)
6007 g_object_unref (arg0);
6008 if ((param_types[3] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg3 != NULL)
6009 g_boxed_free (param_types[3] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg3);
6010 }
6011
6012 /* VOID:OBJECT,OBJECT (./gtkmarshalers.list:92) */
6013 void
_gtk_marshal_VOID__OBJECT_OBJECT(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)6014 _gtk_marshal_VOID__OBJECT_OBJECT (GClosure *closure,
6015 GValue *return_value G_GNUC_UNUSED,
6016 guint n_param_values,
6017 const GValue *param_values,
6018 gpointer invocation_hint G_GNUC_UNUSED,
6019 gpointer marshal_data)
6020 {
6021 typedef void (*GMarshalFunc_VOID__OBJECT_OBJECT) (gpointer data1,
6022 gpointer arg1,
6023 gpointer arg2,
6024 gpointer data2);
6025 GCClosure *cc = (GCClosure *) closure;
6026 gpointer data1, data2;
6027 GMarshalFunc_VOID__OBJECT_OBJECT callback;
6028
6029 g_return_if_fail (n_param_values == 3);
6030
6031 if (G_CCLOSURE_SWAP_DATA (closure))
6032 {
6033 data1 = closure->data;
6034 data2 = g_value_peek_pointer (param_values + 0);
6035 }
6036 else
6037 {
6038 data1 = g_value_peek_pointer (param_values + 0);
6039 data2 = closure->data;
6040 }
6041 callback = (GMarshalFunc_VOID__OBJECT_OBJECT) (marshal_data ? marshal_data : cc->callback);
6042
6043 callback (data1,
6044 g_marshal_value_peek_object (param_values + 1),
6045 g_marshal_value_peek_object (param_values + 2),
6046 data2);
6047 }
6048
6049 void
_gtk_marshal_VOID__OBJECT_OBJECTv(GClosure * closure,GValue * return_value G_GNUC_UNUSED,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)6050 _gtk_marshal_VOID__OBJECT_OBJECTv (GClosure *closure,
6051 GValue *return_value G_GNUC_UNUSED,
6052 gpointer instance,
6053 va_list args,
6054 gpointer marshal_data,
6055 int n_params,
6056 GType *param_types)
6057 {
6058 typedef void (*GMarshalFunc_VOID__OBJECT_OBJECT) (gpointer data1,
6059 gpointer arg1,
6060 gpointer arg2,
6061 gpointer data2);
6062 GCClosure *cc = (GCClosure *) closure;
6063 gpointer data1, data2;
6064 GMarshalFunc_VOID__OBJECT_OBJECT callback;
6065 gpointer arg0;
6066 gpointer arg1;
6067 va_list args_copy;
6068
6069 G_VA_COPY (args_copy, args);
6070 arg0 = (gpointer) va_arg (args_copy, gpointer);
6071 if (arg0 != NULL)
6072 arg0 = g_object_ref (arg0);
6073 arg1 = (gpointer) va_arg (args_copy, gpointer);
6074 if (arg1 != NULL)
6075 arg1 = g_object_ref (arg1);
6076 va_end (args_copy);
6077
6078
6079 if (G_CCLOSURE_SWAP_DATA (closure))
6080 {
6081 data1 = closure->data;
6082 data2 = instance;
6083 }
6084 else
6085 {
6086 data1 = instance;
6087 data2 = closure->data;
6088 }
6089 callback = (GMarshalFunc_VOID__OBJECT_OBJECT) (marshal_data ? marshal_data : cc->callback);
6090
6091 callback (data1,
6092 arg0,
6093 arg1,
6094 data2);
6095 if (arg0 != NULL)
6096 g_object_unref (arg0);
6097 if (arg1 != NULL)
6098 g_object_unref (arg1);
6099 }
6100
6101 /* VOID:OBJECT,POINTER (./gtkmarshalers.list:93) */
6102 void
_gtk_marshal_VOID__OBJECT_POINTER(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)6103 _gtk_marshal_VOID__OBJECT_POINTER (GClosure *closure,
6104 GValue *return_value G_GNUC_UNUSED,
6105 guint n_param_values,
6106 const GValue *param_values,
6107 gpointer invocation_hint G_GNUC_UNUSED,
6108 gpointer marshal_data)
6109 {
6110 typedef void (*GMarshalFunc_VOID__OBJECT_POINTER) (gpointer data1,
6111 gpointer arg1,
6112 gpointer arg2,
6113 gpointer data2);
6114 GCClosure *cc = (GCClosure *) closure;
6115 gpointer data1, data2;
6116 GMarshalFunc_VOID__OBJECT_POINTER callback;
6117
6118 g_return_if_fail (n_param_values == 3);
6119
6120 if (G_CCLOSURE_SWAP_DATA (closure))
6121 {
6122 data1 = closure->data;
6123 data2 = g_value_peek_pointer (param_values + 0);
6124 }
6125 else
6126 {
6127 data1 = g_value_peek_pointer (param_values + 0);
6128 data2 = closure->data;
6129 }
6130 callback = (GMarshalFunc_VOID__OBJECT_POINTER) (marshal_data ? marshal_data : cc->callback);
6131
6132 callback (data1,
6133 g_marshal_value_peek_object (param_values + 1),
6134 g_marshal_value_peek_pointer (param_values + 2),
6135 data2);
6136 }
6137
6138 void
_gtk_marshal_VOID__OBJECT_POINTERv(GClosure * closure,GValue * return_value G_GNUC_UNUSED,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)6139 _gtk_marshal_VOID__OBJECT_POINTERv (GClosure *closure,
6140 GValue *return_value G_GNUC_UNUSED,
6141 gpointer instance,
6142 va_list args,
6143 gpointer marshal_data,
6144 int n_params,
6145 GType *param_types)
6146 {
6147 typedef void (*GMarshalFunc_VOID__OBJECT_POINTER) (gpointer data1,
6148 gpointer arg1,
6149 gpointer arg2,
6150 gpointer data2);
6151 GCClosure *cc = (GCClosure *) closure;
6152 gpointer data1, data2;
6153 GMarshalFunc_VOID__OBJECT_POINTER callback;
6154 gpointer arg0;
6155 gpointer arg1;
6156 va_list args_copy;
6157
6158 G_VA_COPY (args_copy, args);
6159 arg0 = (gpointer) va_arg (args_copy, gpointer);
6160 if (arg0 != NULL)
6161 arg0 = g_object_ref (arg0);
6162 arg1 = (gpointer) va_arg (args_copy, gpointer);
6163 va_end (args_copy);
6164
6165
6166 if (G_CCLOSURE_SWAP_DATA (closure))
6167 {
6168 data1 = closure->data;
6169 data2 = instance;
6170 }
6171 else
6172 {
6173 data1 = instance;
6174 data2 = closure->data;
6175 }
6176 callback = (GMarshalFunc_VOID__OBJECT_POINTER) (marshal_data ? marshal_data : cc->callback);
6177
6178 callback (data1,
6179 arg0,
6180 arg1,
6181 data2);
6182 if (arg0 != NULL)
6183 g_object_unref (arg0);
6184 }
6185
6186 /* VOID:OBJECT,POINTER,INT (./gtkmarshalers.list:94) */
6187 void
_gtk_marshal_VOID__OBJECT_POINTER_INT(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)6188 _gtk_marshal_VOID__OBJECT_POINTER_INT (GClosure *closure,
6189 GValue *return_value G_GNUC_UNUSED,
6190 guint n_param_values,
6191 const GValue *param_values,
6192 gpointer invocation_hint G_GNUC_UNUSED,
6193 gpointer marshal_data)
6194 {
6195 typedef void (*GMarshalFunc_VOID__OBJECT_POINTER_INT) (gpointer data1,
6196 gpointer arg1,
6197 gpointer arg2,
6198 gint arg3,
6199 gpointer data2);
6200 GCClosure *cc = (GCClosure *) closure;
6201 gpointer data1, data2;
6202 GMarshalFunc_VOID__OBJECT_POINTER_INT callback;
6203
6204 g_return_if_fail (n_param_values == 4);
6205
6206 if (G_CCLOSURE_SWAP_DATA (closure))
6207 {
6208 data1 = closure->data;
6209 data2 = g_value_peek_pointer (param_values + 0);
6210 }
6211 else
6212 {
6213 data1 = g_value_peek_pointer (param_values + 0);
6214 data2 = closure->data;
6215 }
6216 callback = (GMarshalFunc_VOID__OBJECT_POINTER_INT) (marshal_data ? marshal_data : cc->callback);
6217
6218 callback (data1,
6219 g_marshal_value_peek_object (param_values + 1),
6220 g_marshal_value_peek_pointer (param_values + 2),
6221 g_marshal_value_peek_int (param_values + 3),
6222 data2);
6223 }
6224
6225 void
_gtk_marshal_VOID__OBJECT_POINTER_INTv(GClosure * closure,GValue * return_value G_GNUC_UNUSED,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)6226 _gtk_marshal_VOID__OBJECT_POINTER_INTv (GClosure *closure,
6227 GValue *return_value G_GNUC_UNUSED,
6228 gpointer instance,
6229 va_list args,
6230 gpointer marshal_data,
6231 int n_params,
6232 GType *param_types)
6233 {
6234 typedef void (*GMarshalFunc_VOID__OBJECT_POINTER_INT) (gpointer data1,
6235 gpointer arg1,
6236 gpointer arg2,
6237 gint arg3,
6238 gpointer data2);
6239 GCClosure *cc = (GCClosure *) closure;
6240 gpointer data1, data2;
6241 GMarshalFunc_VOID__OBJECT_POINTER_INT callback;
6242 gpointer arg0;
6243 gpointer arg1;
6244 gint arg2;
6245 va_list args_copy;
6246
6247 G_VA_COPY (args_copy, args);
6248 arg0 = (gpointer) va_arg (args_copy, gpointer);
6249 if (arg0 != NULL)
6250 arg0 = g_object_ref (arg0);
6251 arg1 = (gpointer) va_arg (args_copy, gpointer);
6252 arg2 = (gint) va_arg (args_copy, gint);
6253 va_end (args_copy);
6254
6255
6256 if (G_CCLOSURE_SWAP_DATA (closure))
6257 {
6258 data1 = closure->data;
6259 data2 = instance;
6260 }
6261 else
6262 {
6263 data1 = instance;
6264 data2 = closure->data;
6265 }
6266 callback = (GMarshalFunc_VOID__OBJECT_POINTER_INT) (marshal_data ? marshal_data : cc->callback);
6267
6268 callback (data1,
6269 arg0,
6270 arg1,
6271 arg2,
6272 data2);
6273 if (arg0 != NULL)
6274 g_object_unref (arg0);
6275 }
6276
6277 /* VOID:OBJECT,STRING (./gtkmarshalers.list:95) */
6278 void
_gtk_marshal_VOID__OBJECT_STRING(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)6279 _gtk_marshal_VOID__OBJECT_STRING (GClosure *closure,
6280 GValue *return_value G_GNUC_UNUSED,
6281 guint n_param_values,
6282 const GValue *param_values,
6283 gpointer invocation_hint G_GNUC_UNUSED,
6284 gpointer marshal_data)
6285 {
6286 typedef void (*GMarshalFunc_VOID__OBJECT_STRING) (gpointer data1,
6287 gpointer arg1,
6288 gpointer arg2,
6289 gpointer data2);
6290 GCClosure *cc = (GCClosure *) closure;
6291 gpointer data1, data2;
6292 GMarshalFunc_VOID__OBJECT_STRING callback;
6293
6294 g_return_if_fail (n_param_values == 3);
6295
6296 if (G_CCLOSURE_SWAP_DATA (closure))
6297 {
6298 data1 = closure->data;
6299 data2 = g_value_peek_pointer (param_values + 0);
6300 }
6301 else
6302 {
6303 data1 = g_value_peek_pointer (param_values + 0);
6304 data2 = closure->data;
6305 }
6306 callback = (GMarshalFunc_VOID__OBJECT_STRING) (marshal_data ? marshal_data : cc->callback);
6307
6308 callback (data1,
6309 g_marshal_value_peek_object (param_values + 1),
6310 g_marshal_value_peek_string (param_values + 2),
6311 data2);
6312 }
6313
6314 void
_gtk_marshal_VOID__OBJECT_STRINGv(GClosure * closure,GValue * return_value G_GNUC_UNUSED,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)6315 _gtk_marshal_VOID__OBJECT_STRINGv (GClosure *closure,
6316 GValue *return_value G_GNUC_UNUSED,
6317 gpointer instance,
6318 va_list args,
6319 gpointer marshal_data,
6320 int n_params,
6321 GType *param_types)
6322 {
6323 typedef void (*GMarshalFunc_VOID__OBJECT_STRING) (gpointer data1,
6324 gpointer arg1,
6325 gpointer arg2,
6326 gpointer data2);
6327 GCClosure *cc = (GCClosure *) closure;
6328 gpointer data1, data2;
6329 GMarshalFunc_VOID__OBJECT_STRING callback;
6330 gpointer arg0;
6331 gpointer arg1;
6332 va_list args_copy;
6333
6334 G_VA_COPY (args_copy, args);
6335 arg0 = (gpointer) va_arg (args_copy, gpointer);
6336 if (arg0 != NULL)
6337 arg0 = g_object_ref (arg0);
6338 arg1 = (gpointer) va_arg (args_copy, gpointer);
6339 if ((param_types[1] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg1 != NULL)
6340 arg1 = g_strdup (arg1);
6341 va_end (args_copy);
6342
6343
6344 if (G_CCLOSURE_SWAP_DATA (closure))
6345 {
6346 data1 = closure->data;
6347 data2 = instance;
6348 }
6349 else
6350 {
6351 data1 = instance;
6352 data2 = closure->data;
6353 }
6354 callback = (GMarshalFunc_VOID__OBJECT_STRING) (marshal_data ? marshal_data : cc->callback);
6355
6356 callback (data1,
6357 arg0,
6358 arg1,
6359 data2);
6360 if (arg0 != NULL)
6361 g_object_unref (arg0);
6362 if ((param_types[1] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg1 != NULL)
6363 g_free (arg1);
6364 }
6365
6366 /* VOID:OBJECT,STRING,STRING (./gtkmarshalers.list:96) */
6367 void
_gtk_marshal_VOID__OBJECT_STRING_STRING(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)6368 _gtk_marshal_VOID__OBJECT_STRING_STRING (GClosure *closure,
6369 GValue *return_value G_GNUC_UNUSED,
6370 guint n_param_values,
6371 const GValue *param_values,
6372 gpointer invocation_hint G_GNUC_UNUSED,
6373 gpointer marshal_data)
6374 {
6375 typedef void (*GMarshalFunc_VOID__OBJECT_STRING_STRING) (gpointer data1,
6376 gpointer arg1,
6377 gpointer arg2,
6378 gpointer arg3,
6379 gpointer data2);
6380 GCClosure *cc = (GCClosure *) closure;
6381 gpointer data1, data2;
6382 GMarshalFunc_VOID__OBJECT_STRING_STRING callback;
6383
6384 g_return_if_fail (n_param_values == 4);
6385
6386 if (G_CCLOSURE_SWAP_DATA (closure))
6387 {
6388 data1 = closure->data;
6389 data2 = g_value_peek_pointer (param_values + 0);
6390 }
6391 else
6392 {
6393 data1 = g_value_peek_pointer (param_values + 0);
6394 data2 = closure->data;
6395 }
6396 callback = (GMarshalFunc_VOID__OBJECT_STRING_STRING) (marshal_data ? marshal_data : cc->callback);
6397
6398 callback (data1,
6399 g_marshal_value_peek_object (param_values + 1),
6400 g_marshal_value_peek_string (param_values + 2),
6401 g_marshal_value_peek_string (param_values + 3),
6402 data2);
6403 }
6404
6405 void
_gtk_marshal_VOID__OBJECT_STRING_STRINGv(GClosure * closure,GValue * return_value G_GNUC_UNUSED,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)6406 _gtk_marshal_VOID__OBJECT_STRING_STRINGv (GClosure *closure,
6407 GValue *return_value G_GNUC_UNUSED,
6408 gpointer instance,
6409 va_list args,
6410 gpointer marshal_data,
6411 int n_params,
6412 GType *param_types)
6413 {
6414 typedef void (*GMarshalFunc_VOID__OBJECT_STRING_STRING) (gpointer data1,
6415 gpointer arg1,
6416 gpointer arg2,
6417 gpointer arg3,
6418 gpointer data2);
6419 GCClosure *cc = (GCClosure *) closure;
6420 gpointer data1, data2;
6421 GMarshalFunc_VOID__OBJECT_STRING_STRING callback;
6422 gpointer arg0;
6423 gpointer arg1;
6424 gpointer arg2;
6425 va_list args_copy;
6426
6427 G_VA_COPY (args_copy, args);
6428 arg0 = (gpointer) va_arg (args_copy, gpointer);
6429 if (arg0 != NULL)
6430 arg0 = g_object_ref (arg0);
6431 arg1 = (gpointer) va_arg (args_copy, gpointer);
6432 if ((param_types[1] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg1 != NULL)
6433 arg1 = g_strdup (arg1);
6434 arg2 = (gpointer) va_arg (args_copy, gpointer);
6435 if ((param_types[2] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg2 != NULL)
6436 arg2 = g_strdup (arg2);
6437 va_end (args_copy);
6438
6439
6440 if (G_CCLOSURE_SWAP_DATA (closure))
6441 {
6442 data1 = closure->data;
6443 data2 = instance;
6444 }
6445 else
6446 {
6447 data1 = instance;
6448 data2 = closure->data;
6449 }
6450 callback = (GMarshalFunc_VOID__OBJECT_STRING_STRING) (marshal_data ? marshal_data : cc->callback);
6451
6452 callback (data1,
6453 arg0,
6454 arg1,
6455 arg2,
6456 data2);
6457 if (arg0 != NULL)
6458 g_object_unref (arg0);
6459 if ((param_types[1] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg1 != NULL)
6460 g_free (arg1);
6461 if ((param_types[2] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg2 != NULL)
6462 g_free (arg2);
6463 }
6464
6465 /* VOID:OBJECT,UINT (./gtkmarshalers.list:97) */
6466 void
_gtk_marshal_VOID__OBJECT_UINT(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)6467 _gtk_marshal_VOID__OBJECT_UINT (GClosure *closure,
6468 GValue *return_value G_GNUC_UNUSED,
6469 guint n_param_values,
6470 const GValue *param_values,
6471 gpointer invocation_hint G_GNUC_UNUSED,
6472 gpointer marshal_data)
6473 {
6474 typedef void (*GMarshalFunc_VOID__OBJECT_UINT) (gpointer data1,
6475 gpointer arg1,
6476 guint arg2,
6477 gpointer data2);
6478 GCClosure *cc = (GCClosure *) closure;
6479 gpointer data1, data2;
6480 GMarshalFunc_VOID__OBJECT_UINT callback;
6481
6482 g_return_if_fail (n_param_values == 3);
6483
6484 if (G_CCLOSURE_SWAP_DATA (closure))
6485 {
6486 data1 = closure->data;
6487 data2 = g_value_peek_pointer (param_values + 0);
6488 }
6489 else
6490 {
6491 data1 = g_value_peek_pointer (param_values + 0);
6492 data2 = closure->data;
6493 }
6494 callback = (GMarshalFunc_VOID__OBJECT_UINT) (marshal_data ? marshal_data : cc->callback);
6495
6496 callback (data1,
6497 g_marshal_value_peek_object (param_values + 1),
6498 g_marshal_value_peek_uint (param_values + 2),
6499 data2);
6500 }
6501
6502 void
_gtk_marshal_VOID__OBJECT_UINTv(GClosure * closure,GValue * return_value G_GNUC_UNUSED,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)6503 _gtk_marshal_VOID__OBJECT_UINTv (GClosure *closure,
6504 GValue *return_value G_GNUC_UNUSED,
6505 gpointer instance,
6506 va_list args,
6507 gpointer marshal_data,
6508 int n_params,
6509 GType *param_types)
6510 {
6511 typedef void (*GMarshalFunc_VOID__OBJECT_UINT) (gpointer data1,
6512 gpointer arg1,
6513 guint arg2,
6514 gpointer data2);
6515 GCClosure *cc = (GCClosure *) closure;
6516 gpointer data1, data2;
6517 GMarshalFunc_VOID__OBJECT_UINT callback;
6518 gpointer arg0;
6519 guint arg1;
6520 va_list args_copy;
6521
6522 G_VA_COPY (args_copy, args);
6523 arg0 = (gpointer) va_arg (args_copy, gpointer);
6524 if (arg0 != NULL)
6525 arg0 = g_object_ref (arg0);
6526 arg1 = (guint) va_arg (args_copy, guint);
6527 va_end (args_copy);
6528
6529
6530 if (G_CCLOSURE_SWAP_DATA (closure))
6531 {
6532 data1 = closure->data;
6533 data2 = instance;
6534 }
6535 else
6536 {
6537 data1 = instance;
6538 data2 = closure->data;
6539 }
6540 callback = (GMarshalFunc_VOID__OBJECT_UINT) (marshal_data ? marshal_data : cc->callback);
6541
6542 callback (data1,
6543 arg0,
6544 arg1,
6545 data2);
6546 if (arg0 != NULL)
6547 g_object_unref (arg0);
6548 }
6549
6550 /* VOID:OBJECT,UINT,FLAGS (./gtkmarshalers.list:98) */
6551 void
_gtk_marshal_VOID__OBJECT_UINT_FLAGS(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)6552 _gtk_marshal_VOID__OBJECT_UINT_FLAGS (GClosure *closure,
6553 GValue *return_value G_GNUC_UNUSED,
6554 guint n_param_values,
6555 const GValue *param_values,
6556 gpointer invocation_hint G_GNUC_UNUSED,
6557 gpointer marshal_data)
6558 {
6559 typedef void (*GMarshalFunc_VOID__OBJECT_UINT_FLAGS) (gpointer data1,
6560 gpointer arg1,
6561 guint arg2,
6562 guint arg3,
6563 gpointer data2);
6564 GCClosure *cc = (GCClosure *) closure;
6565 gpointer data1, data2;
6566 GMarshalFunc_VOID__OBJECT_UINT_FLAGS callback;
6567
6568 g_return_if_fail (n_param_values == 4);
6569
6570 if (G_CCLOSURE_SWAP_DATA (closure))
6571 {
6572 data1 = closure->data;
6573 data2 = g_value_peek_pointer (param_values + 0);
6574 }
6575 else
6576 {
6577 data1 = g_value_peek_pointer (param_values + 0);
6578 data2 = closure->data;
6579 }
6580 callback = (GMarshalFunc_VOID__OBJECT_UINT_FLAGS) (marshal_data ? marshal_data : cc->callback);
6581
6582 callback (data1,
6583 g_marshal_value_peek_object (param_values + 1),
6584 g_marshal_value_peek_uint (param_values + 2),
6585 g_marshal_value_peek_flags (param_values + 3),
6586 data2);
6587 }
6588
6589 void
_gtk_marshal_VOID__OBJECT_UINT_FLAGSv(GClosure * closure,GValue * return_value G_GNUC_UNUSED,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)6590 _gtk_marshal_VOID__OBJECT_UINT_FLAGSv (GClosure *closure,
6591 GValue *return_value G_GNUC_UNUSED,
6592 gpointer instance,
6593 va_list args,
6594 gpointer marshal_data,
6595 int n_params,
6596 GType *param_types)
6597 {
6598 typedef void (*GMarshalFunc_VOID__OBJECT_UINT_FLAGS) (gpointer data1,
6599 gpointer arg1,
6600 guint arg2,
6601 guint arg3,
6602 gpointer data2);
6603 GCClosure *cc = (GCClosure *) closure;
6604 gpointer data1, data2;
6605 GMarshalFunc_VOID__OBJECT_UINT_FLAGS callback;
6606 gpointer arg0;
6607 guint arg1;
6608 guint arg2;
6609 va_list args_copy;
6610
6611 G_VA_COPY (args_copy, args);
6612 arg0 = (gpointer) va_arg (args_copy, gpointer);
6613 if (arg0 != NULL)
6614 arg0 = g_object_ref (arg0);
6615 arg1 = (guint) va_arg (args_copy, guint);
6616 arg2 = (guint) va_arg (args_copy, guint);
6617 va_end (args_copy);
6618
6619
6620 if (G_CCLOSURE_SWAP_DATA (closure))
6621 {
6622 data1 = closure->data;
6623 data2 = instance;
6624 }
6625 else
6626 {
6627 data1 = instance;
6628 data2 = closure->data;
6629 }
6630 callback = (GMarshalFunc_VOID__OBJECT_UINT_FLAGS) (marshal_data ? marshal_data : cc->callback);
6631
6632 callback (data1,
6633 arg0,
6634 arg1,
6635 arg2,
6636 data2);
6637 if (arg0 != NULL)
6638 g_object_unref (arg0);
6639 }
6640
6641 /* VOID:OBJECT,OBJECT,STRING (./gtkmarshalers.list:100) */
6642 void
_gtk_marshal_VOID__OBJECT_OBJECT_STRING(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)6643 _gtk_marshal_VOID__OBJECT_OBJECT_STRING (GClosure *closure,
6644 GValue *return_value G_GNUC_UNUSED,
6645 guint n_param_values,
6646 const GValue *param_values,
6647 gpointer invocation_hint G_GNUC_UNUSED,
6648 gpointer marshal_data)
6649 {
6650 typedef void (*GMarshalFunc_VOID__OBJECT_OBJECT_STRING) (gpointer data1,
6651 gpointer arg1,
6652 gpointer arg2,
6653 gpointer arg3,
6654 gpointer data2);
6655 GCClosure *cc = (GCClosure *) closure;
6656 gpointer data1, data2;
6657 GMarshalFunc_VOID__OBJECT_OBJECT_STRING callback;
6658
6659 g_return_if_fail (n_param_values == 4);
6660
6661 if (G_CCLOSURE_SWAP_DATA (closure))
6662 {
6663 data1 = closure->data;
6664 data2 = g_value_peek_pointer (param_values + 0);
6665 }
6666 else
6667 {
6668 data1 = g_value_peek_pointer (param_values + 0);
6669 data2 = closure->data;
6670 }
6671 callback = (GMarshalFunc_VOID__OBJECT_OBJECT_STRING) (marshal_data ? marshal_data : cc->callback);
6672
6673 callback (data1,
6674 g_marshal_value_peek_object (param_values + 1),
6675 g_marshal_value_peek_object (param_values + 2),
6676 g_marshal_value_peek_string (param_values + 3),
6677 data2);
6678 }
6679
6680 void
_gtk_marshal_VOID__OBJECT_OBJECT_STRINGv(GClosure * closure,GValue * return_value G_GNUC_UNUSED,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)6681 _gtk_marshal_VOID__OBJECT_OBJECT_STRINGv (GClosure *closure,
6682 GValue *return_value G_GNUC_UNUSED,
6683 gpointer instance,
6684 va_list args,
6685 gpointer marshal_data,
6686 int n_params,
6687 GType *param_types)
6688 {
6689 typedef void (*GMarshalFunc_VOID__OBJECT_OBJECT_STRING) (gpointer data1,
6690 gpointer arg1,
6691 gpointer arg2,
6692 gpointer arg3,
6693 gpointer data2);
6694 GCClosure *cc = (GCClosure *) closure;
6695 gpointer data1, data2;
6696 GMarshalFunc_VOID__OBJECT_OBJECT_STRING callback;
6697 gpointer arg0;
6698 gpointer arg1;
6699 gpointer arg2;
6700 va_list args_copy;
6701
6702 G_VA_COPY (args_copy, args);
6703 arg0 = (gpointer) va_arg (args_copy, gpointer);
6704 if (arg0 != NULL)
6705 arg0 = g_object_ref (arg0);
6706 arg1 = (gpointer) va_arg (args_copy, gpointer);
6707 if (arg1 != NULL)
6708 arg1 = g_object_ref (arg1);
6709 arg2 = (gpointer) va_arg (args_copy, gpointer);
6710 if ((param_types[2] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg2 != NULL)
6711 arg2 = g_strdup (arg2);
6712 va_end (args_copy);
6713
6714
6715 if (G_CCLOSURE_SWAP_DATA (closure))
6716 {
6717 data1 = closure->data;
6718 data2 = instance;
6719 }
6720 else
6721 {
6722 data1 = instance;
6723 data2 = closure->data;
6724 }
6725 callback = (GMarshalFunc_VOID__OBJECT_OBJECT_STRING) (marshal_data ? marshal_data : cc->callback);
6726
6727 callback (data1,
6728 arg0,
6729 arg1,
6730 arg2,
6731 data2);
6732 if (arg0 != NULL)
6733 g_object_unref (arg0);
6734 if (arg1 != NULL)
6735 g_object_unref (arg1);
6736 if ((param_types[2] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg2 != NULL)
6737 g_free (arg2);
6738 }
6739
6740 /* VOID:OBJECT,OBJECT,OBJECT (./gtkmarshalers.list:101) */
6741 void
_gtk_marshal_VOID__OBJECT_OBJECT_OBJECT(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)6742 _gtk_marshal_VOID__OBJECT_OBJECT_OBJECT (GClosure *closure,
6743 GValue *return_value G_GNUC_UNUSED,
6744 guint n_param_values,
6745 const GValue *param_values,
6746 gpointer invocation_hint G_GNUC_UNUSED,
6747 gpointer marshal_data)
6748 {
6749 typedef void (*GMarshalFunc_VOID__OBJECT_OBJECT_OBJECT) (gpointer data1,
6750 gpointer arg1,
6751 gpointer arg2,
6752 gpointer arg3,
6753 gpointer data2);
6754 GCClosure *cc = (GCClosure *) closure;
6755 gpointer data1, data2;
6756 GMarshalFunc_VOID__OBJECT_OBJECT_OBJECT callback;
6757
6758 g_return_if_fail (n_param_values == 4);
6759
6760 if (G_CCLOSURE_SWAP_DATA (closure))
6761 {
6762 data1 = closure->data;
6763 data2 = g_value_peek_pointer (param_values + 0);
6764 }
6765 else
6766 {
6767 data1 = g_value_peek_pointer (param_values + 0);
6768 data2 = closure->data;
6769 }
6770 callback = (GMarshalFunc_VOID__OBJECT_OBJECT_OBJECT) (marshal_data ? marshal_data : cc->callback);
6771
6772 callback (data1,
6773 g_marshal_value_peek_object (param_values + 1),
6774 g_marshal_value_peek_object (param_values + 2),
6775 g_marshal_value_peek_object (param_values + 3),
6776 data2);
6777 }
6778
6779 void
_gtk_marshal_VOID__OBJECT_OBJECT_OBJECTv(GClosure * closure,GValue * return_value G_GNUC_UNUSED,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)6780 _gtk_marshal_VOID__OBJECT_OBJECT_OBJECTv (GClosure *closure,
6781 GValue *return_value G_GNUC_UNUSED,
6782 gpointer instance,
6783 va_list args,
6784 gpointer marshal_data,
6785 int n_params,
6786 GType *param_types)
6787 {
6788 typedef void (*GMarshalFunc_VOID__OBJECT_OBJECT_OBJECT) (gpointer data1,
6789 gpointer arg1,
6790 gpointer arg2,
6791 gpointer arg3,
6792 gpointer data2);
6793 GCClosure *cc = (GCClosure *) closure;
6794 gpointer data1, data2;
6795 GMarshalFunc_VOID__OBJECT_OBJECT_OBJECT callback;
6796 gpointer arg0;
6797 gpointer arg1;
6798 gpointer arg2;
6799 va_list args_copy;
6800
6801 G_VA_COPY (args_copy, args);
6802 arg0 = (gpointer) va_arg (args_copy, gpointer);
6803 if (arg0 != NULL)
6804 arg0 = g_object_ref (arg0);
6805 arg1 = (gpointer) va_arg (args_copy, gpointer);
6806 if (arg1 != NULL)
6807 arg1 = g_object_ref (arg1);
6808 arg2 = (gpointer) va_arg (args_copy, gpointer);
6809 if (arg2 != NULL)
6810 arg2 = g_object_ref (arg2);
6811 va_end (args_copy);
6812
6813
6814 if (G_CCLOSURE_SWAP_DATA (closure))
6815 {
6816 data1 = closure->data;
6817 data2 = instance;
6818 }
6819 else
6820 {
6821 data1 = instance;
6822 data2 = closure->data;
6823 }
6824 callback = (GMarshalFunc_VOID__OBJECT_OBJECT_OBJECT) (marshal_data ? marshal_data : cc->callback);
6825
6826 callback (data1,
6827 arg0,
6828 arg1,
6829 arg2,
6830 data2);
6831 if (arg0 != NULL)
6832 g_object_unref (arg0);
6833 if (arg1 != NULL)
6834 g_object_unref (arg1);
6835 if (arg2 != NULL)
6836 g_object_unref (arg2);
6837 }
6838
6839 /* VOID:OBJECT,OBJECT,BOXED,STRING (./gtkmarshalers.list:102) */
6840 void
_gtk_marshal_VOID__OBJECT_OBJECT_BOXED_STRING(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)6841 _gtk_marshal_VOID__OBJECT_OBJECT_BOXED_STRING (GClosure *closure,
6842 GValue *return_value G_GNUC_UNUSED,
6843 guint n_param_values,
6844 const GValue *param_values,
6845 gpointer invocation_hint G_GNUC_UNUSED,
6846 gpointer marshal_data)
6847 {
6848 typedef void (*GMarshalFunc_VOID__OBJECT_OBJECT_BOXED_STRING) (gpointer data1,
6849 gpointer arg1,
6850 gpointer arg2,
6851 gpointer arg3,
6852 gpointer arg4,
6853 gpointer data2);
6854 GCClosure *cc = (GCClosure *) closure;
6855 gpointer data1, data2;
6856 GMarshalFunc_VOID__OBJECT_OBJECT_BOXED_STRING callback;
6857
6858 g_return_if_fail (n_param_values == 5);
6859
6860 if (G_CCLOSURE_SWAP_DATA (closure))
6861 {
6862 data1 = closure->data;
6863 data2 = g_value_peek_pointer (param_values + 0);
6864 }
6865 else
6866 {
6867 data1 = g_value_peek_pointer (param_values + 0);
6868 data2 = closure->data;
6869 }
6870 callback = (GMarshalFunc_VOID__OBJECT_OBJECT_BOXED_STRING) (marshal_data ? marshal_data : cc->callback);
6871
6872 callback (data1,
6873 g_marshal_value_peek_object (param_values + 1),
6874 g_marshal_value_peek_object (param_values + 2),
6875 g_marshal_value_peek_boxed (param_values + 3),
6876 g_marshal_value_peek_string (param_values + 4),
6877 data2);
6878 }
6879
6880 void
_gtk_marshal_VOID__OBJECT_OBJECT_BOXED_STRINGv(GClosure * closure,GValue * return_value G_GNUC_UNUSED,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)6881 _gtk_marshal_VOID__OBJECT_OBJECT_BOXED_STRINGv (GClosure *closure,
6882 GValue *return_value G_GNUC_UNUSED,
6883 gpointer instance,
6884 va_list args,
6885 gpointer marshal_data,
6886 int n_params,
6887 GType *param_types)
6888 {
6889 typedef void (*GMarshalFunc_VOID__OBJECT_OBJECT_BOXED_STRING) (gpointer data1,
6890 gpointer arg1,
6891 gpointer arg2,
6892 gpointer arg3,
6893 gpointer arg4,
6894 gpointer data2);
6895 GCClosure *cc = (GCClosure *) closure;
6896 gpointer data1, data2;
6897 GMarshalFunc_VOID__OBJECT_OBJECT_BOXED_STRING callback;
6898 gpointer arg0;
6899 gpointer arg1;
6900 gpointer arg2;
6901 gpointer arg3;
6902 va_list args_copy;
6903
6904 G_VA_COPY (args_copy, args);
6905 arg0 = (gpointer) va_arg (args_copy, gpointer);
6906 if (arg0 != NULL)
6907 arg0 = g_object_ref (arg0);
6908 arg1 = (gpointer) va_arg (args_copy, gpointer);
6909 if (arg1 != NULL)
6910 arg1 = g_object_ref (arg1);
6911 arg2 = (gpointer) va_arg (args_copy, gpointer);
6912 if ((param_types[2] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg2 != NULL)
6913 arg2 = g_boxed_copy (param_types[2] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg2);
6914 arg3 = (gpointer) va_arg (args_copy, gpointer);
6915 if ((param_types[3] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg3 != NULL)
6916 arg3 = g_strdup (arg3);
6917 va_end (args_copy);
6918
6919
6920 if (G_CCLOSURE_SWAP_DATA (closure))
6921 {
6922 data1 = closure->data;
6923 data2 = instance;
6924 }
6925 else
6926 {
6927 data1 = instance;
6928 data2 = closure->data;
6929 }
6930 callback = (GMarshalFunc_VOID__OBJECT_OBJECT_BOXED_STRING) (marshal_data ? marshal_data : cc->callback);
6931
6932 callback (data1,
6933 arg0,
6934 arg1,
6935 arg2,
6936 arg3,
6937 data2);
6938 if (arg0 != NULL)
6939 g_object_unref (arg0);
6940 if (arg1 != NULL)
6941 g_object_unref (arg1);
6942 if ((param_types[2] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg2 != NULL)
6943 g_boxed_free (param_types[2] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg2);
6944 if ((param_types[3] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg3 != NULL)
6945 g_free (arg3);
6946 }
6947
6948 /* VOID:OBJECT,OBJECT,POINTER,POINTER (./gtkmarshalers.list:103) */
6949 void
_gtk_marshal_VOID__OBJECT_OBJECT_POINTER_POINTER(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)6950 _gtk_marshal_VOID__OBJECT_OBJECT_POINTER_POINTER (GClosure *closure,
6951 GValue *return_value G_GNUC_UNUSED,
6952 guint n_param_values,
6953 const GValue *param_values,
6954 gpointer invocation_hint G_GNUC_UNUSED,
6955 gpointer marshal_data)
6956 {
6957 typedef void (*GMarshalFunc_VOID__OBJECT_OBJECT_POINTER_POINTER) (gpointer data1,
6958 gpointer arg1,
6959 gpointer arg2,
6960 gpointer arg3,
6961 gpointer arg4,
6962 gpointer data2);
6963 GCClosure *cc = (GCClosure *) closure;
6964 gpointer data1, data2;
6965 GMarshalFunc_VOID__OBJECT_OBJECT_POINTER_POINTER callback;
6966
6967 g_return_if_fail (n_param_values == 5);
6968
6969 if (G_CCLOSURE_SWAP_DATA (closure))
6970 {
6971 data1 = closure->data;
6972 data2 = g_value_peek_pointer (param_values + 0);
6973 }
6974 else
6975 {
6976 data1 = g_value_peek_pointer (param_values + 0);
6977 data2 = closure->data;
6978 }
6979 callback = (GMarshalFunc_VOID__OBJECT_OBJECT_POINTER_POINTER) (marshal_data ? marshal_data : cc->callback);
6980
6981 callback (data1,
6982 g_marshal_value_peek_object (param_values + 1),
6983 g_marshal_value_peek_object (param_values + 2),
6984 g_marshal_value_peek_pointer (param_values + 3),
6985 g_marshal_value_peek_pointer (param_values + 4),
6986 data2);
6987 }
6988
6989 void
_gtk_marshal_VOID__OBJECT_OBJECT_POINTER_POINTERv(GClosure * closure,GValue * return_value G_GNUC_UNUSED,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)6990 _gtk_marshal_VOID__OBJECT_OBJECT_POINTER_POINTERv (GClosure *closure,
6991 GValue *return_value G_GNUC_UNUSED,
6992 gpointer instance,
6993 va_list args,
6994 gpointer marshal_data,
6995 int n_params,
6996 GType *param_types)
6997 {
6998 typedef void (*GMarshalFunc_VOID__OBJECT_OBJECT_POINTER_POINTER) (gpointer data1,
6999 gpointer arg1,
7000 gpointer arg2,
7001 gpointer arg3,
7002 gpointer arg4,
7003 gpointer data2);
7004 GCClosure *cc = (GCClosure *) closure;
7005 gpointer data1, data2;
7006 GMarshalFunc_VOID__OBJECT_OBJECT_POINTER_POINTER callback;
7007 gpointer arg0;
7008 gpointer arg1;
7009 gpointer arg2;
7010 gpointer arg3;
7011 va_list args_copy;
7012
7013 G_VA_COPY (args_copy, args);
7014 arg0 = (gpointer) va_arg (args_copy, gpointer);
7015 if (arg0 != NULL)
7016 arg0 = g_object_ref (arg0);
7017 arg1 = (gpointer) va_arg (args_copy, gpointer);
7018 if (arg1 != NULL)
7019 arg1 = g_object_ref (arg1);
7020 arg2 = (gpointer) va_arg (args_copy, gpointer);
7021 arg3 = (gpointer) va_arg (args_copy, gpointer);
7022 va_end (args_copy);
7023
7024
7025 if (G_CCLOSURE_SWAP_DATA (closure))
7026 {
7027 data1 = closure->data;
7028 data2 = instance;
7029 }
7030 else
7031 {
7032 data1 = instance;
7033 data2 = closure->data;
7034 }
7035 callback = (GMarshalFunc_VOID__OBJECT_OBJECT_POINTER_POINTER) (marshal_data ? marshal_data : cc->callback);
7036
7037 callback (data1,
7038 arg0,
7039 arg1,
7040 arg2,
7041 arg3,
7042 data2);
7043 if (arg0 != NULL)
7044 g_object_unref (arg0);
7045 if (arg1 != NULL)
7046 g_object_unref (arg1);
7047 }
7048
7049 /* VOID:POINTER,INT (./gtkmarshalers.list:104) */
7050 void
_gtk_marshal_VOID__POINTER_INT(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)7051 _gtk_marshal_VOID__POINTER_INT (GClosure *closure,
7052 GValue *return_value G_GNUC_UNUSED,
7053 guint n_param_values,
7054 const GValue *param_values,
7055 gpointer invocation_hint G_GNUC_UNUSED,
7056 gpointer marshal_data)
7057 {
7058 typedef void (*GMarshalFunc_VOID__POINTER_INT) (gpointer data1,
7059 gpointer arg1,
7060 gint arg2,
7061 gpointer data2);
7062 GCClosure *cc = (GCClosure *) closure;
7063 gpointer data1, data2;
7064 GMarshalFunc_VOID__POINTER_INT callback;
7065
7066 g_return_if_fail (n_param_values == 3);
7067
7068 if (G_CCLOSURE_SWAP_DATA (closure))
7069 {
7070 data1 = closure->data;
7071 data2 = g_value_peek_pointer (param_values + 0);
7072 }
7073 else
7074 {
7075 data1 = g_value_peek_pointer (param_values + 0);
7076 data2 = closure->data;
7077 }
7078 callback = (GMarshalFunc_VOID__POINTER_INT) (marshal_data ? marshal_data : cc->callback);
7079
7080 callback (data1,
7081 g_marshal_value_peek_pointer (param_values + 1),
7082 g_marshal_value_peek_int (param_values + 2),
7083 data2);
7084 }
7085
7086 void
_gtk_marshal_VOID__POINTER_INTv(GClosure * closure,GValue * return_value G_GNUC_UNUSED,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)7087 _gtk_marshal_VOID__POINTER_INTv (GClosure *closure,
7088 GValue *return_value G_GNUC_UNUSED,
7089 gpointer instance,
7090 va_list args,
7091 gpointer marshal_data,
7092 int n_params,
7093 GType *param_types)
7094 {
7095 typedef void (*GMarshalFunc_VOID__POINTER_INT) (gpointer data1,
7096 gpointer arg1,
7097 gint arg2,
7098 gpointer data2);
7099 GCClosure *cc = (GCClosure *) closure;
7100 gpointer data1, data2;
7101 GMarshalFunc_VOID__POINTER_INT callback;
7102 gpointer arg0;
7103 gint arg1;
7104 va_list args_copy;
7105
7106 G_VA_COPY (args_copy, args);
7107 arg0 = (gpointer) va_arg (args_copy, gpointer);
7108 arg1 = (gint) va_arg (args_copy, gint);
7109 va_end (args_copy);
7110
7111
7112 if (G_CCLOSURE_SWAP_DATA (closure))
7113 {
7114 data1 = closure->data;
7115 data2 = instance;
7116 }
7117 else
7118 {
7119 data1 = instance;
7120 data2 = closure->data;
7121 }
7122 callback = (GMarshalFunc_VOID__POINTER_INT) (marshal_data ? marshal_data : cc->callback);
7123
7124 callback (data1,
7125 arg0,
7126 arg1,
7127 data2);
7128
7129 }
7130
7131 /* VOID:POINTER,BOOLEAN (./gtkmarshalers.list:105) */
7132 void
_gtk_marshal_VOID__POINTER_BOOLEAN(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)7133 _gtk_marshal_VOID__POINTER_BOOLEAN (GClosure *closure,
7134 GValue *return_value G_GNUC_UNUSED,
7135 guint n_param_values,
7136 const GValue *param_values,
7137 gpointer invocation_hint G_GNUC_UNUSED,
7138 gpointer marshal_data)
7139 {
7140 typedef void (*GMarshalFunc_VOID__POINTER_BOOLEAN) (gpointer data1,
7141 gpointer arg1,
7142 gboolean arg2,
7143 gpointer data2);
7144 GCClosure *cc = (GCClosure *) closure;
7145 gpointer data1, data2;
7146 GMarshalFunc_VOID__POINTER_BOOLEAN callback;
7147
7148 g_return_if_fail (n_param_values == 3);
7149
7150 if (G_CCLOSURE_SWAP_DATA (closure))
7151 {
7152 data1 = closure->data;
7153 data2 = g_value_peek_pointer (param_values + 0);
7154 }
7155 else
7156 {
7157 data1 = g_value_peek_pointer (param_values + 0);
7158 data2 = closure->data;
7159 }
7160 callback = (GMarshalFunc_VOID__POINTER_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
7161
7162 callback (data1,
7163 g_marshal_value_peek_pointer (param_values + 1),
7164 g_marshal_value_peek_boolean (param_values + 2),
7165 data2);
7166 }
7167
7168 void
_gtk_marshal_VOID__POINTER_BOOLEANv(GClosure * closure,GValue * return_value G_GNUC_UNUSED,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)7169 _gtk_marshal_VOID__POINTER_BOOLEANv (GClosure *closure,
7170 GValue *return_value G_GNUC_UNUSED,
7171 gpointer instance,
7172 va_list args,
7173 gpointer marshal_data,
7174 int n_params,
7175 GType *param_types)
7176 {
7177 typedef void (*GMarshalFunc_VOID__POINTER_BOOLEAN) (gpointer data1,
7178 gpointer arg1,
7179 gboolean arg2,
7180 gpointer data2);
7181 GCClosure *cc = (GCClosure *) closure;
7182 gpointer data1, data2;
7183 GMarshalFunc_VOID__POINTER_BOOLEAN callback;
7184 gpointer arg0;
7185 gboolean arg1;
7186 va_list args_copy;
7187
7188 G_VA_COPY (args_copy, args);
7189 arg0 = (gpointer) va_arg (args_copy, gpointer);
7190 arg1 = (gboolean) va_arg (args_copy, gboolean);
7191 va_end (args_copy);
7192
7193
7194 if (G_CCLOSURE_SWAP_DATA (closure))
7195 {
7196 data1 = closure->data;
7197 data2 = instance;
7198 }
7199 else
7200 {
7201 data1 = instance;
7202 data2 = closure->data;
7203 }
7204 callback = (GMarshalFunc_VOID__POINTER_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
7205
7206 callback (data1,
7207 arg0,
7208 arg1,
7209 data2);
7210
7211 }
7212
7213 /* VOID:POINTER,POINTER,BOOLEAN (./gtkmarshalers.list:106) */
7214 void
_gtk_marshal_VOID__POINTER_POINTER_BOOLEAN(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)7215 _gtk_marshal_VOID__POINTER_POINTER_BOOLEAN (GClosure *closure,
7216 GValue *return_value G_GNUC_UNUSED,
7217 guint n_param_values,
7218 const GValue *param_values,
7219 gpointer invocation_hint G_GNUC_UNUSED,
7220 gpointer marshal_data)
7221 {
7222 typedef void (*GMarshalFunc_VOID__POINTER_POINTER_BOOLEAN) (gpointer data1,
7223 gpointer arg1,
7224 gpointer arg2,
7225 gboolean arg3,
7226 gpointer data2);
7227 GCClosure *cc = (GCClosure *) closure;
7228 gpointer data1, data2;
7229 GMarshalFunc_VOID__POINTER_POINTER_BOOLEAN callback;
7230
7231 g_return_if_fail (n_param_values == 4);
7232
7233 if (G_CCLOSURE_SWAP_DATA (closure))
7234 {
7235 data1 = closure->data;
7236 data2 = g_value_peek_pointer (param_values + 0);
7237 }
7238 else
7239 {
7240 data1 = g_value_peek_pointer (param_values + 0);
7241 data2 = closure->data;
7242 }
7243 callback = (GMarshalFunc_VOID__POINTER_POINTER_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
7244
7245 callback (data1,
7246 g_marshal_value_peek_pointer (param_values + 1),
7247 g_marshal_value_peek_pointer (param_values + 2),
7248 g_marshal_value_peek_boolean (param_values + 3),
7249 data2);
7250 }
7251
7252 void
_gtk_marshal_VOID__POINTER_POINTER_BOOLEANv(GClosure * closure,GValue * return_value G_GNUC_UNUSED,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)7253 _gtk_marshal_VOID__POINTER_POINTER_BOOLEANv (GClosure *closure,
7254 GValue *return_value G_GNUC_UNUSED,
7255 gpointer instance,
7256 va_list args,
7257 gpointer marshal_data,
7258 int n_params,
7259 GType *param_types)
7260 {
7261 typedef void (*GMarshalFunc_VOID__POINTER_POINTER_BOOLEAN) (gpointer data1,
7262 gpointer arg1,
7263 gpointer arg2,
7264 gboolean arg3,
7265 gpointer data2);
7266 GCClosure *cc = (GCClosure *) closure;
7267 gpointer data1, data2;
7268 GMarshalFunc_VOID__POINTER_POINTER_BOOLEAN callback;
7269 gpointer arg0;
7270 gpointer arg1;
7271 gboolean arg2;
7272 va_list args_copy;
7273
7274 G_VA_COPY (args_copy, args);
7275 arg0 = (gpointer) va_arg (args_copy, gpointer);
7276 arg1 = (gpointer) va_arg (args_copy, gpointer);
7277 arg2 = (gboolean) va_arg (args_copy, gboolean);
7278 va_end (args_copy);
7279
7280
7281 if (G_CCLOSURE_SWAP_DATA (closure))
7282 {
7283 data1 = closure->data;
7284 data2 = instance;
7285 }
7286 else
7287 {
7288 data1 = instance;
7289 data2 = closure->data;
7290 }
7291 callback = (GMarshalFunc_VOID__POINTER_POINTER_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
7292
7293 callback (data1,
7294 arg0,
7295 arg1,
7296 arg2,
7297 data2);
7298
7299 }
7300
7301 /* VOID:POINTER,POINTER,BOOLEAN,BOOLEAN (./gtkmarshalers.list:107) */
7302 void
_gtk_marshal_VOID__POINTER_POINTER_BOOLEAN_BOOLEAN(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)7303 _gtk_marshal_VOID__POINTER_POINTER_BOOLEAN_BOOLEAN (GClosure *closure,
7304 GValue *return_value G_GNUC_UNUSED,
7305 guint n_param_values,
7306 const GValue *param_values,
7307 gpointer invocation_hint G_GNUC_UNUSED,
7308 gpointer marshal_data)
7309 {
7310 typedef void (*GMarshalFunc_VOID__POINTER_POINTER_BOOLEAN_BOOLEAN) (gpointer data1,
7311 gpointer arg1,
7312 gpointer arg2,
7313 gboolean arg3,
7314 gboolean arg4,
7315 gpointer data2);
7316 GCClosure *cc = (GCClosure *) closure;
7317 gpointer data1, data2;
7318 GMarshalFunc_VOID__POINTER_POINTER_BOOLEAN_BOOLEAN callback;
7319
7320 g_return_if_fail (n_param_values == 5);
7321
7322 if (G_CCLOSURE_SWAP_DATA (closure))
7323 {
7324 data1 = closure->data;
7325 data2 = g_value_peek_pointer (param_values + 0);
7326 }
7327 else
7328 {
7329 data1 = g_value_peek_pointer (param_values + 0);
7330 data2 = closure->data;
7331 }
7332 callback = (GMarshalFunc_VOID__POINTER_POINTER_BOOLEAN_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
7333
7334 callback (data1,
7335 g_marshal_value_peek_pointer (param_values + 1),
7336 g_marshal_value_peek_pointer (param_values + 2),
7337 g_marshal_value_peek_boolean (param_values + 3),
7338 g_marshal_value_peek_boolean (param_values + 4),
7339 data2);
7340 }
7341
7342 void
_gtk_marshal_VOID__POINTER_POINTER_BOOLEAN_BOOLEANv(GClosure * closure,GValue * return_value G_GNUC_UNUSED,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)7343 _gtk_marshal_VOID__POINTER_POINTER_BOOLEAN_BOOLEANv (GClosure *closure,
7344 GValue *return_value G_GNUC_UNUSED,
7345 gpointer instance,
7346 va_list args,
7347 gpointer marshal_data,
7348 int n_params,
7349 GType *param_types)
7350 {
7351 typedef void (*GMarshalFunc_VOID__POINTER_POINTER_BOOLEAN_BOOLEAN) (gpointer data1,
7352 gpointer arg1,
7353 gpointer arg2,
7354 gboolean arg3,
7355 gboolean arg4,
7356 gpointer data2);
7357 GCClosure *cc = (GCClosure *) closure;
7358 gpointer data1, data2;
7359 GMarshalFunc_VOID__POINTER_POINTER_BOOLEAN_BOOLEAN callback;
7360 gpointer arg0;
7361 gpointer arg1;
7362 gboolean arg2;
7363 gboolean arg3;
7364 va_list args_copy;
7365
7366 G_VA_COPY (args_copy, args);
7367 arg0 = (gpointer) va_arg (args_copy, gpointer);
7368 arg1 = (gpointer) va_arg (args_copy, gpointer);
7369 arg2 = (gboolean) va_arg (args_copy, gboolean);
7370 arg3 = (gboolean) va_arg (args_copy, gboolean);
7371 va_end (args_copy);
7372
7373
7374 if (G_CCLOSURE_SWAP_DATA (closure))
7375 {
7376 data1 = closure->data;
7377 data2 = instance;
7378 }
7379 else
7380 {
7381 data1 = instance;
7382 data2 = closure->data;
7383 }
7384 callback = (GMarshalFunc_VOID__POINTER_POINTER_BOOLEAN_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
7385
7386 callback (data1,
7387 arg0,
7388 arg1,
7389 arg2,
7390 arg3,
7391 data2);
7392
7393 }
7394
7395 /* VOID:POINTER,POINTER,POINTER (./gtkmarshalers.list:108) */
7396 void
_gtk_marshal_VOID__POINTER_POINTER_POINTER(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)7397 _gtk_marshal_VOID__POINTER_POINTER_POINTER (GClosure *closure,
7398 GValue *return_value G_GNUC_UNUSED,
7399 guint n_param_values,
7400 const GValue *param_values,
7401 gpointer invocation_hint G_GNUC_UNUSED,
7402 gpointer marshal_data)
7403 {
7404 typedef void (*GMarshalFunc_VOID__POINTER_POINTER_POINTER) (gpointer data1,
7405 gpointer arg1,
7406 gpointer arg2,
7407 gpointer arg3,
7408 gpointer data2);
7409 GCClosure *cc = (GCClosure *) closure;
7410 gpointer data1, data2;
7411 GMarshalFunc_VOID__POINTER_POINTER_POINTER callback;
7412
7413 g_return_if_fail (n_param_values == 4);
7414
7415 if (G_CCLOSURE_SWAP_DATA (closure))
7416 {
7417 data1 = closure->data;
7418 data2 = g_value_peek_pointer (param_values + 0);
7419 }
7420 else
7421 {
7422 data1 = g_value_peek_pointer (param_values + 0);
7423 data2 = closure->data;
7424 }
7425 callback = (GMarshalFunc_VOID__POINTER_POINTER_POINTER) (marshal_data ? marshal_data : cc->callback);
7426
7427 callback (data1,
7428 g_marshal_value_peek_pointer (param_values + 1),
7429 g_marshal_value_peek_pointer (param_values + 2),
7430 g_marshal_value_peek_pointer (param_values + 3),
7431 data2);
7432 }
7433
7434 void
_gtk_marshal_VOID__POINTER_POINTER_POINTERv(GClosure * closure,GValue * return_value G_GNUC_UNUSED,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)7435 _gtk_marshal_VOID__POINTER_POINTER_POINTERv (GClosure *closure,
7436 GValue *return_value G_GNUC_UNUSED,
7437 gpointer instance,
7438 va_list args,
7439 gpointer marshal_data,
7440 int n_params,
7441 GType *param_types)
7442 {
7443 typedef void (*GMarshalFunc_VOID__POINTER_POINTER_POINTER) (gpointer data1,
7444 gpointer arg1,
7445 gpointer arg2,
7446 gpointer arg3,
7447 gpointer data2);
7448 GCClosure *cc = (GCClosure *) closure;
7449 gpointer data1, data2;
7450 GMarshalFunc_VOID__POINTER_POINTER_POINTER callback;
7451 gpointer arg0;
7452 gpointer arg1;
7453 gpointer arg2;
7454 va_list args_copy;
7455
7456 G_VA_COPY (args_copy, args);
7457 arg0 = (gpointer) va_arg (args_copy, gpointer);
7458 arg1 = (gpointer) va_arg (args_copy, gpointer);
7459 arg2 = (gpointer) va_arg (args_copy, gpointer);
7460 va_end (args_copy);
7461
7462
7463 if (G_CCLOSURE_SWAP_DATA (closure))
7464 {
7465 data1 = closure->data;
7466 data2 = instance;
7467 }
7468 else
7469 {
7470 data1 = instance;
7471 data2 = closure->data;
7472 }
7473 callback = (GMarshalFunc_VOID__POINTER_POINTER_POINTER) (marshal_data ? marshal_data : cc->callback);
7474
7475 callback (data1,
7476 arg0,
7477 arg1,
7478 arg2,
7479 data2);
7480
7481 }
7482
7483 /* VOID:POINTER,UINT (./gtkmarshalers.list:109) */
7484 void
_gtk_marshal_VOID__POINTER_UINT(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)7485 _gtk_marshal_VOID__POINTER_UINT (GClosure *closure,
7486 GValue *return_value G_GNUC_UNUSED,
7487 guint n_param_values,
7488 const GValue *param_values,
7489 gpointer invocation_hint G_GNUC_UNUSED,
7490 gpointer marshal_data)
7491 {
7492 typedef void (*GMarshalFunc_VOID__POINTER_UINT) (gpointer data1,
7493 gpointer arg1,
7494 guint arg2,
7495 gpointer data2);
7496 GCClosure *cc = (GCClosure *) closure;
7497 gpointer data1, data2;
7498 GMarshalFunc_VOID__POINTER_UINT callback;
7499
7500 g_return_if_fail (n_param_values == 3);
7501
7502 if (G_CCLOSURE_SWAP_DATA (closure))
7503 {
7504 data1 = closure->data;
7505 data2 = g_value_peek_pointer (param_values + 0);
7506 }
7507 else
7508 {
7509 data1 = g_value_peek_pointer (param_values + 0);
7510 data2 = closure->data;
7511 }
7512 callback = (GMarshalFunc_VOID__POINTER_UINT) (marshal_data ? marshal_data : cc->callback);
7513
7514 callback (data1,
7515 g_marshal_value_peek_pointer (param_values + 1),
7516 g_marshal_value_peek_uint (param_values + 2),
7517 data2);
7518 }
7519
7520 void
_gtk_marshal_VOID__POINTER_UINTv(GClosure * closure,GValue * return_value G_GNUC_UNUSED,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)7521 _gtk_marshal_VOID__POINTER_UINTv (GClosure *closure,
7522 GValue *return_value G_GNUC_UNUSED,
7523 gpointer instance,
7524 va_list args,
7525 gpointer marshal_data,
7526 int n_params,
7527 GType *param_types)
7528 {
7529 typedef void (*GMarshalFunc_VOID__POINTER_UINT) (gpointer data1,
7530 gpointer arg1,
7531 guint arg2,
7532 gpointer data2);
7533 GCClosure *cc = (GCClosure *) closure;
7534 gpointer data1, data2;
7535 GMarshalFunc_VOID__POINTER_UINT callback;
7536 gpointer arg0;
7537 guint arg1;
7538 va_list args_copy;
7539
7540 G_VA_COPY (args_copy, args);
7541 arg0 = (gpointer) va_arg (args_copy, gpointer);
7542 arg1 = (guint) va_arg (args_copy, guint);
7543 va_end (args_copy);
7544
7545
7546 if (G_CCLOSURE_SWAP_DATA (closure))
7547 {
7548 data1 = closure->data;
7549 data2 = instance;
7550 }
7551 else
7552 {
7553 data1 = instance;
7554 data2 = closure->data;
7555 }
7556 callback = (GMarshalFunc_VOID__POINTER_UINT) (marshal_data ? marshal_data : cc->callback);
7557
7558 callback (data1,
7559 arg0,
7560 arg1,
7561 data2);
7562
7563 }
7564
7565 /* VOID:STRING,BOXED (./gtkmarshalers.list:110) */
7566 void
_gtk_marshal_VOID__STRING_BOXED(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)7567 _gtk_marshal_VOID__STRING_BOXED (GClosure *closure,
7568 GValue *return_value G_GNUC_UNUSED,
7569 guint n_param_values,
7570 const GValue *param_values,
7571 gpointer invocation_hint G_GNUC_UNUSED,
7572 gpointer marshal_data)
7573 {
7574 typedef void (*GMarshalFunc_VOID__STRING_BOXED) (gpointer data1,
7575 gpointer arg1,
7576 gpointer arg2,
7577 gpointer data2);
7578 GCClosure *cc = (GCClosure *) closure;
7579 gpointer data1, data2;
7580 GMarshalFunc_VOID__STRING_BOXED callback;
7581
7582 g_return_if_fail (n_param_values == 3);
7583
7584 if (G_CCLOSURE_SWAP_DATA (closure))
7585 {
7586 data1 = closure->data;
7587 data2 = g_value_peek_pointer (param_values + 0);
7588 }
7589 else
7590 {
7591 data1 = g_value_peek_pointer (param_values + 0);
7592 data2 = closure->data;
7593 }
7594 callback = (GMarshalFunc_VOID__STRING_BOXED) (marshal_data ? marshal_data : cc->callback);
7595
7596 callback (data1,
7597 g_marshal_value_peek_string (param_values + 1),
7598 g_marshal_value_peek_boxed (param_values + 2),
7599 data2);
7600 }
7601
7602 void
_gtk_marshal_VOID__STRING_BOXEDv(GClosure * closure,GValue * return_value G_GNUC_UNUSED,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)7603 _gtk_marshal_VOID__STRING_BOXEDv (GClosure *closure,
7604 GValue *return_value G_GNUC_UNUSED,
7605 gpointer instance,
7606 va_list args,
7607 gpointer marshal_data,
7608 int n_params,
7609 GType *param_types)
7610 {
7611 typedef void (*GMarshalFunc_VOID__STRING_BOXED) (gpointer data1,
7612 gpointer arg1,
7613 gpointer arg2,
7614 gpointer data2);
7615 GCClosure *cc = (GCClosure *) closure;
7616 gpointer data1, data2;
7617 GMarshalFunc_VOID__STRING_BOXED callback;
7618 gpointer arg0;
7619 gpointer arg1;
7620 va_list args_copy;
7621
7622 G_VA_COPY (args_copy, args);
7623 arg0 = (gpointer) va_arg (args_copy, gpointer);
7624 if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
7625 arg0 = g_strdup (arg0);
7626 arg1 = (gpointer) va_arg (args_copy, gpointer);
7627 if ((param_types[1] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg1 != NULL)
7628 arg1 = g_boxed_copy (param_types[1] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg1);
7629 va_end (args_copy);
7630
7631
7632 if (G_CCLOSURE_SWAP_DATA (closure))
7633 {
7634 data1 = closure->data;
7635 data2 = instance;
7636 }
7637 else
7638 {
7639 data1 = instance;
7640 data2 = closure->data;
7641 }
7642 callback = (GMarshalFunc_VOID__STRING_BOXED) (marshal_data ? marshal_data : cc->callback);
7643
7644 callback (data1,
7645 arg0,
7646 arg1,
7647 data2);
7648 if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
7649 g_free (arg0);
7650 if ((param_types[1] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg1 != NULL)
7651 g_boxed_free (param_types[1] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg1);
7652 }
7653
7654 /* VOID:STRING,STRING (./gtkmarshalers.list:111) */
7655 void
_gtk_marshal_VOID__STRING_STRING(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)7656 _gtk_marshal_VOID__STRING_STRING (GClosure *closure,
7657 GValue *return_value G_GNUC_UNUSED,
7658 guint n_param_values,
7659 const GValue *param_values,
7660 gpointer invocation_hint G_GNUC_UNUSED,
7661 gpointer marshal_data)
7662 {
7663 typedef void (*GMarshalFunc_VOID__STRING_STRING) (gpointer data1,
7664 gpointer arg1,
7665 gpointer arg2,
7666 gpointer data2);
7667 GCClosure *cc = (GCClosure *) closure;
7668 gpointer data1, data2;
7669 GMarshalFunc_VOID__STRING_STRING callback;
7670
7671 g_return_if_fail (n_param_values == 3);
7672
7673 if (G_CCLOSURE_SWAP_DATA (closure))
7674 {
7675 data1 = closure->data;
7676 data2 = g_value_peek_pointer (param_values + 0);
7677 }
7678 else
7679 {
7680 data1 = g_value_peek_pointer (param_values + 0);
7681 data2 = closure->data;
7682 }
7683 callback = (GMarshalFunc_VOID__STRING_STRING) (marshal_data ? marshal_data : cc->callback);
7684
7685 callback (data1,
7686 g_marshal_value_peek_string (param_values + 1),
7687 g_marshal_value_peek_string (param_values + 2),
7688 data2);
7689 }
7690
7691 void
_gtk_marshal_VOID__STRING_STRINGv(GClosure * closure,GValue * return_value G_GNUC_UNUSED,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)7692 _gtk_marshal_VOID__STRING_STRINGv (GClosure *closure,
7693 GValue *return_value G_GNUC_UNUSED,
7694 gpointer instance,
7695 va_list args,
7696 gpointer marshal_data,
7697 int n_params,
7698 GType *param_types)
7699 {
7700 typedef void (*GMarshalFunc_VOID__STRING_STRING) (gpointer data1,
7701 gpointer arg1,
7702 gpointer arg2,
7703 gpointer data2);
7704 GCClosure *cc = (GCClosure *) closure;
7705 gpointer data1, data2;
7706 GMarshalFunc_VOID__STRING_STRING callback;
7707 gpointer arg0;
7708 gpointer arg1;
7709 va_list args_copy;
7710
7711 G_VA_COPY (args_copy, args);
7712 arg0 = (gpointer) va_arg (args_copy, gpointer);
7713 if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
7714 arg0 = g_strdup (arg0);
7715 arg1 = (gpointer) va_arg (args_copy, gpointer);
7716 if ((param_types[1] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg1 != NULL)
7717 arg1 = g_strdup (arg1);
7718 va_end (args_copy);
7719
7720
7721 if (G_CCLOSURE_SWAP_DATA (closure))
7722 {
7723 data1 = closure->data;
7724 data2 = instance;
7725 }
7726 else
7727 {
7728 data1 = instance;
7729 data2 = closure->data;
7730 }
7731 callback = (GMarshalFunc_VOID__STRING_STRING) (marshal_data ? marshal_data : cc->callback);
7732
7733 callback (data1,
7734 arg0,
7735 arg1,
7736 data2);
7737 if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
7738 g_free (arg0);
7739 if ((param_types[1] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg1 != NULL)
7740 g_free (arg1);
7741 }
7742
7743 /* VOID:STRING,STRING,STRING (./gtkmarshalers.list:112) */
7744 void
_gtk_marshal_VOID__STRING_STRING_STRING(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)7745 _gtk_marshal_VOID__STRING_STRING_STRING (GClosure *closure,
7746 GValue *return_value G_GNUC_UNUSED,
7747 guint n_param_values,
7748 const GValue *param_values,
7749 gpointer invocation_hint G_GNUC_UNUSED,
7750 gpointer marshal_data)
7751 {
7752 typedef void (*GMarshalFunc_VOID__STRING_STRING_STRING) (gpointer data1,
7753 gpointer arg1,
7754 gpointer arg2,
7755 gpointer arg3,
7756 gpointer data2);
7757 GCClosure *cc = (GCClosure *) closure;
7758 gpointer data1, data2;
7759 GMarshalFunc_VOID__STRING_STRING_STRING callback;
7760
7761 g_return_if_fail (n_param_values == 4);
7762
7763 if (G_CCLOSURE_SWAP_DATA (closure))
7764 {
7765 data1 = closure->data;
7766 data2 = g_value_peek_pointer (param_values + 0);
7767 }
7768 else
7769 {
7770 data1 = g_value_peek_pointer (param_values + 0);
7771 data2 = closure->data;
7772 }
7773 callback = (GMarshalFunc_VOID__STRING_STRING_STRING) (marshal_data ? marshal_data : cc->callback);
7774
7775 callback (data1,
7776 g_marshal_value_peek_string (param_values + 1),
7777 g_marshal_value_peek_string (param_values + 2),
7778 g_marshal_value_peek_string (param_values + 3),
7779 data2);
7780 }
7781
7782 void
_gtk_marshal_VOID__STRING_STRING_STRINGv(GClosure * closure,GValue * return_value G_GNUC_UNUSED,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)7783 _gtk_marshal_VOID__STRING_STRING_STRINGv (GClosure *closure,
7784 GValue *return_value G_GNUC_UNUSED,
7785 gpointer instance,
7786 va_list args,
7787 gpointer marshal_data,
7788 int n_params,
7789 GType *param_types)
7790 {
7791 typedef void (*GMarshalFunc_VOID__STRING_STRING_STRING) (gpointer data1,
7792 gpointer arg1,
7793 gpointer arg2,
7794 gpointer arg3,
7795 gpointer data2);
7796 GCClosure *cc = (GCClosure *) closure;
7797 gpointer data1, data2;
7798 GMarshalFunc_VOID__STRING_STRING_STRING callback;
7799 gpointer arg0;
7800 gpointer arg1;
7801 gpointer arg2;
7802 va_list args_copy;
7803
7804 G_VA_COPY (args_copy, args);
7805 arg0 = (gpointer) va_arg (args_copy, gpointer);
7806 if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
7807 arg0 = g_strdup (arg0);
7808 arg1 = (gpointer) va_arg (args_copy, gpointer);
7809 if ((param_types[1] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg1 != NULL)
7810 arg1 = g_strdup (arg1);
7811 arg2 = (gpointer) va_arg (args_copy, gpointer);
7812 if ((param_types[2] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg2 != NULL)
7813 arg2 = g_strdup (arg2);
7814 va_end (args_copy);
7815
7816
7817 if (G_CCLOSURE_SWAP_DATA (closure))
7818 {
7819 data1 = closure->data;
7820 data2 = instance;
7821 }
7822 else
7823 {
7824 data1 = instance;
7825 data2 = closure->data;
7826 }
7827 callback = (GMarshalFunc_VOID__STRING_STRING_STRING) (marshal_data ? marshal_data : cc->callback);
7828
7829 callback (data1,
7830 arg0,
7831 arg1,
7832 arg2,
7833 data2);
7834 if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
7835 g_free (arg0);
7836 if ((param_types[1] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg1 != NULL)
7837 g_free (arg1);
7838 if ((param_types[2] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg2 != NULL)
7839 g_free (arg2);
7840 }
7841
7842 /* VOID:STRING,INT,POINTER (./gtkmarshalers.list:113) */
7843 void
_gtk_marshal_VOID__STRING_INT_POINTER(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)7844 _gtk_marshal_VOID__STRING_INT_POINTER (GClosure *closure,
7845 GValue *return_value G_GNUC_UNUSED,
7846 guint n_param_values,
7847 const GValue *param_values,
7848 gpointer invocation_hint G_GNUC_UNUSED,
7849 gpointer marshal_data)
7850 {
7851 typedef void (*GMarshalFunc_VOID__STRING_INT_POINTER) (gpointer data1,
7852 gpointer arg1,
7853 gint arg2,
7854 gpointer arg3,
7855 gpointer data2);
7856 GCClosure *cc = (GCClosure *) closure;
7857 gpointer data1, data2;
7858 GMarshalFunc_VOID__STRING_INT_POINTER callback;
7859
7860 g_return_if_fail (n_param_values == 4);
7861
7862 if (G_CCLOSURE_SWAP_DATA (closure))
7863 {
7864 data1 = closure->data;
7865 data2 = g_value_peek_pointer (param_values + 0);
7866 }
7867 else
7868 {
7869 data1 = g_value_peek_pointer (param_values + 0);
7870 data2 = closure->data;
7871 }
7872 callback = (GMarshalFunc_VOID__STRING_INT_POINTER) (marshal_data ? marshal_data : cc->callback);
7873
7874 callback (data1,
7875 g_marshal_value_peek_string (param_values + 1),
7876 g_marshal_value_peek_int (param_values + 2),
7877 g_marshal_value_peek_pointer (param_values + 3),
7878 data2);
7879 }
7880
7881 void
_gtk_marshal_VOID__STRING_INT_POINTERv(GClosure * closure,GValue * return_value G_GNUC_UNUSED,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)7882 _gtk_marshal_VOID__STRING_INT_POINTERv (GClosure *closure,
7883 GValue *return_value G_GNUC_UNUSED,
7884 gpointer instance,
7885 va_list args,
7886 gpointer marshal_data,
7887 int n_params,
7888 GType *param_types)
7889 {
7890 typedef void (*GMarshalFunc_VOID__STRING_INT_POINTER) (gpointer data1,
7891 gpointer arg1,
7892 gint arg2,
7893 gpointer arg3,
7894 gpointer data2);
7895 GCClosure *cc = (GCClosure *) closure;
7896 gpointer data1, data2;
7897 GMarshalFunc_VOID__STRING_INT_POINTER callback;
7898 gpointer arg0;
7899 gint arg1;
7900 gpointer arg2;
7901 va_list args_copy;
7902
7903 G_VA_COPY (args_copy, args);
7904 arg0 = (gpointer) va_arg (args_copy, gpointer);
7905 if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
7906 arg0 = g_strdup (arg0);
7907 arg1 = (gint) va_arg (args_copy, gint);
7908 arg2 = (gpointer) va_arg (args_copy, gpointer);
7909 va_end (args_copy);
7910
7911
7912 if (G_CCLOSURE_SWAP_DATA (closure))
7913 {
7914 data1 = closure->data;
7915 data2 = instance;
7916 }
7917 else
7918 {
7919 data1 = instance;
7920 data2 = closure->data;
7921 }
7922 callback = (GMarshalFunc_VOID__STRING_INT_POINTER) (marshal_data ? marshal_data : cc->callback);
7923
7924 callback (data1,
7925 arg0,
7926 arg1,
7927 arg2,
7928 data2);
7929 if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
7930 g_free (arg0);
7931 }
7932
7933 /* VOID:STRING,UINT,FLAGS (./gtkmarshalers.list:114) */
7934 void
_gtk_marshal_VOID__STRING_UINT_FLAGS(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)7935 _gtk_marshal_VOID__STRING_UINT_FLAGS (GClosure *closure,
7936 GValue *return_value G_GNUC_UNUSED,
7937 guint n_param_values,
7938 const GValue *param_values,
7939 gpointer invocation_hint G_GNUC_UNUSED,
7940 gpointer marshal_data)
7941 {
7942 typedef void (*GMarshalFunc_VOID__STRING_UINT_FLAGS) (gpointer data1,
7943 gpointer arg1,
7944 guint arg2,
7945 guint arg3,
7946 gpointer data2);
7947 GCClosure *cc = (GCClosure *) closure;
7948 gpointer data1, data2;
7949 GMarshalFunc_VOID__STRING_UINT_FLAGS callback;
7950
7951 g_return_if_fail (n_param_values == 4);
7952
7953 if (G_CCLOSURE_SWAP_DATA (closure))
7954 {
7955 data1 = closure->data;
7956 data2 = g_value_peek_pointer (param_values + 0);
7957 }
7958 else
7959 {
7960 data1 = g_value_peek_pointer (param_values + 0);
7961 data2 = closure->data;
7962 }
7963 callback = (GMarshalFunc_VOID__STRING_UINT_FLAGS) (marshal_data ? marshal_data : cc->callback);
7964
7965 callback (data1,
7966 g_marshal_value_peek_string (param_values + 1),
7967 g_marshal_value_peek_uint (param_values + 2),
7968 g_marshal_value_peek_flags (param_values + 3),
7969 data2);
7970 }
7971
7972 void
_gtk_marshal_VOID__STRING_UINT_FLAGSv(GClosure * closure,GValue * return_value G_GNUC_UNUSED,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)7973 _gtk_marshal_VOID__STRING_UINT_FLAGSv (GClosure *closure,
7974 GValue *return_value G_GNUC_UNUSED,
7975 gpointer instance,
7976 va_list args,
7977 gpointer marshal_data,
7978 int n_params,
7979 GType *param_types)
7980 {
7981 typedef void (*GMarshalFunc_VOID__STRING_UINT_FLAGS) (gpointer data1,
7982 gpointer arg1,
7983 guint arg2,
7984 guint arg3,
7985 gpointer data2);
7986 GCClosure *cc = (GCClosure *) closure;
7987 gpointer data1, data2;
7988 GMarshalFunc_VOID__STRING_UINT_FLAGS callback;
7989 gpointer arg0;
7990 guint arg1;
7991 guint arg2;
7992 va_list args_copy;
7993
7994 G_VA_COPY (args_copy, args);
7995 arg0 = (gpointer) va_arg (args_copy, gpointer);
7996 if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
7997 arg0 = g_strdup (arg0);
7998 arg1 = (guint) va_arg (args_copy, guint);
7999 arg2 = (guint) va_arg (args_copy, guint);
8000 va_end (args_copy);
8001
8002
8003 if (G_CCLOSURE_SWAP_DATA (closure))
8004 {
8005 data1 = closure->data;
8006 data2 = instance;
8007 }
8008 else
8009 {
8010 data1 = instance;
8011 data2 = closure->data;
8012 }
8013 callback = (GMarshalFunc_VOID__STRING_UINT_FLAGS) (marshal_data ? marshal_data : cc->callback);
8014
8015 callback (data1,
8016 arg0,
8017 arg1,
8018 arg2,
8019 data2);
8020 if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
8021 g_free (arg0);
8022 }
8023
8024 /* VOID:STRING,UINT,FLAGS,UINT (./gtkmarshalers.list:115) */
8025 void
_gtk_marshal_VOID__STRING_UINT_FLAGS_UINT(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)8026 _gtk_marshal_VOID__STRING_UINT_FLAGS_UINT (GClosure *closure,
8027 GValue *return_value G_GNUC_UNUSED,
8028 guint n_param_values,
8029 const GValue *param_values,
8030 gpointer invocation_hint G_GNUC_UNUSED,
8031 gpointer marshal_data)
8032 {
8033 typedef void (*GMarshalFunc_VOID__STRING_UINT_FLAGS_UINT) (gpointer data1,
8034 gpointer arg1,
8035 guint arg2,
8036 guint arg3,
8037 guint arg4,
8038 gpointer data2);
8039 GCClosure *cc = (GCClosure *) closure;
8040 gpointer data1, data2;
8041 GMarshalFunc_VOID__STRING_UINT_FLAGS_UINT callback;
8042
8043 g_return_if_fail (n_param_values == 5);
8044
8045 if (G_CCLOSURE_SWAP_DATA (closure))
8046 {
8047 data1 = closure->data;
8048 data2 = g_value_peek_pointer (param_values + 0);
8049 }
8050 else
8051 {
8052 data1 = g_value_peek_pointer (param_values + 0);
8053 data2 = closure->data;
8054 }
8055 callback = (GMarshalFunc_VOID__STRING_UINT_FLAGS_UINT) (marshal_data ? marshal_data : cc->callback);
8056
8057 callback (data1,
8058 g_marshal_value_peek_string (param_values + 1),
8059 g_marshal_value_peek_uint (param_values + 2),
8060 g_marshal_value_peek_flags (param_values + 3),
8061 g_marshal_value_peek_uint (param_values + 4),
8062 data2);
8063 }
8064
8065 void
_gtk_marshal_VOID__STRING_UINT_FLAGS_UINTv(GClosure * closure,GValue * return_value G_GNUC_UNUSED,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)8066 _gtk_marshal_VOID__STRING_UINT_FLAGS_UINTv (GClosure *closure,
8067 GValue *return_value G_GNUC_UNUSED,
8068 gpointer instance,
8069 va_list args,
8070 gpointer marshal_data,
8071 int n_params,
8072 GType *param_types)
8073 {
8074 typedef void (*GMarshalFunc_VOID__STRING_UINT_FLAGS_UINT) (gpointer data1,
8075 gpointer arg1,
8076 guint arg2,
8077 guint arg3,
8078 guint arg4,
8079 gpointer data2);
8080 GCClosure *cc = (GCClosure *) closure;
8081 gpointer data1, data2;
8082 GMarshalFunc_VOID__STRING_UINT_FLAGS_UINT callback;
8083 gpointer arg0;
8084 guint arg1;
8085 guint arg2;
8086 guint arg3;
8087 va_list args_copy;
8088
8089 G_VA_COPY (args_copy, args);
8090 arg0 = (gpointer) va_arg (args_copy, gpointer);
8091 if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
8092 arg0 = g_strdup (arg0);
8093 arg1 = (guint) va_arg (args_copy, guint);
8094 arg2 = (guint) va_arg (args_copy, guint);
8095 arg3 = (guint) va_arg (args_copy, guint);
8096 va_end (args_copy);
8097
8098
8099 if (G_CCLOSURE_SWAP_DATA (closure))
8100 {
8101 data1 = closure->data;
8102 data2 = instance;
8103 }
8104 else
8105 {
8106 data1 = instance;
8107 data2 = closure->data;
8108 }
8109 callback = (GMarshalFunc_VOID__STRING_UINT_FLAGS_UINT) (marshal_data ? marshal_data : cc->callback);
8110
8111 callback (data1,
8112 arg0,
8113 arg1,
8114 arg2,
8115 arg3,
8116 data2);
8117 if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
8118 g_free (arg0);
8119 }
8120
8121 /* VOID:UINT,FLAGS,BOXED (./gtkmarshalers.list:116) */
8122 void
_gtk_marshal_VOID__UINT_FLAGS_BOXED(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)8123 _gtk_marshal_VOID__UINT_FLAGS_BOXED (GClosure *closure,
8124 GValue *return_value G_GNUC_UNUSED,
8125 guint n_param_values,
8126 const GValue *param_values,
8127 gpointer invocation_hint G_GNUC_UNUSED,
8128 gpointer marshal_data)
8129 {
8130 typedef void (*GMarshalFunc_VOID__UINT_FLAGS_BOXED) (gpointer data1,
8131 guint arg1,
8132 guint arg2,
8133 gpointer arg3,
8134 gpointer data2);
8135 GCClosure *cc = (GCClosure *) closure;
8136 gpointer data1, data2;
8137 GMarshalFunc_VOID__UINT_FLAGS_BOXED callback;
8138
8139 g_return_if_fail (n_param_values == 4);
8140
8141 if (G_CCLOSURE_SWAP_DATA (closure))
8142 {
8143 data1 = closure->data;
8144 data2 = g_value_peek_pointer (param_values + 0);
8145 }
8146 else
8147 {
8148 data1 = g_value_peek_pointer (param_values + 0);
8149 data2 = closure->data;
8150 }
8151 callback = (GMarshalFunc_VOID__UINT_FLAGS_BOXED) (marshal_data ? marshal_data : cc->callback);
8152
8153 callback (data1,
8154 g_marshal_value_peek_uint (param_values + 1),
8155 g_marshal_value_peek_flags (param_values + 2),
8156 g_marshal_value_peek_boxed (param_values + 3),
8157 data2);
8158 }
8159
8160 void
_gtk_marshal_VOID__UINT_FLAGS_BOXEDv(GClosure * closure,GValue * return_value G_GNUC_UNUSED,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)8161 _gtk_marshal_VOID__UINT_FLAGS_BOXEDv (GClosure *closure,
8162 GValue *return_value G_GNUC_UNUSED,
8163 gpointer instance,
8164 va_list args,
8165 gpointer marshal_data,
8166 int n_params,
8167 GType *param_types)
8168 {
8169 typedef void (*GMarshalFunc_VOID__UINT_FLAGS_BOXED) (gpointer data1,
8170 guint arg1,
8171 guint arg2,
8172 gpointer arg3,
8173 gpointer data2);
8174 GCClosure *cc = (GCClosure *) closure;
8175 gpointer data1, data2;
8176 GMarshalFunc_VOID__UINT_FLAGS_BOXED callback;
8177 guint arg0;
8178 guint arg1;
8179 gpointer arg2;
8180 va_list args_copy;
8181
8182 G_VA_COPY (args_copy, args);
8183 arg0 = (guint) va_arg (args_copy, guint);
8184 arg1 = (guint) va_arg (args_copy, guint);
8185 arg2 = (gpointer) va_arg (args_copy, gpointer);
8186 if ((param_types[2] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg2 != NULL)
8187 arg2 = g_boxed_copy (param_types[2] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg2);
8188 va_end (args_copy);
8189
8190
8191 if (G_CCLOSURE_SWAP_DATA (closure))
8192 {
8193 data1 = closure->data;
8194 data2 = instance;
8195 }
8196 else
8197 {
8198 data1 = instance;
8199 data2 = closure->data;
8200 }
8201 callback = (GMarshalFunc_VOID__UINT_FLAGS_BOXED) (marshal_data ? marshal_data : cc->callback);
8202
8203 callback (data1,
8204 arg0,
8205 arg1,
8206 arg2,
8207 data2);
8208 if ((param_types[2] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg2 != NULL)
8209 g_boxed_free (param_types[2] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg2);
8210 }
8211
8212 /* VOID:UINT,UINT (./gtkmarshalers.list:117) */
8213 void
_gtk_marshal_VOID__UINT_UINT(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)8214 _gtk_marshal_VOID__UINT_UINT (GClosure *closure,
8215 GValue *return_value G_GNUC_UNUSED,
8216 guint n_param_values,
8217 const GValue *param_values,
8218 gpointer invocation_hint G_GNUC_UNUSED,
8219 gpointer marshal_data)
8220 {
8221 typedef void (*GMarshalFunc_VOID__UINT_UINT) (gpointer data1,
8222 guint arg1,
8223 guint arg2,
8224 gpointer data2);
8225 GCClosure *cc = (GCClosure *) closure;
8226 gpointer data1, data2;
8227 GMarshalFunc_VOID__UINT_UINT callback;
8228
8229 g_return_if_fail (n_param_values == 3);
8230
8231 if (G_CCLOSURE_SWAP_DATA (closure))
8232 {
8233 data1 = closure->data;
8234 data2 = g_value_peek_pointer (param_values + 0);
8235 }
8236 else
8237 {
8238 data1 = g_value_peek_pointer (param_values + 0);
8239 data2 = closure->data;
8240 }
8241 callback = (GMarshalFunc_VOID__UINT_UINT) (marshal_data ? marshal_data : cc->callback);
8242
8243 callback (data1,
8244 g_marshal_value_peek_uint (param_values + 1),
8245 g_marshal_value_peek_uint (param_values + 2),
8246 data2);
8247 }
8248
8249 void
_gtk_marshal_VOID__UINT_UINTv(GClosure * closure,GValue * return_value G_GNUC_UNUSED,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)8250 _gtk_marshal_VOID__UINT_UINTv (GClosure *closure,
8251 GValue *return_value G_GNUC_UNUSED,
8252 gpointer instance,
8253 va_list args,
8254 gpointer marshal_data,
8255 int n_params,
8256 GType *param_types)
8257 {
8258 typedef void (*GMarshalFunc_VOID__UINT_UINT) (gpointer data1,
8259 guint arg1,
8260 guint arg2,
8261 gpointer data2);
8262 GCClosure *cc = (GCClosure *) closure;
8263 gpointer data1, data2;
8264 GMarshalFunc_VOID__UINT_UINT callback;
8265 guint arg0;
8266 guint arg1;
8267 va_list args_copy;
8268
8269 G_VA_COPY (args_copy, args);
8270 arg0 = (guint) va_arg (args_copy, guint);
8271 arg1 = (guint) va_arg (args_copy, guint);
8272 va_end (args_copy);
8273
8274
8275 if (G_CCLOSURE_SWAP_DATA (closure))
8276 {
8277 data1 = closure->data;
8278 data2 = instance;
8279 }
8280 else
8281 {
8282 data1 = instance;
8283 data2 = closure->data;
8284 }
8285 callback = (GMarshalFunc_VOID__UINT_UINT) (marshal_data ? marshal_data : cc->callback);
8286
8287 callback (data1,
8288 arg0,
8289 arg1,
8290 data2);
8291
8292 }
8293
8294 /* VOID:UINT,UINT,FLAGS (./gtkmarshalers.list:118) */
8295 void
_gtk_marshal_VOID__UINT_UINT_FLAGS(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)8296 _gtk_marshal_VOID__UINT_UINT_FLAGS (GClosure *closure,
8297 GValue *return_value G_GNUC_UNUSED,
8298 guint n_param_values,
8299 const GValue *param_values,
8300 gpointer invocation_hint G_GNUC_UNUSED,
8301 gpointer marshal_data)
8302 {
8303 typedef void (*GMarshalFunc_VOID__UINT_UINT_FLAGS) (gpointer data1,
8304 guint arg1,
8305 guint arg2,
8306 guint arg3,
8307 gpointer data2);
8308 GCClosure *cc = (GCClosure *) closure;
8309 gpointer data1, data2;
8310 GMarshalFunc_VOID__UINT_UINT_FLAGS callback;
8311
8312 g_return_if_fail (n_param_values == 4);
8313
8314 if (G_CCLOSURE_SWAP_DATA (closure))
8315 {
8316 data1 = closure->data;
8317 data2 = g_value_peek_pointer (param_values + 0);
8318 }
8319 else
8320 {
8321 data1 = g_value_peek_pointer (param_values + 0);
8322 data2 = closure->data;
8323 }
8324 callback = (GMarshalFunc_VOID__UINT_UINT_FLAGS) (marshal_data ? marshal_data : cc->callback);
8325
8326 callback (data1,
8327 g_marshal_value_peek_uint (param_values + 1),
8328 g_marshal_value_peek_uint (param_values + 2),
8329 g_marshal_value_peek_flags (param_values + 3),
8330 data2);
8331 }
8332
8333 void
_gtk_marshal_VOID__UINT_UINT_FLAGSv(GClosure * closure,GValue * return_value G_GNUC_UNUSED,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)8334 _gtk_marshal_VOID__UINT_UINT_FLAGSv (GClosure *closure,
8335 GValue *return_value G_GNUC_UNUSED,
8336 gpointer instance,
8337 va_list args,
8338 gpointer marshal_data,
8339 int n_params,
8340 GType *param_types)
8341 {
8342 typedef void (*GMarshalFunc_VOID__UINT_UINT_FLAGS) (gpointer data1,
8343 guint arg1,
8344 guint arg2,
8345 guint arg3,
8346 gpointer data2);
8347 GCClosure *cc = (GCClosure *) closure;
8348 gpointer data1, data2;
8349 GMarshalFunc_VOID__UINT_UINT_FLAGS callback;
8350 guint arg0;
8351 guint arg1;
8352 guint arg2;
8353 va_list args_copy;
8354
8355 G_VA_COPY (args_copy, args);
8356 arg0 = (guint) va_arg (args_copy, guint);
8357 arg1 = (guint) va_arg (args_copy, guint);
8358 arg2 = (guint) va_arg (args_copy, guint);
8359 va_end (args_copy);
8360
8361
8362 if (G_CCLOSURE_SWAP_DATA (closure))
8363 {
8364 data1 = closure->data;
8365 data2 = instance;
8366 }
8367 else
8368 {
8369 data1 = instance;
8370 data2 = closure->data;
8371 }
8372 callback = (GMarshalFunc_VOID__UINT_UINT_FLAGS) (marshal_data ? marshal_data : cc->callback);
8373
8374 callback (data1,
8375 arg0,
8376 arg1,
8377 arg2,
8378 data2);
8379
8380 }
8381
8382 /* VOID:UINT,STRING (./gtkmarshalers.list:119) */
8383 void
_gtk_marshal_VOID__UINT_STRING(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)8384 _gtk_marshal_VOID__UINT_STRING (GClosure *closure,
8385 GValue *return_value G_GNUC_UNUSED,
8386 guint n_param_values,
8387 const GValue *param_values,
8388 gpointer invocation_hint G_GNUC_UNUSED,
8389 gpointer marshal_data)
8390 {
8391 typedef void (*GMarshalFunc_VOID__UINT_STRING) (gpointer data1,
8392 guint arg1,
8393 gpointer arg2,
8394 gpointer data2);
8395 GCClosure *cc = (GCClosure *) closure;
8396 gpointer data1, data2;
8397 GMarshalFunc_VOID__UINT_STRING callback;
8398
8399 g_return_if_fail (n_param_values == 3);
8400
8401 if (G_CCLOSURE_SWAP_DATA (closure))
8402 {
8403 data1 = closure->data;
8404 data2 = g_value_peek_pointer (param_values + 0);
8405 }
8406 else
8407 {
8408 data1 = g_value_peek_pointer (param_values + 0);
8409 data2 = closure->data;
8410 }
8411 callback = (GMarshalFunc_VOID__UINT_STRING) (marshal_data ? marshal_data : cc->callback);
8412
8413 callback (data1,
8414 g_marshal_value_peek_uint (param_values + 1),
8415 g_marshal_value_peek_string (param_values + 2),
8416 data2);
8417 }
8418
8419 void
_gtk_marshal_VOID__UINT_STRINGv(GClosure * closure,GValue * return_value G_GNUC_UNUSED,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)8420 _gtk_marshal_VOID__UINT_STRINGv (GClosure *closure,
8421 GValue *return_value G_GNUC_UNUSED,
8422 gpointer instance,
8423 va_list args,
8424 gpointer marshal_data,
8425 int n_params,
8426 GType *param_types)
8427 {
8428 typedef void (*GMarshalFunc_VOID__UINT_STRING) (gpointer data1,
8429 guint arg1,
8430 gpointer arg2,
8431 gpointer data2);
8432 GCClosure *cc = (GCClosure *) closure;
8433 gpointer data1, data2;
8434 GMarshalFunc_VOID__UINT_STRING callback;
8435 guint arg0;
8436 gpointer arg1;
8437 va_list args_copy;
8438
8439 G_VA_COPY (args_copy, args);
8440 arg0 = (guint) va_arg (args_copy, guint);
8441 arg1 = (gpointer) va_arg (args_copy, gpointer);
8442 if ((param_types[1] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg1 != NULL)
8443 arg1 = g_strdup (arg1);
8444 va_end (args_copy);
8445
8446
8447 if (G_CCLOSURE_SWAP_DATA (closure))
8448 {
8449 data1 = closure->data;
8450 data2 = instance;
8451 }
8452 else
8453 {
8454 data1 = instance;
8455 data2 = closure->data;
8456 }
8457 callback = (GMarshalFunc_VOID__UINT_STRING) (marshal_data ? marshal_data : cc->callback);
8458
8459 callback (data1,
8460 arg0,
8461 arg1,
8462 data2);
8463 if ((param_types[1] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg1 != NULL)
8464 g_free (arg1);
8465 }
8466
8467 /* VOID:UINT,BOXED,UINT,FLAGS,FLAGS (./gtkmarshalers.list:120) */
8468 void
_gtk_marshal_VOID__UINT_BOXED_UINT_FLAGS_FLAGS(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)8469 _gtk_marshal_VOID__UINT_BOXED_UINT_FLAGS_FLAGS (GClosure *closure,
8470 GValue *return_value G_GNUC_UNUSED,
8471 guint n_param_values,
8472 const GValue *param_values,
8473 gpointer invocation_hint G_GNUC_UNUSED,
8474 gpointer marshal_data)
8475 {
8476 typedef void (*GMarshalFunc_VOID__UINT_BOXED_UINT_FLAGS_FLAGS) (gpointer data1,
8477 guint arg1,
8478 gpointer arg2,
8479 guint arg3,
8480 guint arg4,
8481 guint arg5,
8482 gpointer data2);
8483 GCClosure *cc = (GCClosure *) closure;
8484 gpointer data1, data2;
8485 GMarshalFunc_VOID__UINT_BOXED_UINT_FLAGS_FLAGS callback;
8486
8487 g_return_if_fail (n_param_values == 6);
8488
8489 if (G_CCLOSURE_SWAP_DATA (closure))
8490 {
8491 data1 = closure->data;
8492 data2 = g_value_peek_pointer (param_values + 0);
8493 }
8494 else
8495 {
8496 data1 = g_value_peek_pointer (param_values + 0);
8497 data2 = closure->data;
8498 }
8499 callback = (GMarshalFunc_VOID__UINT_BOXED_UINT_FLAGS_FLAGS) (marshal_data ? marshal_data : cc->callback);
8500
8501 callback (data1,
8502 g_marshal_value_peek_uint (param_values + 1),
8503 g_marshal_value_peek_boxed (param_values + 2),
8504 g_marshal_value_peek_uint (param_values + 3),
8505 g_marshal_value_peek_flags (param_values + 4),
8506 g_marshal_value_peek_flags (param_values + 5),
8507 data2);
8508 }
8509
8510 void
_gtk_marshal_VOID__UINT_BOXED_UINT_FLAGS_FLAGSv(GClosure * closure,GValue * return_value G_GNUC_UNUSED,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)8511 _gtk_marshal_VOID__UINT_BOXED_UINT_FLAGS_FLAGSv (GClosure *closure,
8512 GValue *return_value G_GNUC_UNUSED,
8513 gpointer instance,
8514 va_list args,
8515 gpointer marshal_data,
8516 int n_params,
8517 GType *param_types)
8518 {
8519 typedef void (*GMarshalFunc_VOID__UINT_BOXED_UINT_FLAGS_FLAGS) (gpointer data1,
8520 guint arg1,
8521 gpointer arg2,
8522 guint arg3,
8523 guint arg4,
8524 guint arg5,
8525 gpointer data2);
8526 GCClosure *cc = (GCClosure *) closure;
8527 gpointer data1, data2;
8528 GMarshalFunc_VOID__UINT_BOXED_UINT_FLAGS_FLAGS callback;
8529 guint arg0;
8530 gpointer arg1;
8531 guint arg2;
8532 guint arg3;
8533 guint arg4;
8534 va_list args_copy;
8535
8536 G_VA_COPY (args_copy, args);
8537 arg0 = (guint) va_arg (args_copy, guint);
8538 arg1 = (gpointer) va_arg (args_copy, gpointer);
8539 if ((param_types[1] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg1 != NULL)
8540 arg1 = g_boxed_copy (param_types[1] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg1);
8541 arg2 = (guint) va_arg (args_copy, guint);
8542 arg3 = (guint) va_arg (args_copy, guint);
8543 arg4 = (guint) va_arg (args_copy, guint);
8544 va_end (args_copy);
8545
8546
8547 if (G_CCLOSURE_SWAP_DATA (closure))
8548 {
8549 data1 = closure->data;
8550 data2 = instance;
8551 }
8552 else
8553 {
8554 data1 = instance;
8555 data2 = closure->data;
8556 }
8557 callback = (GMarshalFunc_VOID__UINT_BOXED_UINT_FLAGS_FLAGS) (marshal_data ? marshal_data : cc->callback);
8558
8559 callback (data1,
8560 arg0,
8561 arg1,
8562 arg2,
8563 arg3,
8564 arg4,
8565 data2);
8566 if ((param_types[1] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg1 != NULL)
8567 g_boxed_free (param_types[1] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg1);
8568 }
8569
8570 /* VOID:UINT,OBJECT,UINT,FLAGS,FLAGS (./gtkmarshalers.list:121) */
8571 void
_gtk_marshal_VOID__UINT_OBJECT_UINT_FLAGS_FLAGS(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)8572 _gtk_marshal_VOID__UINT_OBJECT_UINT_FLAGS_FLAGS (GClosure *closure,
8573 GValue *return_value G_GNUC_UNUSED,
8574 guint n_param_values,
8575 const GValue *param_values,
8576 gpointer invocation_hint G_GNUC_UNUSED,
8577 gpointer marshal_data)
8578 {
8579 typedef void (*GMarshalFunc_VOID__UINT_OBJECT_UINT_FLAGS_FLAGS) (gpointer data1,
8580 guint arg1,
8581 gpointer arg2,
8582 guint arg3,
8583 guint arg4,
8584 guint arg5,
8585 gpointer data2);
8586 GCClosure *cc = (GCClosure *) closure;
8587 gpointer data1, data2;
8588 GMarshalFunc_VOID__UINT_OBJECT_UINT_FLAGS_FLAGS callback;
8589
8590 g_return_if_fail (n_param_values == 6);
8591
8592 if (G_CCLOSURE_SWAP_DATA (closure))
8593 {
8594 data1 = closure->data;
8595 data2 = g_value_peek_pointer (param_values + 0);
8596 }
8597 else
8598 {
8599 data1 = g_value_peek_pointer (param_values + 0);
8600 data2 = closure->data;
8601 }
8602 callback = (GMarshalFunc_VOID__UINT_OBJECT_UINT_FLAGS_FLAGS) (marshal_data ? marshal_data : cc->callback);
8603
8604 callback (data1,
8605 g_marshal_value_peek_uint (param_values + 1),
8606 g_marshal_value_peek_object (param_values + 2),
8607 g_marshal_value_peek_uint (param_values + 3),
8608 g_marshal_value_peek_flags (param_values + 4),
8609 g_marshal_value_peek_flags (param_values + 5),
8610 data2);
8611 }
8612
8613 void
_gtk_marshal_VOID__UINT_OBJECT_UINT_FLAGS_FLAGSv(GClosure * closure,GValue * return_value G_GNUC_UNUSED,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)8614 _gtk_marshal_VOID__UINT_OBJECT_UINT_FLAGS_FLAGSv (GClosure *closure,
8615 GValue *return_value G_GNUC_UNUSED,
8616 gpointer instance,
8617 va_list args,
8618 gpointer marshal_data,
8619 int n_params,
8620 GType *param_types)
8621 {
8622 typedef void (*GMarshalFunc_VOID__UINT_OBJECT_UINT_FLAGS_FLAGS) (gpointer data1,
8623 guint arg1,
8624 gpointer arg2,
8625 guint arg3,
8626 guint arg4,
8627 guint arg5,
8628 gpointer data2);
8629 GCClosure *cc = (GCClosure *) closure;
8630 gpointer data1, data2;
8631 GMarshalFunc_VOID__UINT_OBJECT_UINT_FLAGS_FLAGS callback;
8632 guint arg0;
8633 gpointer arg1;
8634 guint arg2;
8635 guint arg3;
8636 guint arg4;
8637 va_list args_copy;
8638
8639 G_VA_COPY (args_copy, args);
8640 arg0 = (guint) va_arg (args_copy, guint);
8641 arg1 = (gpointer) va_arg (args_copy, gpointer);
8642 if (arg1 != NULL)
8643 arg1 = g_object_ref (arg1);
8644 arg2 = (guint) va_arg (args_copy, guint);
8645 arg3 = (guint) va_arg (args_copy, guint);
8646 arg4 = (guint) va_arg (args_copy, guint);
8647 va_end (args_copy);
8648
8649
8650 if (G_CCLOSURE_SWAP_DATA (closure))
8651 {
8652 data1 = closure->data;
8653 data2 = instance;
8654 }
8655 else
8656 {
8657 data1 = instance;
8658 data2 = closure->data;
8659 }
8660 callback = (GMarshalFunc_VOID__UINT_OBJECT_UINT_FLAGS_FLAGS) (marshal_data ? marshal_data : cc->callback);
8661
8662 callback (data1,
8663 arg0,
8664 arg1,
8665 arg2,
8666 arg3,
8667 arg4,
8668 data2);
8669 if (arg1 != NULL)
8670 g_object_unref (arg1);
8671 }
8672
8673 /* VOID:UINT,STRING,UINT (./gtkmarshalers.list:122) */
8674 void
_gtk_marshal_VOID__UINT_STRING_UINT(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)8675 _gtk_marshal_VOID__UINT_STRING_UINT (GClosure *closure,
8676 GValue *return_value G_GNUC_UNUSED,
8677 guint n_param_values,
8678 const GValue *param_values,
8679 gpointer invocation_hint G_GNUC_UNUSED,
8680 gpointer marshal_data)
8681 {
8682 typedef void (*GMarshalFunc_VOID__UINT_STRING_UINT) (gpointer data1,
8683 guint arg1,
8684 gpointer arg2,
8685 guint arg3,
8686 gpointer data2);
8687 GCClosure *cc = (GCClosure *) closure;
8688 gpointer data1, data2;
8689 GMarshalFunc_VOID__UINT_STRING_UINT callback;
8690
8691 g_return_if_fail (n_param_values == 4);
8692
8693 if (G_CCLOSURE_SWAP_DATA (closure))
8694 {
8695 data1 = closure->data;
8696 data2 = g_value_peek_pointer (param_values + 0);
8697 }
8698 else
8699 {
8700 data1 = g_value_peek_pointer (param_values + 0);
8701 data2 = closure->data;
8702 }
8703 callback = (GMarshalFunc_VOID__UINT_STRING_UINT) (marshal_data ? marshal_data : cc->callback);
8704
8705 callback (data1,
8706 g_marshal_value_peek_uint (param_values + 1),
8707 g_marshal_value_peek_string (param_values + 2),
8708 g_marshal_value_peek_uint (param_values + 3),
8709 data2);
8710 }
8711
8712 void
_gtk_marshal_VOID__UINT_STRING_UINTv(GClosure * closure,GValue * return_value G_GNUC_UNUSED,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)8713 _gtk_marshal_VOID__UINT_STRING_UINTv (GClosure *closure,
8714 GValue *return_value G_GNUC_UNUSED,
8715 gpointer instance,
8716 va_list args,
8717 gpointer marshal_data,
8718 int n_params,
8719 GType *param_types)
8720 {
8721 typedef void (*GMarshalFunc_VOID__UINT_STRING_UINT) (gpointer data1,
8722 guint arg1,
8723 gpointer arg2,
8724 guint arg3,
8725 gpointer data2);
8726 GCClosure *cc = (GCClosure *) closure;
8727 gpointer data1, data2;
8728 GMarshalFunc_VOID__UINT_STRING_UINT callback;
8729 guint arg0;
8730 gpointer arg1;
8731 guint arg2;
8732 va_list args_copy;
8733
8734 G_VA_COPY (args_copy, args);
8735 arg0 = (guint) va_arg (args_copy, guint);
8736 arg1 = (gpointer) va_arg (args_copy, gpointer);
8737 if ((param_types[1] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg1 != NULL)
8738 arg1 = g_strdup (arg1);
8739 arg2 = (guint) va_arg (args_copy, guint);
8740 va_end (args_copy);
8741
8742
8743 if (G_CCLOSURE_SWAP_DATA (closure))
8744 {
8745 data1 = closure->data;
8746 data2 = instance;
8747 }
8748 else
8749 {
8750 data1 = instance;
8751 data2 = closure->data;
8752 }
8753 callback = (GMarshalFunc_VOID__UINT_STRING_UINT) (marshal_data ? marshal_data : cc->callback);
8754
8755 callback (data1,
8756 arg0,
8757 arg1,
8758 arg2,
8759 data2);
8760 if ((param_types[1] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg1 != NULL)
8761 g_free (arg1);
8762 }
8763
8764 /* OBJECT:OBJECT,INT,INT (./gtkmarshalers.list:124) */
8765 void
_gtk_marshal_OBJECT__OBJECT_INT_INT(GClosure * closure,GValue * return_value,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)8766 _gtk_marshal_OBJECT__OBJECT_INT_INT (GClosure *closure,
8767 GValue *return_value,
8768 guint n_param_values,
8769 const GValue *param_values,
8770 gpointer invocation_hint G_GNUC_UNUSED,
8771 gpointer marshal_data)
8772 {
8773 typedef GObject* (*GMarshalFunc_OBJECT__OBJECT_INT_INT) (gpointer data1,
8774 gpointer arg1,
8775 gint arg2,
8776 gint arg3,
8777 gpointer data2);
8778 GCClosure *cc = (GCClosure *) closure;
8779 gpointer data1, data2;
8780 GMarshalFunc_OBJECT__OBJECT_INT_INT callback;
8781 GObject* v_return;
8782
8783 g_return_if_fail (return_value != NULL);
8784 g_return_if_fail (n_param_values == 4);
8785
8786 if (G_CCLOSURE_SWAP_DATA (closure))
8787 {
8788 data1 = closure->data;
8789 data2 = g_value_peek_pointer (param_values + 0);
8790 }
8791 else
8792 {
8793 data1 = g_value_peek_pointer (param_values + 0);
8794 data2 = closure->data;
8795 }
8796 callback = (GMarshalFunc_OBJECT__OBJECT_INT_INT) (marshal_data ? marshal_data : cc->callback);
8797
8798 v_return = callback (data1,
8799 g_marshal_value_peek_object (param_values + 1),
8800 g_marshal_value_peek_int (param_values + 2),
8801 g_marshal_value_peek_int (param_values + 3),
8802 data2);
8803
8804 g_value_take_object (return_value, v_return);
8805 }
8806
8807 void
_gtk_marshal_OBJECT__OBJECT_INT_INTv(GClosure * closure,GValue * return_value,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)8808 _gtk_marshal_OBJECT__OBJECT_INT_INTv (GClosure *closure,
8809 GValue *return_value,
8810 gpointer instance,
8811 va_list args,
8812 gpointer marshal_data,
8813 int n_params,
8814 GType *param_types)
8815 {
8816 typedef GObject* (*GMarshalFunc_OBJECT__OBJECT_INT_INT) (gpointer data1,
8817 gpointer arg1,
8818 gint arg2,
8819 gint arg3,
8820 gpointer data2);
8821 GCClosure *cc = (GCClosure *) closure;
8822 gpointer data1, data2;
8823 GMarshalFunc_OBJECT__OBJECT_INT_INT callback;
8824 GObject* v_return;
8825 gpointer arg0;
8826 gint arg1;
8827 gint arg2;
8828 va_list args_copy;
8829
8830 G_VA_COPY (args_copy, args);
8831 arg0 = (gpointer) va_arg (args_copy, gpointer);
8832 if (arg0 != NULL)
8833 arg0 = g_object_ref (arg0);
8834 arg1 = (gint) va_arg (args_copy, gint);
8835 arg2 = (gint) va_arg (args_copy, gint);
8836 va_end (args_copy);
8837
8838 g_return_if_fail (return_value != NULL);
8839
8840 if (G_CCLOSURE_SWAP_DATA (closure))
8841 {
8842 data1 = closure->data;
8843 data2 = instance;
8844 }
8845 else
8846 {
8847 data1 = instance;
8848 data2 = closure->data;
8849 }
8850 callback = (GMarshalFunc_OBJECT__OBJECT_INT_INT) (marshal_data ? marshal_data : cc->callback);
8851
8852 v_return = callback (data1,
8853 arg0,
8854 arg1,
8855 arg2,
8856 data2);
8857 if (arg0 != NULL)
8858 g_object_unref (arg0);
8859
8860 g_value_take_object (return_value, v_return);
8861 }
8862
8863 /* VOID:OBJECT,STRING,POINTER,POINTER (./gtkmarshalers.list:125) */
8864 void
_gtk_marshal_VOID__OBJECT_STRING_POINTER_POINTER(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)8865 _gtk_marshal_VOID__OBJECT_STRING_POINTER_POINTER (GClosure *closure,
8866 GValue *return_value G_GNUC_UNUSED,
8867 guint n_param_values,
8868 const GValue *param_values,
8869 gpointer invocation_hint G_GNUC_UNUSED,
8870 gpointer marshal_data)
8871 {
8872 typedef void (*GMarshalFunc_VOID__OBJECT_STRING_POINTER_POINTER) (gpointer data1,
8873 gpointer arg1,
8874 gpointer arg2,
8875 gpointer arg3,
8876 gpointer arg4,
8877 gpointer data2);
8878 GCClosure *cc = (GCClosure *) closure;
8879 gpointer data1, data2;
8880 GMarshalFunc_VOID__OBJECT_STRING_POINTER_POINTER callback;
8881
8882 g_return_if_fail (n_param_values == 5);
8883
8884 if (G_CCLOSURE_SWAP_DATA (closure))
8885 {
8886 data1 = closure->data;
8887 data2 = g_value_peek_pointer (param_values + 0);
8888 }
8889 else
8890 {
8891 data1 = g_value_peek_pointer (param_values + 0);
8892 data2 = closure->data;
8893 }
8894 callback = (GMarshalFunc_VOID__OBJECT_STRING_POINTER_POINTER) (marshal_data ? marshal_data : cc->callback);
8895
8896 callback (data1,
8897 g_marshal_value_peek_object (param_values + 1),
8898 g_marshal_value_peek_string (param_values + 2),
8899 g_marshal_value_peek_pointer (param_values + 3),
8900 g_marshal_value_peek_pointer (param_values + 4),
8901 data2);
8902 }
8903
8904 void
_gtk_marshal_VOID__OBJECT_STRING_POINTER_POINTERv(GClosure * closure,GValue * return_value G_GNUC_UNUSED,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)8905 _gtk_marshal_VOID__OBJECT_STRING_POINTER_POINTERv (GClosure *closure,
8906 GValue *return_value G_GNUC_UNUSED,
8907 gpointer instance,
8908 va_list args,
8909 gpointer marshal_data,
8910 int n_params,
8911 GType *param_types)
8912 {
8913 typedef void (*GMarshalFunc_VOID__OBJECT_STRING_POINTER_POINTER) (gpointer data1,
8914 gpointer arg1,
8915 gpointer arg2,
8916 gpointer arg3,
8917 gpointer arg4,
8918 gpointer data2);
8919 GCClosure *cc = (GCClosure *) closure;
8920 gpointer data1, data2;
8921 GMarshalFunc_VOID__OBJECT_STRING_POINTER_POINTER callback;
8922 gpointer arg0;
8923 gpointer arg1;
8924 gpointer arg2;
8925 gpointer arg3;
8926 va_list args_copy;
8927
8928 G_VA_COPY (args_copy, args);
8929 arg0 = (gpointer) va_arg (args_copy, gpointer);
8930 if (arg0 != NULL)
8931 arg0 = g_object_ref (arg0);
8932 arg1 = (gpointer) va_arg (args_copy, gpointer);
8933 if ((param_types[1] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg1 != NULL)
8934 arg1 = g_strdup (arg1);
8935 arg2 = (gpointer) va_arg (args_copy, gpointer);
8936 arg3 = (gpointer) va_arg (args_copy, gpointer);
8937 va_end (args_copy);
8938
8939
8940 if (G_CCLOSURE_SWAP_DATA (closure))
8941 {
8942 data1 = closure->data;
8943 data2 = instance;
8944 }
8945 else
8946 {
8947 data1 = instance;
8948 data2 = closure->data;
8949 }
8950 callback = (GMarshalFunc_VOID__OBJECT_STRING_POINTER_POINTER) (marshal_data ? marshal_data : cc->callback);
8951
8952 callback (data1,
8953 arg0,
8954 arg1,
8955 arg2,
8956 arg3,
8957 data2);
8958 if (arg0 != NULL)
8959 g_object_unref (arg0);
8960 if ((param_types[1] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg1 != NULL)
8961 g_free (arg1);
8962 }
8963
8964 /* INT:INT (./gtkmarshalers.list:126) */
8965 void
_gtk_marshal_INT__INT(GClosure * closure,GValue * return_value,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)8966 _gtk_marshal_INT__INT (GClosure *closure,
8967 GValue *return_value,
8968 guint n_param_values,
8969 const GValue *param_values,
8970 gpointer invocation_hint G_GNUC_UNUSED,
8971 gpointer marshal_data)
8972 {
8973 typedef gint (*GMarshalFunc_INT__INT) (gpointer data1,
8974 gint arg1,
8975 gpointer data2);
8976 GCClosure *cc = (GCClosure *) closure;
8977 gpointer data1, data2;
8978 GMarshalFunc_INT__INT callback;
8979 gint v_return;
8980
8981 g_return_if_fail (return_value != NULL);
8982 g_return_if_fail (n_param_values == 2);
8983
8984 if (G_CCLOSURE_SWAP_DATA (closure))
8985 {
8986 data1 = closure->data;
8987 data2 = g_value_peek_pointer (param_values + 0);
8988 }
8989 else
8990 {
8991 data1 = g_value_peek_pointer (param_values + 0);
8992 data2 = closure->data;
8993 }
8994 callback = (GMarshalFunc_INT__INT) (marshal_data ? marshal_data : cc->callback);
8995
8996 v_return = callback (data1,
8997 g_marshal_value_peek_int (param_values + 1),
8998 data2);
8999
9000 g_value_set_int (return_value, v_return);
9001 }
9002
9003 void
_gtk_marshal_INT__INTv(GClosure * closure,GValue * return_value,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)9004 _gtk_marshal_INT__INTv (GClosure *closure,
9005 GValue *return_value,
9006 gpointer instance,
9007 va_list args,
9008 gpointer marshal_data,
9009 int n_params,
9010 GType *param_types)
9011 {
9012 typedef gint (*GMarshalFunc_INT__INT) (gpointer data1,
9013 gint arg1,
9014 gpointer data2);
9015 GCClosure *cc = (GCClosure *) closure;
9016 gpointer data1, data2;
9017 GMarshalFunc_INT__INT callback;
9018 gint v_return;
9019 gint arg0;
9020 va_list args_copy;
9021
9022 G_VA_COPY (args_copy, args);
9023 arg0 = (gint) va_arg (args_copy, gint);
9024 va_end (args_copy);
9025
9026 g_return_if_fail (return_value != NULL);
9027
9028 if (G_CCLOSURE_SWAP_DATA (closure))
9029 {
9030 data1 = closure->data;
9031 data2 = instance;
9032 }
9033 else
9034 {
9035 data1 = instance;
9036 data2 = closure->data;
9037 }
9038 callback = (GMarshalFunc_INT__INT) (marshal_data ? marshal_data : cc->callback);
9039
9040 v_return = callback (data1,
9041 arg0,
9042 data2);
9043
9044
9045 g_value_set_int (return_value, v_return);
9046 }
9047
9048 /* VOID:POINTER,STRING,INT (./gtkmarshalers.list:127) */
9049 void
_gtk_marshal_VOID__POINTER_STRING_INT(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)9050 _gtk_marshal_VOID__POINTER_STRING_INT (GClosure *closure,
9051 GValue *return_value G_GNUC_UNUSED,
9052 guint n_param_values,
9053 const GValue *param_values,
9054 gpointer invocation_hint G_GNUC_UNUSED,
9055 gpointer marshal_data)
9056 {
9057 typedef void (*GMarshalFunc_VOID__POINTER_STRING_INT) (gpointer data1,
9058 gpointer arg1,
9059 gpointer arg2,
9060 gint arg3,
9061 gpointer data2);
9062 GCClosure *cc = (GCClosure *) closure;
9063 gpointer data1, data2;
9064 GMarshalFunc_VOID__POINTER_STRING_INT callback;
9065
9066 g_return_if_fail (n_param_values == 4);
9067
9068 if (G_CCLOSURE_SWAP_DATA (closure))
9069 {
9070 data1 = closure->data;
9071 data2 = g_value_peek_pointer (param_values + 0);
9072 }
9073 else
9074 {
9075 data1 = g_value_peek_pointer (param_values + 0);
9076 data2 = closure->data;
9077 }
9078 callback = (GMarshalFunc_VOID__POINTER_STRING_INT) (marshal_data ? marshal_data : cc->callback);
9079
9080 callback (data1,
9081 g_marshal_value_peek_pointer (param_values + 1),
9082 g_marshal_value_peek_string (param_values + 2),
9083 g_marshal_value_peek_int (param_values + 3),
9084 data2);
9085 }
9086
9087 void
_gtk_marshal_VOID__POINTER_STRING_INTv(GClosure * closure,GValue * return_value G_GNUC_UNUSED,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)9088 _gtk_marshal_VOID__POINTER_STRING_INTv (GClosure *closure,
9089 GValue *return_value G_GNUC_UNUSED,
9090 gpointer instance,
9091 va_list args,
9092 gpointer marshal_data,
9093 int n_params,
9094 GType *param_types)
9095 {
9096 typedef void (*GMarshalFunc_VOID__POINTER_STRING_INT) (gpointer data1,
9097 gpointer arg1,
9098 gpointer arg2,
9099 gint arg3,
9100 gpointer data2);
9101 GCClosure *cc = (GCClosure *) closure;
9102 gpointer data1, data2;
9103 GMarshalFunc_VOID__POINTER_STRING_INT callback;
9104 gpointer arg0;
9105 gpointer arg1;
9106 gint arg2;
9107 va_list args_copy;
9108
9109 G_VA_COPY (args_copy, args);
9110 arg0 = (gpointer) va_arg (args_copy, gpointer);
9111 arg1 = (gpointer) va_arg (args_copy, gpointer);
9112 if ((param_types[1] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg1 != NULL)
9113 arg1 = g_strdup (arg1);
9114 arg2 = (gint) va_arg (args_copy, gint);
9115 va_end (args_copy);
9116
9117
9118 if (G_CCLOSURE_SWAP_DATA (closure))
9119 {
9120 data1 = closure->data;
9121 data2 = instance;
9122 }
9123 else
9124 {
9125 data1 = instance;
9126 data2 = closure->data;
9127 }
9128 callback = (GMarshalFunc_VOID__POINTER_STRING_INT) (marshal_data ? marshal_data : cc->callback);
9129
9130 callback (data1,
9131 arg0,
9132 arg1,
9133 arg2,
9134 data2);
9135 if ((param_types[1] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg1 != NULL)
9136 g_free (arg1);
9137 }
9138
9139 /* INT:OBJECT,OBJECT,POINTER (./gtkmarshalers.list:128) */
9140 void
_gtk_marshal_INT__OBJECT_OBJECT_POINTER(GClosure * closure,GValue * return_value,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)9141 _gtk_marshal_INT__OBJECT_OBJECT_POINTER (GClosure *closure,
9142 GValue *return_value,
9143 guint n_param_values,
9144 const GValue *param_values,
9145 gpointer invocation_hint G_GNUC_UNUSED,
9146 gpointer marshal_data)
9147 {
9148 typedef gint (*GMarshalFunc_INT__OBJECT_OBJECT_POINTER) (gpointer data1,
9149 gpointer arg1,
9150 gpointer arg2,
9151 gpointer arg3,
9152 gpointer data2);
9153 GCClosure *cc = (GCClosure *) closure;
9154 gpointer data1, data2;
9155 GMarshalFunc_INT__OBJECT_OBJECT_POINTER callback;
9156 gint v_return;
9157
9158 g_return_if_fail (return_value != NULL);
9159 g_return_if_fail (n_param_values == 4);
9160
9161 if (G_CCLOSURE_SWAP_DATA (closure))
9162 {
9163 data1 = closure->data;
9164 data2 = g_value_peek_pointer (param_values + 0);
9165 }
9166 else
9167 {
9168 data1 = g_value_peek_pointer (param_values + 0);
9169 data2 = closure->data;
9170 }
9171 callback = (GMarshalFunc_INT__OBJECT_OBJECT_POINTER) (marshal_data ? marshal_data : cc->callback);
9172
9173 v_return = callback (data1,
9174 g_marshal_value_peek_object (param_values + 1),
9175 g_marshal_value_peek_object (param_values + 2),
9176 g_marshal_value_peek_pointer (param_values + 3),
9177 data2);
9178
9179 g_value_set_int (return_value, v_return);
9180 }
9181
9182 void
_gtk_marshal_INT__OBJECT_OBJECT_POINTERv(GClosure * closure,GValue * return_value,gpointer instance,va_list args,gpointer marshal_data,int n_params,GType * param_types)9183 _gtk_marshal_INT__OBJECT_OBJECT_POINTERv (GClosure *closure,
9184 GValue *return_value,
9185 gpointer instance,
9186 va_list args,
9187 gpointer marshal_data,
9188 int n_params,
9189 GType *param_types)
9190 {
9191 typedef gint (*GMarshalFunc_INT__OBJECT_OBJECT_POINTER) (gpointer data1,
9192 gpointer arg1,
9193 gpointer arg2,
9194 gpointer arg3,
9195 gpointer data2);
9196 GCClosure *cc = (GCClosure *) closure;
9197 gpointer data1, data2;
9198 GMarshalFunc_INT__OBJECT_OBJECT_POINTER callback;
9199 gint v_return;
9200 gpointer arg0;
9201 gpointer arg1;
9202 gpointer arg2;
9203 va_list args_copy;
9204
9205 G_VA_COPY (args_copy, args);
9206 arg0 = (gpointer) va_arg (args_copy, gpointer);
9207 if (arg0 != NULL)
9208 arg0 = g_object_ref (arg0);
9209 arg1 = (gpointer) va_arg (args_copy, gpointer);
9210 if (arg1 != NULL)
9211 arg1 = g_object_ref (arg1);
9212 arg2 = (gpointer) va_arg (args_copy, gpointer);
9213 va_end (args_copy);
9214
9215 g_return_if_fail (return_value != NULL);
9216
9217 if (G_CCLOSURE_SWAP_DATA (closure))
9218 {
9219 data1 = closure->data;
9220 data2 = instance;
9221 }
9222 else
9223 {
9224 data1 = instance;
9225 data2 = closure->data;
9226 }
9227 callback = (GMarshalFunc_INT__OBJECT_OBJECT_POINTER) (marshal_data ? marshal_data : cc->callback);
9228
9229 v_return = callback (data1,
9230 arg0,
9231 arg1,
9232 arg2,
9233 data2);
9234 if (arg0 != NULL)
9235 g_object_unref (arg0);
9236 if (arg1 != NULL)
9237 g_object_unref (arg1);
9238
9239 g_value_set_int (return_value, v_return);
9240 }
9241
9242