1 #include "gtkmarshalers.h"
2 #include "gtkalias.h"
3 /* 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. */
4 #include <glib-object.h>
5
6 #ifdef G_ENABLE_DEBUG
7 #define g_marshal_value_peek_boolean(v) g_value_get_boolean (v)
8 #define g_marshal_value_peek_char(v) g_value_get_schar (v)
9 #define g_marshal_value_peek_uchar(v) g_value_get_uchar (v)
10 #define g_marshal_value_peek_int(v) g_value_get_int (v)
11 #define g_marshal_value_peek_uint(v) g_value_get_uint (v)
12 #define g_marshal_value_peek_long(v) g_value_get_long (v)
13 #define g_marshal_value_peek_ulong(v) g_value_get_ulong (v)
14 #define g_marshal_value_peek_int64(v) g_value_get_int64 (v)
15 #define g_marshal_value_peek_uint64(v) g_value_get_uint64 (v)
16 #define g_marshal_value_peek_enum(v) g_value_get_enum (v)
17 #define g_marshal_value_peek_flags(v) g_value_get_flags (v)
18 #define g_marshal_value_peek_float(v) g_value_get_float (v)
19 #define g_marshal_value_peek_double(v) g_value_get_double (v)
20 #define g_marshal_value_peek_string(v) (char*) g_value_get_string (v)
21 #define g_marshal_value_peek_param(v) g_value_get_param (v)
22 #define g_marshal_value_peek_boxed(v) g_value_get_boxed (v)
23 #define g_marshal_value_peek_pointer(v) g_value_get_pointer (v)
24 #define g_marshal_value_peek_object(v) g_value_get_object (v)
25 #define g_marshal_value_peek_variant(v) g_value_get_variant (v)
26 #else /* !G_ENABLE_DEBUG */
27 /* WARNING: This code accesses GValues directly, which is UNSUPPORTED API.
28 * Do not access GValues directly in your code. Instead, use the
29 * g_value_get_*() functions
30 */
31 #define g_marshal_value_peek_boolean(v) (v)->data[0].v_int
32 #define g_marshal_value_peek_char(v) (v)->data[0].v_int
33 #define g_marshal_value_peek_uchar(v) (v)->data[0].v_uint
34 #define g_marshal_value_peek_int(v) (v)->data[0].v_int
35 #define g_marshal_value_peek_uint(v) (v)->data[0].v_uint
36 #define g_marshal_value_peek_long(v) (v)->data[0].v_long
37 #define g_marshal_value_peek_ulong(v) (v)->data[0].v_ulong
38 #define g_marshal_value_peek_int64(v) (v)->data[0].v_int64
39 #define g_marshal_value_peek_uint64(v) (v)->data[0].v_uint64
40 #define g_marshal_value_peek_enum(v) (v)->data[0].v_long
41 #define g_marshal_value_peek_flags(v) (v)->data[0].v_ulong
42 #define g_marshal_value_peek_float(v) (v)->data[0].v_float
43 #define g_marshal_value_peek_double(v) (v)->data[0].v_double
44 #define g_marshal_value_peek_string(v) (v)->data[0].v_pointer
45 #define g_marshal_value_peek_param(v) (v)->data[0].v_pointer
46 #define g_marshal_value_peek_boxed(v) (v)->data[0].v_pointer
47 #define g_marshal_value_peek_pointer(v) (v)->data[0].v_pointer
48 #define g_marshal_value_peek_object(v) (v)->data[0].v_pointer
49 #define g_marshal_value_peek_variant(v) (v)->data[0].v_pointer
50 #endif /* !G_ENABLE_DEBUG */
51
52 /* BOOLEAN:BOXED (./gtkmarshalers.list:24) */
53 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)54 _gtk_marshal_BOOLEAN__BOXED (GClosure *closure,
55 GValue *return_value,
56 guint n_param_values,
57 const GValue *param_values,
58 gpointer invocation_hint G_GNUC_UNUSED,
59 gpointer marshal_data)
60 {
61 typedef gboolean (*GMarshalFunc_BOOLEAN__BOXED) (gpointer data1,
62 gpointer arg1,
63 gpointer data2);
64 GCClosure *cc = (GCClosure *) closure;
65 gpointer data1, data2;
66 GMarshalFunc_BOOLEAN__BOXED callback;
67 gboolean v_return;
68
69 g_return_if_fail (return_value != NULL);
70 g_return_if_fail (n_param_values == 2);
71
72 if (G_CCLOSURE_SWAP_DATA (closure))
73 {
74 data1 = closure->data;
75 data2 = g_value_peek_pointer (param_values + 0);
76 }
77 else
78 {
79 data1 = g_value_peek_pointer (param_values + 0);
80 data2 = closure->data;
81 }
82 callback = (GMarshalFunc_BOOLEAN__BOXED) (marshal_data ? marshal_data : cc->callback);
83
84 v_return = callback (data1,
85 g_marshal_value_peek_boxed (param_values + 1),
86 data2);
87
88 g_value_set_boolean (return_value, v_return);
89 }
90
91 /* BOOLEAN:ENUM (./gtkmarshalers.list:26) */
92 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)93 _gtk_marshal_BOOLEAN__ENUM (GClosure *closure,
94 GValue *return_value,
95 guint n_param_values,
96 const GValue *param_values,
97 gpointer invocation_hint G_GNUC_UNUSED,
98 gpointer marshal_data)
99 {
100 typedef gboolean (*GMarshalFunc_BOOLEAN__ENUM) (gpointer data1,
101 gint arg1,
102 gpointer data2);
103 GCClosure *cc = (GCClosure *) closure;
104 gpointer data1, data2;
105 GMarshalFunc_BOOLEAN__ENUM callback;
106 gboolean v_return;
107
108 g_return_if_fail (return_value != NULL);
109 g_return_if_fail (n_param_values == 2);
110
111 if (G_CCLOSURE_SWAP_DATA (closure))
112 {
113 data1 = closure->data;
114 data2 = g_value_peek_pointer (param_values + 0);
115 }
116 else
117 {
118 data1 = g_value_peek_pointer (param_values + 0);
119 data2 = closure->data;
120 }
121 callback = (GMarshalFunc_BOOLEAN__ENUM) (marshal_data ? marshal_data : cc->callback);
122
123 v_return = callback (data1,
124 g_marshal_value_peek_enum (param_values + 1),
125 data2);
126
127 g_value_set_boolean (return_value, v_return);
128 }
129
130 /* BOOLEAN:ENUM,BOOLEAN (./gtkmarshalers.list:27) */
131 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)132 _gtk_marshal_BOOLEAN__ENUM_BOOLEAN (GClosure *closure,
133 GValue *return_value,
134 guint n_param_values,
135 const GValue *param_values,
136 gpointer invocation_hint G_GNUC_UNUSED,
137 gpointer marshal_data)
138 {
139 typedef gboolean (*GMarshalFunc_BOOLEAN__ENUM_BOOLEAN) (gpointer data1,
140 gint arg1,
141 gboolean arg2,
142 gpointer data2);
143 GCClosure *cc = (GCClosure *) closure;
144 gpointer data1, data2;
145 GMarshalFunc_BOOLEAN__ENUM_BOOLEAN callback;
146 gboolean v_return;
147
148 g_return_if_fail (return_value != NULL);
149 g_return_if_fail (n_param_values == 3);
150
151 if (G_CCLOSURE_SWAP_DATA (closure))
152 {
153 data1 = closure->data;
154 data2 = g_value_peek_pointer (param_values + 0);
155 }
156 else
157 {
158 data1 = g_value_peek_pointer (param_values + 0);
159 data2 = closure->data;
160 }
161 callback = (GMarshalFunc_BOOLEAN__ENUM_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
162
163 v_return = callback (data1,
164 g_marshal_value_peek_enum (param_values + 1),
165 g_marshal_value_peek_boolean (param_values + 2),
166 data2);
167
168 g_value_set_boolean (return_value, v_return);
169 }
170
171 /* BOOLEAN:ENUM,DOUBLE (./gtkmarshalers.list:28) */
172 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)173 _gtk_marshal_BOOLEAN__ENUM_DOUBLE (GClosure *closure,
174 GValue *return_value,
175 guint n_param_values,
176 const GValue *param_values,
177 gpointer invocation_hint G_GNUC_UNUSED,
178 gpointer marshal_data)
179 {
180 typedef gboolean (*GMarshalFunc_BOOLEAN__ENUM_DOUBLE) (gpointer data1,
181 gint arg1,
182 gdouble arg2,
183 gpointer data2);
184 GCClosure *cc = (GCClosure *) closure;
185 gpointer data1, data2;
186 GMarshalFunc_BOOLEAN__ENUM_DOUBLE callback;
187 gboolean v_return;
188
189 g_return_if_fail (return_value != NULL);
190 g_return_if_fail (n_param_values == 3);
191
192 if (G_CCLOSURE_SWAP_DATA (closure))
193 {
194 data1 = closure->data;
195 data2 = g_value_peek_pointer (param_values + 0);
196 }
197 else
198 {
199 data1 = g_value_peek_pointer (param_values + 0);
200 data2 = closure->data;
201 }
202 callback = (GMarshalFunc_BOOLEAN__ENUM_DOUBLE) (marshal_data ? marshal_data : cc->callback);
203
204 v_return = callback (data1,
205 g_marshal_value_peek_enum (param_values + 1),
206 g_marshal_value_peek_double (param_values + 2),
207 data2);
208
209 g_value_set_boolean (return_value, v_return);
210 }
211
212 /* BOOLEAN:ENUM,INT (./gtkmarshalers.list:29) */
213 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)214 _gtk_marshal_BOOLEAN__ENUM_INT (GClosure *closure,
215 GValue *return_value,
216 guint n_param_values,
217 const GValue *param_values,
218 gpointer invocation_hint G_GNUC_UNUSED,
219 gpointer marshal_data)
220 {
221 typedef gboolean (*GMarshalFunc_BOOLEAN__ENUM_INT) (gpointer data1,
222 gint arg1,
223 gint arg2,
224 gpointer data2);
225 GCClosure *cc = (GCClosure *) closure;
226 gpointer data1, data2;
227 GMarshalFunc_BOOLEAN__ENUM_INT callback;
228 gboolean v_return;
229
230 g_return_if_fail (return_value != NULL);
231 g_return_if_fail (n_param_values == 3);
232
233 if (G_CCLOSURE_SWAP_DATA (closure))
234 {
235 data1 = closure->data;
236 data2 = g_value_peek_pointer (param_values + 0);
237 }
238 else
239 {
240 data1 = g_value_peek_pointer (param_values + 0);
241 data2 = closure->data;
242 }
243 callback = (GMarshalFunc_BOOLEAN__ENUM_INT) (marshal_data ? marshal_data : cc->callback);
244
245 v_return = callback (data1,
246 g_marshal_value_peek_enum (param_values + 1),
247 g_marshal_value_peek_int (param_values + 2),
248 data2);
249
250 g_value_set_boolean (return_value, v_return);
251 }
252
253 /* BOOLEAN:OBJECT (./gtkmarshalers.list:30) */
254 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)255 _gtk_marshal_BOOLEAN__OBJECT (GClosure *closure,
256 GValue *return_value,
257 guint n_param_values,
258 const GValue *param_values,
259 gpointer invocation_hint G_GNUC_UNUSED,
260 gpointer marshal_data)
261 {
262 typedef gboolean (*GMarshalFunc_BOOLEAN__OBJECT) (gpointer data1,
263 gpointer arg1,
264 gpointer data2);
265 GCClosure *cc = (GCClosure *) closure;
266 gpointer data1, data2;
267 GMarshalFunc_BOOLEAN__OBJECT callback;
268 gboolean v_return;
269
270 g_return_if_fail (return_value != NULL);
271 g_return_if_fail (n_param_values == 2);
272
273 if (G_CCLOSURE_SWAP_DATA (closure))
274 {
275 data1 = closure->data;
276 data2 = g_value_peek_pointer (param_values + 0);
277 }
278 else
279 {
280 data1 = g_value_peek_pointer (param_values + 0);
281 data2 = closure->data;
282 }
283 callback = (GMarshalFunc_BOOLEAN__OBJECT) (marshal_data ? marshal_data : cc->callback);
284
285 v_return = callback (data1,
286 g_marshal_value_peek_object (param_values + 1),
287 data2);
288
289 g_value_set_boolean (return_value, v_return);
290 }
291
292 /* BOOLEAN:OBJECT,UINT,FLAGS (./gtkmarshalers.list:31) */
293 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)294 _gtk_marshal_BOOLEAN__OBJECT_UINT_FLAGS (GClosure *closure,
295 GValue *return_value,
296 guint n_param_values,
297 const GValue *param_values,
298 gpointer invocation_hint G_GNUC_UNUSED,
299 gpointer marshal_data)
300 {
301 typedef gboolean (*GMarshalFunc_BOOLEAN__OBJECT_UINT_FLAGS) (gpointer data1,
302 gpointer arg1,
303 guint arg2,
304 guint arg3,
305 gpointer data2);
306 GCClosure *cc = (GCClosure *) closure;
307 gpointer data1, data2;
308 GMarshalFunc_BOOLEAN__OBJECT_UINT_FLAGS callback;
309 gboolean v_return;
310
311 g_return_if_fail (return_value != NULL);
312 g_return_if_fail (n_param_values == 4);
313
314 if (G_CCLOSURE_SWAP_DATA (closure))
315 {
316 data1 = closure->data;
317 data2 = g_value_peek_pointer (param_values + 0);
318 }
319 else
320 {
321 data1 = g_value_peek_pointer (param_values + 0);
322 data2 = closure->data;
323 }
324 callback = (GMarshalFunc_BOOLEAN__OBJECT_UINT_FLAGS) (marshal_data ? marshal_data : cc->callback);
325
326 v_return = callback (data1,
327 g_marshal_value_peek_object (param_values + 1),
328 g_marshal_value_peek_uint (param_values + 2),
329 g_marshal_value_peek_flags (param_values + 3),
330 data2);
331
332 g_value_set_boolean (return_value, v_return);
333 }
334
335 /* BOOLEAN:OBJECT,INT,INT,UINT (./gtkmarshalers.list:32) */
336 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)337 _gtk_marshal_BOOLEAN__OBJECT_INT_INT_UINT (GClosure *closure,
338 GValue *return_value,
339 guint n_param_values,
340 const GValue *param_values,
341 gpointer invocation_hint G_GNUC_UNUSED,
342 gpointer marshal_data)
343 {
344 typedef gboolean (*GMarshalFunc_BOOLEAN__OBJECT_INT_INT_UINT) (gpointer data1,
345 gpointer arg1,
346 gint arg2,
347 gint arg3,
348 guint arg4,
349 gpointer data2);
350 GCClosure *cc = (GCClosure *) closure;
351 gpointer data1, data2;
352 GMarshalFunc_BOOLEAN__OBJECT_INT_INT_UINT callback;
353 gboolean v_return;
354
355 g_return_if_fail (return_value != NULL);
356 g_return_if_fail (n_param_values == 5);
357
358 if (G_CCLOSURE_SWAP_DATA (closure))
359 {
360 data1 = closure->data;
361 data2 = g_value_peek_pointer (param_values + 0);
362 }
363 else
364 {
365 data1 = g_value_peek_pointer (param_values + 0);
366 data2 = closure->data;
367 }
368 callback = (GMarshalFunc_BOOLEAN__OBJECT_INT_INT_UINT) (marshal_data ? marshal_data : cc->callback);
369
370 v_return = callback (data1,
371 g_marshal_value_peek_object (param_values + 1),
372 g_marshal_value_peek_int (param_values + 2),
373 g_marshal_value_peek_int (param_values + 3),
374 g_marshal_value_peek_uint (param_values + 4),
375 data2);
376
377 g_value_set_boolean (return_value, v_return);
378 }
379
380 /* BOOLEAN:OBJECT,STRING,STRING,BOXED (./gtkmarshalers.list:33) */
381 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)382 _gtk_marshal_BOOLEAN__OBJECT_STRING_STRING_BOXED (GClosure *closure,
383 GValue *return_value,
384 guint n_param_values,
385 const GValue *param_values,
386 gpointer invocation_hint G_GNUC_UNUSED,
387 gpointer marshal_data)
388 {
389 typedef gboolean (*GMarshalFunc_BOOLEAN__OBJECT_STRING_STRING_BOXED) (gpointer data1,
390 gpointer arg1,
391 gpointer arg2,
392 gpointer arg3,
393 gpointer arg4,
394 gpointer data2);
395 GCClosure *cc = (GCClosure *) closure;
396 gpointer data1, data2;
397 GMarshalFunc_BOOLEAN__OBJECT_STRING_STRING_BOXED callback;
398 gboolean v_return;
399
400 g_return_if_fail (return_value != NULL);
401 g_return_if_fail (n_param_values == 5);
402
403 if (G_CCLOSURE_SWAP_DATA (closure))
404 {
405 data1 = closure->data;
406 data2 = g_value_peek_pointer (param_values + 0);
407 }
408 else
409 {
410 data1 = g_value_peek_pointer (param_values + 0);
411 data2 = closure->data;
412 }
413 callback = (GMarshalFunc_BOOLEAN__OBJECT_STRING_STRING_BOXED) (marshal_data ? marshal_data : cc->callback);
414
415 v_return = callback (data1,
416 g_marshal_value_peek_object (param_values + 1),
417 g_marshal_value_peek_string (param_values + 2),
418 g_marshal_value_peek_string (param_values + 3),
419 g_marshal_value_peek_boxed (param_values + 4),
420 data2);
421
422 g_value_set_boolean (return_value, v_return);
423 }
424
425 /* BOOLEAN:OBJECT,BOXED (./gtkmarshalers.list:34) */
426 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)427 _gtk_marshal_BOOLEAN__OBJECT_BOXED (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__OBJECT_BOXED) (gpointer data1,
435 gpointer arg1,
436 gpointer arg2,
437 gpointer data2);
438 GCClosure *cc = (GCClosure *) closure;
439 gpointer data1, data2;
440 GMarshalFunc_BOOLEAN__OBJECT_BOXED 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__OBJECT_BOXED) (marshal_data ? marshal_data : cc->callback);
457
458 v_return = callback (data1,
459 g_marshal_value_peek_object (param_values + 1),
460 g_marshal_value_peek_boxed (param_values + 2),
461 data2);
462
463 g_value_set_boolean (return_value, v_return);
464 }
465
466 /* BOOLEAN:OBJECT,BOXED,BOXED (./gtkmarshalers.list:35) */
467 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)468 _gtk_marshal_BOOLEAN__OBJECT_BOXED_BOXED (GClosure *closure,
469 GValue *return_value,
470 guint n_param_values,
471 const GValue *param_values,
472 gpointer invocation_hint G_GNUC_UNUSED,
473 gpointer marshal_data)
474 {
475 typedef gboolean (*GMarshalFunc_BOOLEAN__OBJECT_BOXED_BOXED) (gpointer data1,
476 gpointer arg1,
477 gpointer arg2,
478 gpointer arg3,
479 gpointer data2);
480 GCClosure *cc = (GCClosure *) closure;
481 gpointer data1, data2;
482 GMarshalFunc_BOOLEAN__OBJECT_BOXED_BOXED callback;
483 gboolean v_return;
484
485 g_return_if_fail (return_value != NULL);
486 g_return_if_fail (n_param_values == 4);
487
488 if (G_CCLOSURE_SWAP_DATA (closure))
489 {
490 data1 = closure->data;
491 data2 = g_value_peek_pointer (param_values + 0);
492 }
493 else
494 {
495 data1 = g_value_peek_pointer (param_values + 0);
496 data2 = closure->data;
497 }
498 callback = (GMarshalFunc_BOOLEAN__OBJECT_BOXED_BOXED) (marshal_data ? marshal_data : cc->callback);
499
500 v_return = callback (data1,
501 g_marshal_value_peek_object (param_values + 1),
502 g_marshal_value_peek_boxed (param_values + 2),
503 g_marshal_value_peek_boxed (param_values + 3),
504 data2);
505
506 g_value_set_boolean (return_value, v_return);
507 }
508
509 /* BOOLEAN:OBJECT,OBJECT,OBJECT (./gtkmarshalers.list:36) */
510 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)511 _gtk_marshal_BOOLEAN__OBJECT_OBJECT_OBJECT (GClosure *closure,
512 GValue *return_value,
513 guint n_param_values,
514 const GValue *param_values,
515 gpointer invocation_hint G_GNUC_UNUSED,
516 gpointer marshal_data)
517 {
518 typedef gboolean (*GMarshalFunc_BOOLEAN__OBJECT_OBJECT_OBJECT) (gpointer data1,
519 gpointer arg1,
520 gpointer arg2,
521 gpointer arg3,
522 gpointer data2);
523 GCClosure *cc = (GCClosure *) closure;
524 gpointer data1, data2;
525 GMarshalFunc_BOOLEAN__OBJECT_OBJECT_OBJECT callback;
526 gboolean v_return;
527
528 g_return_if_fail (return_value != NULL);
529 g_return_if_fail (n_param_values == 4);
530
531 if (G_CCLOSURE_SWAP_DATA (closure))
532 {
533 data1 = closure->data;
534 data2 = g_value_peek_pointer (param_values + 0);
535 }
536 else
537 {
538 data1 = g_value_peek_pointer (param_values + 0);
539 data2 = closure->data;
540 }
541 callback = (GMarshalFunc_BOOLEAN__OBJECT_OBJECT_OBJECT) (marshal_data ? marshal_data : cc->callback);
542
543 v_return = callback (data1,
544 g_marshal_value_peek_object (param_values + 1),
545 g_marshal_value_peek_object (param_values + 2),
546 g_marshal_value_peek_object (param_values + 3),
547 data2);
548
549 g_value_set_boolean (return_value, v_return);
550 }
551
552 /* BOOLEAN:OBJECT,STRING,STRING (./gtkmarshalers.list:37) */
553 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)554 _gtk_marshal_BOOLEAN__OBJECT_STRING_STRING (GClosure *closure,
555 GValue *return_value,
556 guint n_param_values,
557 const GValue *param_values,
558 gpointer invocation_hint G_GNUC_UNUSED,
559 gpointer marshal_data)
560 {
561 typedef gboolean (*GMarshalFunc_BOOLEAN__OBJECT_STRING_STRING) (gpointer data1,
562 gpointer arg1,
563 gpointer arg2,
564 gpointer arg3,
565 gpointer data2);
566 GCClosure *cc = (GCClosure *) closure;
567 gpointer data1, data2;
568 GMarshalFunc_BOOLEAN__OBJECT_STRING_STRING callback;
569 gboolean v_return;
570
571 g_return_if_fail (return_value != NULL);
572 g_return_if_fail (n_param_values == 4);
573
574 if (G_CCLOSURE_SWAP_DATA (closure))
575 {
576 data1 = closure->data;
577 data2 = g_value_peek_pointer (param_values + 0);
578 }
579 else
580 {
581 data1 = g_value_peek_pointer (param_values + 0);
582 data2 = closure->data;
583 }
584 callback = (GMarshalFunc_BOOLEAN__OBJECT_STRING_STRING) (marshal_data ? marshal_data : cc->callback);
585
586 v_return = callback (data1,
587 g_marshal_value_peek_object (param_values + 1),
588 g_marshal_value_peek_string (param_values + 2),
589 g_marshal_value_peek_string (param_values + 3),
590 data2);
591
592 g_value_set_boolean (return_value, v_return);
593 }
594
595 /* BOOLEAN:OBJECT,ENUM (./gtkmarshalers.list:38) */
596 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)597 _gtk_marshal_BOOLEAN__OBJECT_ENUM (GClosure *closure,
598 GValue *return_value,
599 guint n_param_values,
600 const GValue *param_values,
601 gpointer invocation_hint G_GNUC_UNUSED,
602 gpointer marshal_data)
603 {
604 typedef gboolean (*GMarshalFunc_BOOLEAN__OBJECT_ENUM) (gpointer data1,
605 gpointer arg1,
606 gint arg2,
607 gpointer data2);
608 GCClosure *cc = (GCClosure *) closure;
609 gpointer data1, data2;
610 GMarshalFunc_BOOLEAN__OBJECT_ENUM callback;
611 gboolean v_return;
612
613 g_return_if_fail (return_value != NULL);
614 g_return_if_fail (n_param_values == 3);
615
616 if (G_CCLOSURE_SWAP_DATA (closure))
617 {
618 data1 = closure->data;
619 data2 = g_value_peek_pointer (param_values + 0);
620 }
621 else
622 {
623 data1 = g_value_peek_pointer (param_values + 0);
624 data2 = closure->data;
625 }
626 callback = (GMarshalFunc_BOOLEAN__OBJECT_ENUM) (marshal_data ? marshal_data : cc->callback);
627
628 v_return = callback (data1,
629 g_marshal_value_peek_object (param_values + 1),
630 g_marshal_value_peek_enum (param_values + 2),
631 data2);
632
633 g_value_set_boolean (return_value, v_return);
634 }
635
636 /* BOOLEAN:INT (./gtkmarshalers.list:39) */
637 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)638 _gtk_marshal_BOOLEAN__INT (GClosure *closure,
639 GValue *return_value,
640 guint n_param_values,
641 const GValue *param_values,
642 gpointer invocation_hint G_GNUC_UNUSED,
643 gpointer marshal_data)
644 {
645 typedef gboolean (*GMarshalFunc_BOOLEAN__INT) (gpointer data1,
646 gint arg1,
647 gpointer data2);
648 GCClosure *cc = (GCClosure *) closure;
649 gpointer data1, data2;
650 GMarshalFunc_BOOLEAN__INT callback;
651 gboolean v_return;
652
653 g_return_if_fail (return_value != NULL);
654 g_return_if_fail (n_param_values == 2);
655
656 if (G_CCLOSURE_SWAP_DATA (closure))
657 {
658 data1 = closure->data;
659 data2 = g_value_peek_pointer (param_values + 0);
660 }
661 else
662 {
663 data1 = g_value_peek_pointer (param_values + 0);
664 data2 = closure->data;
665 }
666 callback = (GMarshalFunc_BOOLEAN__INT) (marshal_data ? marshal_data : cc->callback);
667
668 v_return = callback (data1,
669 g_marshal_value_peek_int (param_values + 1),
670 data2);
671
672 g_value_set_boolean (return_value, v_return);
673 }
674
675 /* BOOLEAN:INT,INT (./gtkmarshalers.list:40) */
676 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)677 _gtk_marshal_BOOLEAN__INT_INT (GClosure *closure,
678 GValue *return_value,
679 guint n_param_values,
680 const GValue *param_values,
681 gpointer invocation_hint G_GNUC_UNUSED,
682 gpointer marshal_data)
683 {
684 typedef gboolean (*GMarshalFunc_BOOLEAN__INT_INT) (gpointer data1,
685 gint arg1,
686 gint arg2,
687 gpointer data2);
688 GCClosure *cc = (GCClosure *) closure;
689 gpointer data1, data2;
690 GMarshalFunc_BOOLEAN__INT_INT callback;
691 gboolean v_return;
692
693 g_return_if_fail (return_value != NULL);
694 g_return_if_fail (n_param_values == 3);
695
696 if (G_CCLOSURE_SWAP_DATA (closure))
697 {
698 data1 = closure->data;
699 data2 = g_value_peek_pointer (param_values + 0);
700 }
701 else
702 {
703 data1 = g_value_peek_pointer (param_values + 0);
704 data2 = closure->data;
705 }
706 callback = (GMarshalFunc_BOOLEAN__INT_INT) (marshal_data ? marshal_data : cc->callback);
707
708 v_return = callback (data1,
709 g_marshal_value_peek_int (param_values + 1),
710 g_marshal_value_peek_int (param_values + 2),
711 data2);
712
713 g_value_set_boolean (return_value, v_return);
714 }
715
716 /* BOOLEAN:INT,INT,INT (./gtkmarshalers.list:41) */
717 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)718 _gtk_marshal_BOOLEAN__INT_INT_INT (GClosure *closure,
719 GValue *return_value,
720 guint n_param_values,
721 const GValue *param_values,
722 gpointer invocation_hint G_GNUC_UNUSED,
723 gpointer marshal_data)
724 {
725 typedef gboolean (*GMarshalFunc_BOOLEAN__INT_INT_INT) (gpointer data1,
726 gint arg1,
727 gint arg2,
728 gint arg3,
729 gpointer data2);
730 GCClosure *cc = (GCClosure *) closure;
731 gpointer data1, data2;
732 GMarshalFunc_BOOLEAN__INT_INT_INT callback;
733 gboolean v_return;
734
735 g_return_if_fail (return_value != NULL);
736 g_return_if_fail (n_param_values == 4);
737
738 if (G_CCLOSURE_SWAP_DATA (closure))
739 {
740 data1 = closure->data;
741 data2 = g_value_peek_pointer (param_values + 0);
742 }
743 else
744 {
745 data1 = g_value_peek_pointer (param_values + 0);
746 data2 = closure->data;
747 }
748 callback = (GMarshalFunc_BOOLEAN__INT_INT_INT) (marshal_data ? marshal_data : cc->callback);
749
750 v_return = callback (data1,
751 g_marshal_value_peek_int (param_values + 1),
752 g_marshal_value_peek_int (param_values + 2),
753 g_marshal_value_peek_int (param_values + 3),
754 data2);
755
756 g_value_set_boolean (return_value, v_return);
757 }
758
759 /* BOOLEAN:INT,INT,BOOLEAN,OBJECT (./gtkmarshalers.list:42) */
760 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)761 _gtk_marshal_BOOLEAN__INT_INT_BOOLEAN_OBJECT (GClosure *closure,
762 GValue *return_value,
763 guint n_param_values,
764 const GValue *param_values,
765 gpointer invocation_hint G_GNUC_UNUSED,
766 gpointer marshal_data)
767 {
768 typedef gboolean (*GMarshalFunc_BOOLEAN__INT_INT_BOOLEAN_OBJECT) (gpointer data1,
769 gint arg1,
770 gint arg2,
771 gboolean arg3,
772 gpointer arg4,
773 gpointer data2);
774 GCClosure *cc = (GCClosure *) closure;
775 gpointer data1, data2;
776 GMarshalFunc_BOOLEAN__INT_INT_BOOLEAN_OBJECT callback;
777 gboolean v_return;
778
779 g_return_if_fail (return_value != NULL);
780 g_return_if_fail (n_param_values == 5);
781
782 if (G_CCLOSURE_SWAP_DATA (closure))
783 {
784 data1 = closure->data;
785 data2 = g_value_peek_pointer (param_values + 0);
786 }
787 else
788 {
789 data1 = g_value_peek_pointer (param_values + 0);
790 data2 = closure->data;
791 }
792 callback = (GMarshalFunc_BOOLEAN__INT_INT_BOOLEAN_OBJECT) (marshal_data ? marshal_data : cc->callback);
793
794 v_return = callback (data1,
795 g_marshal_value_peek_int (param_values + 1),
796 g_marshal_value_peek_int (param_values + 2),
797 g_marshal_value_peek_boolean (param_values + 3),
798 g_marshal_value_peek_object (param_values + 4),
799 data2);
800
801 g_value_set_boolean (return_value, v_return);
802 }
803
804 /* BOOLEAN:UINT (./gtkmarshalers.list:43) */
805 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)806 _gtk_marshal_BOOLEAN__UINT (GClosure *closure,
807 GValue *return_value,
808 guint n_param_values,
809 const GValue *param_values,
810 gpointer invocation_hint G_GNUC_UNUSED,
811 gpointer marshal_data)
812 {
813 typedef gboolean (*GMarshalFunc_BOOLEAN__UINT) (gpointer data1,
814 guint arg1,
815 gpointer data2);
816 GCClosure *cc = (GCClosure *) closure;
817 gpointer data1, data2;
818 GMarshalFunc_BOOLEAN__UINT callback;
819 gboolean v_return;
820
821 g_return_if_fail (return_value != NULL);
822 g_return_if_fail (n_param_values == 2);
823
824 if (G_CCLOSURE_SWAP_DATA (closure))
825 {
826 data1 = closure->data;
827 data2 = g_value_peek_pointer (param_values + 0);
828 }
829 else
830 {
831 data1 = g_value_peek_pointer (param_values + 0);
832 data2 = closure->data;
833 }
834 callback = (GMarshalFunc_BOOLEAN__UINT) (marshal_data ? marshal_data : cc->callback);
835
836 v_return = callback (data1,
837 g_marshal_value_peek_uint (param_values + 1),
838 data2);
839
840 g_value_set_boolean (return_value, v_return);
841 }
842
843 /* BOOLEAN:VOID (./gtkmarshalers.list:44) */
844 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)845 _gtk_marshal_BOOLEAN__VOID (GClosure *closure,
846 GValue *return_value,
847 guint n_param_values,
848 const GValue *param_values,
849 gpointer invocation_hint G_GNUC_UNUSED,
850 gpointer marshal_data)
851 {
852 typedef gboolean (*GMarshalFunc_BOOLEAN__VOID) (gpointer data1,
853 gpointer data2);
854 GCClosure *cc = (GCClosure *) closure;
855 gpointer data1, data2;
856 GMarshalFunc_BOOLEAN__VOID callback;
857 gboolean v_return;
858
859 g_return_if_fail (return_value != NULL);
860 g_return_if_fail (n_param_values == 1);
861
862 if (G_CCLOSURE_SWAP_DATA (closure))
863 {
864 data1 = closure->data;
865 data2 = g_value_peek_pointer (param_values + 0);
866 }
867 else
868 {
869 data1 = g_value_peek_pointer (param_values + 0);
870 data2 = closure->data;
871 }
872 callback = (GMarshalFunc_BOOLEAN__VOID) (marshal_data ? marshal_data : cc->callback);
873
874 v_return = callback (data1,
875 data2);
876
877 g_value_set_boolean (return_value, v_return);
878 }
879
880 /* BOOLEAN:BOOLEAN (./gtkmarshalers.list:45) */
881 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)882 _gtk_marshal_BOOLEAN__BOOLEAN (GClosure *closure,
883 GValue *return_value,
884 guint n_param_values,
885 const GValue *param_values,
886 gpointer invocation_hint G_GNUC_UNUSED,
887 gpointer marshal_data)
888 {
889 typedef gboolean (*GMarshalFunc_BOOLEAN__BOOLEAN) (gpointer data1,
890 gboolean arg1,
891 gpointer data2);
892 GCClosure *cc = (GCClosure *) closure;
893 gpointer data1, data2;
894 GMarshalFunc_BOOLEAN__BOOLEAN callback;
895 gboolean v_return;
896
897 g_return_if_fail (return_value != NULL);
898 g_return_if_fail (n_param_values == 2);
899
900 if (G_CCLOSURE_SWAP_DATA (closure))
901 {
902 data1 = closure->data;
903 data2 = g_value_peek_pointer (param_values + 0);
904 }
905 else
906 {
907 data1 = g_value_peek_pointer (param_values + 0);
908 data2 = closure->data;
909 }
910 callback = (GMarshalFunc_BOOLEAN__BOOLEAN) (marshal_data ? marshal_data : cc->callback);
911
912 v_return = callback (data1,
913 g_marshal_value_peek_boolean (param_values + 1),
914 data2);
915
916 g_value_set_boolean (return_value, v_return);
917 }
918
919 /* BOOLEAN:BOOLEAN,BOOLEAN,BOOLEAN (./gtkmarshalers.list:46) */
920 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)921 _gtk_marshal_BOOLEAN__BOOLEAN_BOOLEAN_BOOLEAN (GClosure *closure,
922 GValue *return_value,
923 guint n_param_values,
924 const GValue *param_values,
925 gpointer invocation_hint G_GNUC_UNUSED,
926 gpointer marshal_data)
927 {
928 typedef gboolean (*GMarshalFunc_BOOLEAN__BOOLEAN_BOOLEAN_BOOLEAN) (gpointer data1,
929 gboolean arg1,
930 gboolean arg2,
931 gboolean arg3,
932 gpointer data2);
933 GCClosure *cc = (GCClosure *) closure;
934 gpointer data1, data2;
935 GMarshalFunc_BOOLEAN__BOOLEAN_BOOLEAN_BOOLEAN callback;
936 gboolean v_return;
937
938 g_return_if_fail (return_value != NULL);
939 g_return_if_fail (n_param_values == 4);
940
941 if (G_CCLOSURE_SWAP_DATA (closure))
942 {
943 data1 = closure->data;
944 data2 = g_value_peek_pointer (param_values + 0);
945 }
946 else
947 {
948 data1 = g_value_peek_pointer (param_values + 0);
949 data2 = closure->data;
950 }
951 callback = (GMarshalFunc_BOOLEAN__BOOLEAN_BOOLEAN_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
952
953 v_return = callback (data1,
954 g_marshal_value_peek_boolean (param_values + 1),
955 g_marshal_value_peek_boolean (param_values + 2),
956 g_marshal_value_peek_boolean (param_values + 3),
957 data2);
958
959 g_value_set_boolean (return_value, v_return);
960 }
961
962 /* BOOLEAN:STRING (./gtkmarshalers.list:47) */
963 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)964 _gtk_marshal_BOOLEAN__STRING (GClosure *closure,
965 GValue *return_value,
966 guint n_param_values,
967 const GValue *param_values,
968 gpointer invocation_hint G_GNUC_UNUSED,
969 gpointer marshal_data)
970 {
971 typedef gboolean (*GMarshalFunc_BOOLEAN__STRING) (gpointer data1,
972 gpointer arg1,
973 gpointer data2);
974 GCClosure *cc = (GCClosure *) closure;
975 gpointer data1, data2;
976 GMarshalFunc_BOOLEAN__STRING callback;
977 gboolean v_return;
978
979 g_return_if_fail (return_value != NULL);
980 g_return_if_fail (n_param_values == 2);
981
982 if (G_CCLOSURE_SWAP_DATA (closure))
983 {
984 data1 = closure->data;
985 data2 = g_value_peek_pointer (param_values + 0);
986 }
987 else
988 {
989 data1 = g_value_peek_pointer (param_values + 0);
990 data2 = closure->data;
991 }
992 callback = (GMarshalFunc_BOOLEAN__STRING) (marshal_data ? marshal_data : cc->callback);
993
994 v_return = callback (data1,
995 g_marshal_value_peek_string (param_values + 1),
996 data2);
997
998 g_value_set_boolean (return_value, v_return);
999 }
1000
1001 /* ENUM:ENUM (./gtkmarshalers.list:48) */
1002 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)1003 _gtk_marshal_ENUM__ENUM (GClosure *closure,
1004 GValue *return_value,
1005 guint n_param_values,
1006 const GValue *param_values,
1007 gpointer invocation_hint G_GNUC_UNUSED,
1008 gpointer marshal_data)
1009 {
1010 typedef gint (*GMarshalFunc_ENUM__ENUM) (gpointer data1,
1011 gint arg1,
1012 gpointer data2);
1013 GCClosure *cc = (GCClosure *) closure;
1014 gpointer data1, data2;
1015 GMarshalFunc_ENUM__ENUM callback;
1016 gint v_return;
1017
1018 g_return_if_fail (return_value != NULL);
1019 g_return_if_fail (n_param_values == 2);
1020
1021 if (G_CCLOSURE_SWAP_DATA (closure))
1022 {
1023 data1 = closure->data;
1024 data2 = g_value_peek_pointer (param_values + 0);
1025 }
1026 else
1027 {
1028 data1 = g_value_peek_pointer (param_values + 0);
1029 data2 = closure->data;
1030 }
1031 callback = (GMarshalFunc_ENUM__ENUM) (marshal_data ? marshal_data : cc->callback);
1032
1033 v_return = callback (data1,
1034 g_marshal_value_peek_enum (param_values + 1),
1035 data2);
1036
1037 g_value_set_enum (return_value, v_return);
1038 }
1039
1040 /* ENUM:VOID (./gtkmarshalers.list:49) */
1041 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)1042 _gtk_marshal_ENUM__VOID (GClosure *closure,
1043 GValue *return_value,
1044 guint n_param_values,
1045 const GValue *param_values,
1046 gpointer invocation_hint G_GNUC_UNUSED,
1047 gpointer marshal_data)
1048 {
1049 typedef gint (*GMarshalFunc_ENUM__VOID) (gpointer data1,
1050 gpointer data2);
1051 GCClosure *cc = (GCClosure *) closure;
1052 gpointer data1, data2;
1053 GMarshalFunc_ENUM__VOID callback;
1054 gint v_return;
1055
1056 g_return_if_fail (return_value != NULL);
1057 g_return_if_fail (n_param_values == 1);
1058
1059 if (G_CCLOSURE_SWAP_DATA (closure))
1060 {
1061 data1 = closure->data;
1062 data2 = g_value_peek_pointer (param_values + 0);
1063 }
1064 else
1065 {
1066 data1 = g_value_peek_pointer (param_values + 0);
1067 data2 = closure->data;
1068 }
1069 callback = (GMarshalFunc_ENUM__VOID) (marshal_data ? marshal_data : cc->callback);
1070
1071 v_return = callback (data1,
1072 data2);
1073
1074 g_value_set_enum (return_value, v_return);
1075 }
1076
1077 /* INT:POINTER (./gtkmarshalers.list:50) */
1078 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)1079 _gtk_marshal_INT__POINTER (GClosure *closure,
1080 GValue *return_value,
1081 guint n_param_values,
1082 const GValue *param_values,
1083 gpointer invocation_hint G_GNUC_UNUSED,
1084 gpointer marshal_data)
1085 {
1086 typedef gint (*GMarshalFunc_INT__POINTER) (gpointer data1,
1087 gpointer arg1,
1088 gpointer data2);
1089 GCClosure *cc = (GCClosure *) closure;
1090 gpointer data1, data2;
1091 GMarshalFunc_INT__POINTER callback;
1092 gint v_return;
1093
1094 g_return_if_fail (return_value != NULL);
1095 g_return_if_fail (n_param_values == 2);
1096
1097 if (G_CCLOSURE_SWAP_DATA (closure))
1098 {
1099 data1 = closure->data;
1100 data2 = g_value_peek_pointer (param_values + 0);
1101 }
1102 else
1103 {
1104 data1 = g_value_peek_pointer (param_values + 0);
1105 data2 = closure->data;
1106 }
1107 callback = (GMarshalFunc_INT__POINTER) (marshal_data ? marshal_data : cc->callback);
1108
1109 v_return = callback (data1,
1110 g_marshal_value_peek_pointer (param_values + 1),
1111 data2);
1112
1113 g_value_set_int (return_value, v_return);
1114 }
1115
1116 /* OBJECT:VOID (./gtkmarshalers.list:51) */
1117 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)1118 _gtk_marshal_OBJECT__VOID (GClosure *closure,
1119 GValue *return_value,
1120 guint n_param_values,
1121 const GValue *param_values,
1122 gpointer invocation_hint G_GNUC_UNUSED,
1123 gpointer marshal_data)
1124 {
1125 typedef GObject* (*GMarshalFunc_OBJECT__VOID) (gpointer data1,
1126 gpointer data2);
1127 GCClosure *cc = (GCClosure *) closure;
1128 gpointer data1, data2;
1129 GMarshalFunc_OBJECT__VOID callback;
1130 GObject* v_return;
1131
1132 g_return_if_fail (return_value != NULL);
1133 g_return_if_fail (n_param_values == 1);
1134
1135 if (G_CCLOSURE_SWAP_DATA (closure))
1136 {
1137 data1 = closure->data;
1138 data2 = g_value_peek_pointer (param_values + 0);
1139 }
1140 else
1141 {
1142 data1 = g_value_peek_pointer (param_values + 0);
1143 data2 = closure->data;
1144 }
1145 callback = (GMarshalFunc_OBJECT__VOID) (marshal_data ? marshal_data : cc->callback);
1146
1147 v_return = callback (data1,
1148 data2);
1149
1150 g_value_take_object (return_value, v_return);
1151 }
1152
1153 /* STRING:DOUBLE (./gtkmarshalers.list:52) */
1154 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)1155 _gtk_marshal_STRING__DOUBLE (GClosure *closure,
1156 GValue *return_value,
1157 guint n_param_values,
1158 const GValue *param_values,
1159 gpointer invocation_hint G_GNUC_UNUSED,
1160 gpointer marshal_data)
1161 {
1162 typedef gchar* (*GMarshalFunc_STRING__DOUBLE) (gpointer data1,
1163 gdouble arg1,
1164 gpointer data2);
1165 GCClosure *cc = (GCClosure *) closure;
1166 gpointer data1, data2;
1167 GMarshalFunc_STRING__DOUBLE callback;
1168 gchar* v_return;
1169
1170 g_return_if_fail (return_value != NULL);
1171 g_return_if_fail (n_param_values == 2);
1172
1173 if (G_CCLOSURE_SWAP_DATA (closure))
1174 {
1175 data1 = closure->data;
1176 data2 = g_value_peek_pointer (param_values + 0);
1177 }
1178 else
1179 {
1180 data1 = g_value_peek_pointer (param_values + 0);
1181 data2 = closure->data;
1182 }
1183 callback = (GMarshalFunc_STRING__DOUBLE) (marshal_data ? marshal_data : cc->callback);
1184
1185 v_return = callback (data1,
1186 g_marshal_value_peek_double (param_values + 1),
1187 data2);
1188
1189 g_value_take_string (return_value, v_return);
1190 }
1191
1192 /* VOID:BOOLEAN,BOOLEAN,BOOLEAN (./gtkmarshalers.list:55) */
1193 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)1194 _gtk_marshal_VOID__BOOLEAN_BOOLEAN_BOOLEAN (GClosure *closure,
1195 GValue *return_value G_GNUC_UNUSED,
1196 guint n_param_values,
1197 const GValue *param_values,
1198 gpointer invocation_hint G_GNUC_UNUSED,
1199 gpointer marshal_data)
1200 {
1201 typedef void (*GMarshalFunc_VOID__BOOLEAN_BOOLEAN_BOOLEAN) (gpointer data1,
1202 gboolean arg1,
1203 gboolean arg2,
1204 gboolean arg3,
1205 gpointer data2);
1206 GCClosure *cc = (GCClosure *) closure;
1207 gpointer data1, data2;
1208 GMarshalFunc_VOID__BOOLEAN_BOOLEAN_BOOLEAN callback;
1209
1210 g_return_if_fail (n_param_values == 4);
1211
1212 if (G_CCLOSURE_SWAP_DATA (closure))
1213 {
1214 data1 = closure->data;
1215 data2 = g_value_peek_pointer (param_values + 0);
1216 }
1217 else
1218 {
1219 data1 = g_value_peek_pointer (param_values + 0);
1220 data2 = closure->data;
1221 }
1222 callback = (GMarshalFunc_VOID__BOOLEAN_BOOLEAN_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
1223
1224 callback (data1,
1225 g_marshal_value_peek_boolean (param_values + 1),
1226 g_marshal_value_peek_boolean (param_values + 2),
1227 g_marshal_value_peek_boolean (param_values + 3),
1228 data2);
1229 }
1230
1231 /* VOID:BOXED,BOXED (./gtkmarshalers.list:57) */
1232 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)1233 _gtk_marshal_VOID__BOXED_BOXED (GClosure *closure,
1234 GValue *return_value G_GNUC_UNUSED,
1235 guint n_param_values,
1236 const GValue *param_values,
1237 gpointer invocation_hint G_GNUC_UNUSED,
1238 gpointer marshal_data)
1239 {
1240 typedef void (*GMarshalFunc_VOID__BOXED_BOXED) (gpointer data1,
1241 gpointer arg1,
1242 gpointer arg2,
1243 gpointer data2);
1244 GCClosure *cc = (GCClosure *) closure;
1245 gpointer data1, data2;
1246 GMarshalFunc_VOID__BOXED_BOXED callback;
1247
1248 g_return_if_fail (n_param_values == 3);
1249
1250 if (G_CCLOSURE_SWAP_DATA (closure))
1251 {
1252 data1 = closure->data;
1253 data2 = g_value_peek_pointer (param_values + 0);
1254 }
1255 else
1256 {
1257 data1 = g_value_peek_pointer (param_values + 0);
1258 data2 = closure->data;
1259 }
1260 callback = (GMarshalFunc_VOID__BOXED_BOXED) (marshal_data ? marshal_data : cc->callback);
1261
1262 callback (data1,
1263 g_marshal_value_peek_boxed (param_values + 1),
1264 g_marshal_value_peek_boxed (param_values + 2),
1265 data2);
1266 }
1267
1268 /* VOID:BOXED,BOXED,POINTER (./gtkmarshalers.list:58) */
1269 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)1270 _gtk_marshal_VOID__BOXED_BOXED_POINTER (GClosure *closure,
1271 GValue *return_value G_GNUC_UNUSED,
1272 guint n_param_values,
1273 const GValue *param_values,
1274 gpointer invocation_hint G_GNUC_UNUSED,
1275 gpointer marshal_data)
1276 {
1277 typedef void (*GMarshalFunc_VOID__BOXED_BOXED_POINTER) (gpointer data1,
1278 gpointer arg1,
1279 gpointer arg2,
1280 gpointer arg3,
1281 gpointer data2);
1282 GCClosure *cc = (GCClosure *) closure;
1283 gpointer data1, data2;
1284 GMarshalFunc_VOID__BOXED_BOXED_POINTER callback;
1285
1286 g_return_if_fail (n_param_values == 4);
1287
1288 if (G_CCLOSURE_SWAP_DATA (closure))
1289 {
1290 data1 = closure->data;
1291 data2 = g_value_peek_pointer (param_values + 0);
1292 }
1293 else
1294 {
1295 data1 = g_value_peek_pointer (param_values + 0);
1296 data2 = closure->data;
1297 }
1298 callback = (GMarshalFunc_VOID__BOXED_BOXED_POINTER) (marshal_data ? marshal_data : cc->callback);
1299
1300 callback (data1,
1301 g_marshal_value_peek_boxed (param_values + 1),
1302 g_marshal_value_peek_boxed (param_values + 2),
1303 g_marshal_value_peek_pointer (param_values + 3),
1304 data2);
1305 }
1306
1307 /* VOID:BOXED,OBJECT (./gtkmarshalers.list:59) */
1308 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)1309 _gtk_marshal_VOID__BOXED_OBJECT (GClosure *closure,
1310 GValue *return_value G_GNUC_UNUSED,
1311 guint n_param_values,
1312 const GValue *param_values,
1313 gpointer invocation_hint G_GNUC_UNUSED,
1314 gpointer marshal_data)
1315 {
1316 typedef void (*GMarshalFunc_VOID__BOXED_OBJECT) (gpointer data1,
1317 gpointer arg1,
1318 gpointer arg2,
1319 gpointer data2);
1320 GCClosure *cc = (GCClosure *) closure;
1321 gpointer data1, data2;
1322 GMarshalFunc_VOID__BOXED_OBJECT callback;
1323
1324 g_return_if_fail (n_param_values == 3);
1325
1326 if (G_CCLOSURE_SWAP_DATA (closure))
1327 {
1328 data1 = closure->data;
1329 data2 = g_value_peek_pointer (param_values + 0);
1330 }
1331 else
1332 {
1333 data1 = g_value_peek_pointer (param_values + 0);
1334 data2 = closure->data;
1335 }
1336 callback = (GMarshalFunc_VOID__BOXED_OBJECT) (marshal_data ? marshal_data : cc->callback);
1337
1338 callback (data1,
1339 g_marshal_value_peek_boxed (param_values + 1),
1340 g_marshal_value_peek_object (param_values + 2),
1341 data2);
1342 }
1343
1344 /* VOID:BOXED,STRING,INT (./gtkmarshalers.list:60) */
1345 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)1346 _gtk_marshal_VOID__BOXED_STRING_INT (GClosure *closure,
1347 GValue *return_value G_GNUC_UNUSED,
1348 guint n_param_values,
1349 const GValue *param_values,
1350 gpointer invocation_hint G_GNUC_UNUSED,
1351 gpointer marshal_data)
1352 {
1353 typedef void (*GMarshalFunc_VOID__BOXED_STRING_INT) (gpointer data1,
1354 gpointer arg1,
1355 gpointer arg2,
1356 gint arg3,
1357 gpointer data2);
1358 GCClosure *cc = (GCClosure *) closure;
1359 gpointer data1, data2;
1360 GMarshalFunc_VOID__BOXED_STRING_INT callback;
1361
1362 g_return_if_fail (n_param_values == 4);
1363
1364 if (G_CCLOSURE_SWAP_DATA (closure))
1365 {
1366 data1 = closure->data;
1367 data2 = g_value_peek_pointer (param_values + 0);
1368 }
1369 else
1370 {
1371 data1 = g_value_peek_pointer (param_values + 0);
1372 data2 = closure->data;
1373 }
1374 callback = (GMarshalFunc_VOID__BOXED_STRING_INT) (marshal_data ? marshal_data : cc->callback);
1375
1376 callback (data1,
1377 g_marshal_value_peek_boxed (param_values + 1),
1378 g_marshal_value_peek_string (param_values + 2),
1379 g_marshal_value_peek_int (param_values + 3),
1380 data2);
1381 }
1382
1383 /* VOID:BOXED,UINT (./gtkmarshalers.list:61) */
1384 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)1385 _gtk_marshal_VOID__BOXED_UINT (GClosure *closure,
1386 GValue *return_value G_GNUC_UNUSED,
1387 guint n_param_values,
1388 const GValue *param_values,
1389 gpointer invocation_hint G_GNUC_UNUSED,
1390 gpointer marshal_data)
1391 {
1392 typedef void (*GMarshalFunc_VOID__BOXED_UINT) (gpointer data1,
1393 gpointer arg1,
1394 guint arg2,
1395 gpointer data2);
1396 GCClosure *cc = (GCClosure *) closure;
1397 gpointer data1, data2;
1398 GMarshalFunc_VOID__BOXED_UINT callback;
1399
1400 g_return_if_fail (n_param_values == 3);
1401
1402 if (G_CCLOSURE_SWAP_DATA (closure))
1403 {
1404 data1 = closure->data;
1405 data2 = g_value_peek_pointer (param_values + 0);
1406 }
1407 else
1408 {
1409 data1 = g_value_peek_pointer (param_values + 0);
1410 data2 = closure->data;
1411 }
1412 callback = (GMarshalFunc_VOID__BOXED_UINT) (marshal_data ? marshal_data : cc->callback);
1413
1414 callback (data1,
1415 g_marshal_value_peek_boxed (param_values + 1),
1416 g_marshal_value_peek_uint (param_values + 2),
1417 data2);
1418 }
1419
1420 /* VOID:BOXED,UINT,FLAGS (./gtkmarshalers.list:62) */
1421 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)1422 _gtk_marshal_VOID__BOXED_UINT_FLAGS (GClosure *closure,
1423 GValue *return_value G_GNUC_UNUSED,
1424 guint n_param_values,
1425 const GValue *param_values,
1426 gpointer invocation_hint G_GNUC_UNUSED,
1427 gpointer marshal_data)
1428 {
1429 typedef void (*GMarshalFunc_VOID__BOXED_UINT_FLAGS) (gpointer data1,
1430 gpointer arg1,
1431 guint arg2,
1432 guint arg3,
1433 gpointer data2);
1434 GCClosure *cc = (GCClosure *) closure;
1435 gpointer data1, data2;
1436 GMarshalFunc_VOID__BOXED_UINT_FLAGS callback;
1437
1438 g_return_if_fail (n_param_values == 4);
1439
1440 if (G_CCLOSURE_SWAP_DATA (closure))
1441 {
1442 data1 = closure->data;
1443 data2 = g_value_peek_pointer (param_values + 0);
1444 }
1445 else
1446 {
1447 data1 = g_value_peek_pointer (param_values + 0);
1448 data2 = closure->data;
1449 }
1450 callback = (GMarshalFunc_VOID__BOXED_UINT_FLAGS) (marshal_data ? marshal_data : cc->callback);
1451
1452 callback (data1,
1453 g_marshal_value_peek_boxed (param_values + 1),
1454 g_marshal_value_peek_uint (param_values + 2),
1455 g_marshal_value_peek_flags (param_values + 3),
1456 data2);
1457 }
1458
1459 /* VOID:BOXED,UINT,UINT (./gtkmarshalers.list:63) */
1460 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)1461 _gtk_marshal_VOID__BOXED_UINT_UINT (GClosure *closure,
1462 GValue *return_value G_GNUC_UNUSED,
1463 guint n_param_values,
1464 const GValue *param_values,
1465 gpointer invocation_hint G_GNUC_UNUSED,
1466 gpointer marshal_data)
1467 {
1468 typedef void (*GMarshalFunc_VOID__BOXED_UINT_UINT) (gpointer data1,
1469 gpointer arg1,
1470 guint arg2,
1471 guint arg3,
1472 gpointer data2);
1473 GCClosure *cc = (GCClosure *) closure;
1474 gpointer data1, data2;
1475 GMarshalFunc_VOID__BOXED_UINT_UINT callback;
1476
1477 g_return_if_fail (n_param_values == 4);
1478
1479 if (G_CCLOSURE_SWAP_DATA (closure))
1480 {
1481 data1 = closure->data;
1482 data2 = g_value_peek_pointer (param_values + 0);
1483 }
1484 else
1485 {
1486 data1 = g_value_peek_pointer (param_values + 0);
1487 data2 = closure->data;
1488 }
1489 callback = (GMarshalFunc_VOID__BOXED_UINT_UINT) (marshal_data ? marshal_data : cc->callback);
1490
1491 callback (data1,
1492 g_marshal_value_peek_boxed (param_values + 1),
1493 g_marshal_value_peek_uint (param_values + 2),
1494 g_marshal_value_peek_uint (param_values + 3),
1495 data2);
1496 }
1497
1498 /* VOID:ENUM,BOOLEAN (./gtkmarshalers.list:65) */
1499 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)1500 _gtk_marshal_VOID__ENUM_BOOLEAN (GClosure *closure,
1501 GValue *return_value G_GNUC_UNUSED,
1502 guint n_param_values,
1503 const GValue *param_values,
1504 gpointer invocation_hint G_GNUC_UNUSED,
1505 gpointer marshal_data)
1506 {
1507 typedef void (*GMarshalFunc_VOID__ENUM_BOOLEAN) (gpointer data1,
1508 gint arg1,
1509 gboolean arg2,
1510 gpointer data2);
1511 GCClosure *cc = (GCClosure *) closure;
1512 gpointer data1, data2;
1513 GMarshalFunc_VOID__ENUM_BOOLEAN callback;
1514
1515 g_return_if_fail (n_param_values == 3);
1516
1517 if (G_CCLOSURE_SWAP_DATA (closure))
1518 {
1519 data1 = closure->data;
1520 data2 = g_value_peek_pointer (param_values + 0);
1521 }
1522 else
1523 {
1524 data1 = g_value_peek_pointer (param_values + 0);
1525 data2 = closure->data;
1526 }
1527 callback = (GMarshalFunc_VOID__ENUM_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
1528
1529 callback (data1,
1530 g_marshal_value_peek_enum (param_values + 1),
1531 g_marshal_value_peek_boolean (param_values + 2),
1532 data2);
1533 }
1534
1535 /* VOID:ENUM,ENUM (./gtkmarshalers.list:66) */
1536 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)1537 _gtk_marshal_VOID__ENUM_ENUM (GClosure *closure,
1538 GValue *return_value G_GNUC_UNUSED,
1539 guint n_param_values,
1540 const GValue *param_values,
1541 gpointer invocation_hint G_GNUC_UNUSED,
1542 gpointer marshal_data)
1543 {
1544 typedef void (*GMarshalFunc_VOID__ENUM_ENUM) (gpointer data1,
1545 gint arg1,
1546 gint arg2,
1547 gpointer data2);
1548 GCClosure *cc = (GCClosure *) closure;
1549 gpointer data1, data2;
1550 GMarshalFunc_VOID__ENUM_ENUM callback;
1551
1552 g_return_if_fail (n_param_values == 3);
1553
1554 if (G_CCLOSURE_SWAP_DATA (closure))
1555 {
1556 data1 = closure->data;
1557 data2 = g_value_peek_pointer (param_values + 0);
1558 }
1559 else
1560 {
1561 data1 = g_value_peek_pointer (param_values + 0);
1562 data2 = closure->data;
1563 }
1564 callback = (GMarshalFunc_VOID__ENUM_ENUM) (marshal_data ? marshal_data : cc->callback);
1565
1566 callback (data1,
1567 g_marshal_value_peek_enum (param_values + 1),
1568 g_marshal_value_peek_enum (param_values + 2),
1569 data2);
1570 }
1571
1572 /* VOID:ENUM,FLOAT (./gtkmarshalers.list:67) */
1573 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)1574 _gtk_marshal_VOID__ENUM_FLOAT (GClosure *closure,
1575 GValue *return_value G_GNUC_UNUSED,
1576 guint n_param_values,
1577 const GValue *param_values,
1578 gpointer invocation_hint G_GNUC_UNUSED,
1579 gpointer marshal_data)
1580 {
1581 typedef void (*GMarshalFunc_VOID__ENUM_FLOAT) (gpointer data1,
1582 gint arg1,
1583 gfloat arg2,
1584 gpointer data2);
1585 GCClosure *cc = (GCClosure *) closure;
1586 gpointer data1, data2;
1587 GMarshalFunc_VOID__ENUM_FLOAT callback;
1588
1589 g_return_if_fail (n_param_values == 3);
1590
1591 if (G_CCLOSURE_SWAP_DATA (closure))
1592 {
1593 data1 = closure->data;
1594 data2 = g_value_peek_pointer (param_values + 0);
1595 }
1596 else
1597 {
1598 data1 = g_value_peek_pointer (param_values + 0);
1599 data2 = closure->data;
1600 }
1601 callback = (GMarshalFunc_VOID__ENUM_FLOAT) (marshal_data ? marshal_data : cc->callback);
1602
1603 callback (data1,
1604 g_marshal_value_peek_enum (param_values + 1),
1605 g_marshal_value_peek_float (param_values + 2),
1606 data2);
1607 }
1608
1609 /* VOID:ENUM,FLOAT,BOOLEAN (./gtkmarshalers.list:68) */
1610 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)1611 _gtk_marshal_VOID__ENUM_FLOAT_BOOLEAN (GClosure *closure,
1612 GValue *return_value G_GNUC_UNUSED,
1613 guint n_param_values,
1614 const GValue *param_values,
1615 gpointer invocation_hint G_GNUC_UNUSED,
1616 gpointer marshal_data)
1617 {
1618 typedef void (*GMarshalFunc_VOID__ENUM_FLOAT_BOOLEAN) (gpointer data1,
1619 gint arg1,
1620 gfloat arg2,
1621 gboolean arg3,
1622 gpointer data2);
1623 GCClosure *cc = (GCClosure *) closure;
1624 gpointer data1, data2;
1625 GMarshalFunc_VOID__ENUM_FLOAT_BOOLEAN callback;
1626
1627 g_return_if_fail (n_param_values == 4);
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_VOID__ENUM_FLOAT_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
1640
1641 callback (data1,
1642 g_marshal_value_peek_enum (param_values + 1),
1643 g_marshal_value_peek_float (param_values + 2),
1644 g_marshal_value_peek_boolean (param_values + 3),
1645 data2);
1646 }
1647
1648 /* VOID:ENUM,INT (./gtkmarshalers.list:69) */
1649 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)1650 _gtk_marshal_VOID__ENUM_INT (GClosure *closure,
1651 GValue *return_value G_GNUC_UNUSED,
1652 guint n_param_values,
1653 const GValue *param_values,
1654 gpointer invocation_hint G_GNUC_UNUSED,
1655 gpointer marshal_data)
1656 {
1657 typedef void (*GMarshalFunc_VOID__ENUM_INT) (gpointer data1,
1658 gint arg1,
1659 gint arg2,
1660 gpointer data2);
1661 GCClosure *cc = (GCClosure *) closure;
1662 gpointer data1, data2;
1663 GMarshalFunc_VOID__ENUM_INT callback;
1664
1665 g_return_if_fail (n_param_values == 3);
1666
1667 if (G_CCLOSURE_SWAP_DATA (closure))
1668 {
1669 data1 = closure->data;
1670 data2 = g_value_peek_pointer (param_values + 0);
1671 }
1672 else
1673 {
1674 data1 = g_value_peek_pointer (param_values + 0);
1675 data2 = closure->data;
1676 }
1677 callback = (GMarshalFunc_VOID__ENUM_INT) (marshal_data ? marshal_data : cc->callback);
1678
1679 callback (data1,
1680 g_marshal_value_peek_enum (param_values + 1),
1681 g_marshal_value_peek_int (param_values + 2),
1682 data2);
1683 }
1684
1685 /* VOID:ENUM,INT,BOOLEAN (./gtkmarshalers.list:70) */
1686 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)1687 _gtk_marshal_VOID__ENUM_INT_BOOLEAN (GClosure *closure,
1688 GValue *return_value G_GNUC_UNUSED,
1689 guint n_param_values,
1690 const GValue *param_values,
1691 gpointer invocation_hint G_GNUC_UNUSED,
1692 gpointer marshal_data)
1693 {
1694 typedef void (*GMarshalFunc_VOID__ENUM_INT_BOOLEAN) (gpointer data1,
1695 gint arg1,
1696 gint arg2,
1697 gboolean arg3,
1698 gpointer data2);
1699 GCClosure *cc = (GCClosure *) closure;
1700 gpointer data1, data2;
1701 GMarshalFunc_VOID__ENUM_INT_BOOLEAN callback;
1702
1703 g_return_if_fail (n_param_values == 4);
1704
1705 if (G_CCLOSURE_SWAP_DATA (closure))
1706 {
1707 data1 = closure->data;
1708 data2 = g_value_peek_pointer (param_values + 0);
1709 }
1710 else
1711 {
1712 data1 = g_value_peek_pointer (param_values + 0);
1713 data2 = closure->data;
1714 }
1715 callback = (GMarshalFunc_VOID__ENUM_INT_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
1716
1717 callback (data1,
1718 g_marshal_value_peek_enum (param_values + 1),
1719 g_marshal_value_peek_int (param_values + 2),
1720 g_marshal_value_peek_boolean (param_values + 3),
1721 data2);
1722 }
1723
1724 /* VOID:ENUM,BOXED (./gtkmarshalers.list:71) */
1725 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)1726 _gtk_marshal_VOID__ENUM_BOXED (GClosure *closure,
1727 GValue *return_value G_GNUC_UNUSED,
1728 guint n_param_values,
1729 const GValue *param_values,
1730 gpointer invocation_hint G_GNUC_UNUSED,
1731 gpointer marshal_data)
1732 {
1733 typedef void (*GMarshalFunc_VOID__ENUM_BOXED) (gpointer data1,
1734 gint arg1,
1735 gpointer arg2,
1736 gpointer data2);
1737 GCClosure *cc = (GCClosure *) closure;
1738 gpointer data1, data2;
1739 GMarshalFunc_VOID__ENUM_BOXED callback;
1740
1741 g_return_if_fail (n_param_values == 3);
1742
1743 if (G_CCLOSURE_SWAP_DATA (closure))
1744 {
1745 data1 = closure->data;
1746 data2 = g_value_peek_pointer (param_values + 0);
1747 }
1748 else
1749 {
1750 data1 = g_value_peek_pointer (param_values + 0);
1751 data2 = closure->data;
1752 }
1753 callback = (GMarshalFunc_VOID__ENUM_BOXED) (marshal_data ? marshal_data : cc->callback);
1754
1755 callback (data1,
1756 g_marshal_value_peek_enum (param_values + 1),
1757 g_marshal_value_peek_boxed (param_values + 2),
1758 data2);
1759 }
1760
1761 /* VOID:INT,BOOLEAN (./gtkmarshalers.list:73) */
1762 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)1763 _gtk_marshal_VOID__INT_BOOLEAN (GClosure *closure,
1764 GValue *return_value G_GNUC_UNUSED,
1765 guint n_param_values,
1766 const GValue *param_values,
1767 gpointer invocation_hint G_GNUC_UNUSED,
1768 gpointer marshal_data)
1769 {
1770 typedef void (*GMarshalFunc_VOID__INT_BOOLEAN) (gpointer data1,
1771 gint arg1,
1772 gboolean arg2,
1773 gpointer data2);
1774 GCClosure *cc = (GCClosure *) closure;
1775 gpointer data1, data2;
1776 GMarshalFunc_VOID__INT_BOOLEAN callback;
1777
1778 g_return_if_fail (n_param_values == 3);
1779
1780 if (G_CCLOSURE_SWAP_DATA (closure))
1781 {
1782 data1 = closure->data;
1783 data2 = g_value_peek_pointer (param_values + 0);
1784 }
1785 else
1786 {
1787 data1 = g_value_peek_pointer (param_values + 0);
1788 data2 = closure->data;
1789 }
1790 callback = (GMarshalFunc_VOID__INT_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
1791
1792 callback (data1,
1793 g_marshal_value_peek_int (param_values + 1),
1794 g_marshal_value_peek_boolean (param_values + 2),
1795 data2);
1796 }
1797
1798 /* VOID:INT,INT (./gtkmarshalers.list:74) */
1799 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)1800 _gtk_marshal_VOID__INT_INT (GClosure *closure,
1801 GValue *return_value G_GNUC_UNUSED,
1802 guint n_param_values,
1803 const GValue *param_values,
1804 gpointer invocation_hint G_GNUC_UNUSED,
1805 gpointer marshal_data)
1806 {
1807 typedef void (*GMarshalFunc_VOID__INT_INT) (gpointer data1,
1808 gint arg1,
1809 gint arg2,
1810 gpointer data2);
1811 GCClosure *cc = (GCClosure *) closure;
1812 gpointer data1, data2;
1813 GMarshalFunc_VOID__INT_INT callback;
1814
1815 g_return_if_fail (n_param_values == 3);
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_VOID__INT_INT) (marshal_data ? marshal_data : cc->callback);
1828
1829 callback (data1,
1830 g_marshal_value_peek_int (param_values + 1),
1831 g_marshal_value_peek_int (param_values + 2),
1832 data2);
1833 }
1834
1835 /* VOID:INT,INT,BOXED (./gtkmarshalers.list:75) */
1836 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)1837 _gtk_marshal_VOID__INT_INT_BOXED (GClosure *closure,
1838 GValue *return_value G_GNUC_UNUSED,
1839 guint n_param_values,
1840 const GValue *param_values,
1841 gpointer invocation_hint G_GNUC_UNUSED,
1842 gpointer marshal_data)
1843 {
1844 typedef void (*GMarshalFunc_VOID__INT_INT_BOXED) (gpointer data1,
1845 gint arg1,
1846 gint arg2,
1847 gpointer arg3,
1848 gpointer data2);
1849 GCClosure *cc = (GCClosure *) closure;
1850 gpointer data1, data2;
1851 GMarshalFunc_VOID__INT_INT_BOXED callback;
1852
1853 g_return_if_fail (n_param_values == 4);
1854
1855 if (G_CCLOSURE_SWAP_DATA (closure))
1856 {
1857 data1 = closure->data;
1858 data2 = g_value_peek_pointer (param_values + 0);
1859 }
1860 else
1861 {
1862 data1 = g_value_peek_pointer (param_values + 0);
1863 data2 = closure->data;
1864 }
1865 callback = (GMarshalFunc_VOID__INT_INT_BOXED) (marshal_data ? marshal_data : cc->callback);
1866
1867 callback (data1,
1868 g_marshal_value_peek_int (param_values + 1),
1869 g_marshal_value_peek_int (param_values + 2),
1870 g_marshal_value_peek_boxed (param_values + 3),
1871 data2);
1872 }
1873
1874 /* VOID:INT,INT,INT (./gtkmarshalers.list:76) */
1875 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)1876 _gtk_marshal_VOID__INT_INT_INT (GClosure *closure,
1877 GValue *return_value G_GNUC_UNUSED,
1878 guint n_param_values,
1879 const GValue *param_values,
1880 gpointer invocation_hint G_GNUC_UNUSED,
1881 gpointer marshal_data)
1882 {
1883 typedef void (*GMarshalFunc_VOID__INT_INT_INT) (gpointer data1,
1884 gint arg1,
1885 gint arg2,
1886 gint arg3,
1887 gpointer data2);
1888 GCClosure *cc = (GCClosure *) closure;
1889 gpointer data1, data2;
1890 GMarshalFunc_VOID__INT_INT_INT callback;
1891
1892 g_return_if_fail (n_param_values == 4);
1893
1894 if (G_CCLOSURE_SWAP_DATA (closure))
1895 {
1896 data1 = closure->data;
1897 data2 = g_value_peek_pointer (param_values + 0);
1898 }
1899 else
1900 {
1901 data1 = g_value_peek_pointer (param_values + 0);
1902 data2 = closure->data;
1903 }
1904 callback = (GMarshalFunc_VOID__INT_INT_INT) (marshal_data ? marshal_data : cc->callback);
1905
1906 callback (data1,
1907 g_marshal_value_peek_int (param_values + 1),
1908 g_marshal_value_peek_int (param_values + 2),
1909 g_marshal_value_peek_int (param_values + 3),
1910 data2);
1911 }
1912
1913 /* VOID:OBJECT,BOOLEAN (./gtkmarshalers.list:78) */
1914 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)1915 _gtk_marshal_VOID__OBJECT_BOOLEAN (GClosure *closure,
1916 GValue *return_value G_GNUC_UNUSED,
1917 guint n_param_values,
1918 const GValue *param_values,
1919 gpointer invocation_hint G_GNUC_UNUSED,
1920 gpointer marshal_data)
1921 {
1922 typedef void (*GMarshalFunc_VOID__OBJECT_BOOLEAN) (gpointer data1,
1923 gpointer arg1,
1924 gboolean arg2,
1925 gpointer data2);
1926 GCClosure *cc = (GCClosure *) closure;
1927 gpointer data1, data2;
1928 GMarshalFunc_VOID__OBJECT_BOOLEAN callback;
1929
1930 g_return_if_fail (n_param_values == 3);
1931
1932 if (G_CCLOSURE_SWAP_DATA (closure))
1933 {
1934 data1 = closure->data;
1935 data2 = g_value_peek_pointer (param_values + 0);
1936 }
1937 else
1938 {
1939 data1 = g_value_peek_pointer (param_values + 0);
1940 data2 = closure->data;
1941 }
1942 callback = (GMarshalFunc_VOID__OBJECT_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
1943
1944 callback (data1,
1945 g_marshal_value_peek_object (param_values + 1),
1946 g_marshal_value_peek_boolean (param_values + 2),
1947 data2);
1948 }
1949
1950 /* VOID:OBJECT,BOXED,BOXED (./gtkmarshalers.list:79) */
1951 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)1952 _gtk_marshal_VOID__OBJECT_BOXED_BOXED (GClosure *closure,
1953 GValue *return_value G_GNUC_UNUSED,
1954 guint n_param_values,
1955 const GValue *param_values,
1956 gpointer invocation_hint G_GNUC_UNUSED,
1957 gpointer marshal_data)
1958 {
1959 typedef void (*GMarshalFunc_VOID__OBJECT_BOXED_BOXED) (gpointer data1,
1960 gpointer arg1,
1961 gpointer arg2,
1962 gpointer arg3,
1963 gpointer data2);
1964 GCClosure *cc = (GCClosure *) closure;
1965 gpointer data1, data2;
1966 GMarshalFunc_VOID__OBJECT_BOXED_BOXED callback;
1967
1968 g_return_if_fail (n_param_values == 4);
1969
1970 if (G_CCLOSURE_SWAP_DATA (closure))
1971 {
1972 data1 = closure->data;
1973 data2 = g_value_peek_pointer (param_values + 0);
1974 }
1975 else
1976 {
1977 data1 = g_value_peek_pointer (param_values + 0);
1978 data2 = closure->data;
1979 }
1980 callback = (GMarshalFunc_VOID__OBJECT_BOXED_BOXED) (marshal_data ? marshal_data : cc->callback);
1981
1982 callback (data1,
1983 g_marshal_value_peek_object (param_values + 1),
1984 g_marshal_value_peek_boxed (param_values + 2),
1985 g_marshal_value_peek_boxed (param_values + 3),
1986 data2);
1987 }
1988
1989 /* VOID:OBJECT,BOXED,UINT,UINT (./gtkmarshalers.list:80) */
1990 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)1991 _gtk_marshal_VOID__OBJECT_BOXED_UINT_UINT (GClosure *closure,
1992 GValue *return_value G_GNUC_UNUSED,
1993 guint n_param_values,
1994 const GValue *param_values,
1995 gpointer invocation_hint G_GNUC_UNUSED,
1996 gpointer marshal_data)
1997 {
1998 typedef void (*GMarshalFunc_VOID__OBJECT_BOXED_UINT_UINT) (gpointer data1,
1999 gpointer arg1,
2000 gpointer arg2,
2001 guint arg3,
2002 guint arg4,
2003 gpointer data2);
2004 GCClosure *cc = (GCClosure *) closure;
2005 gpointer data1, data2;
2006 GMarshalFunc_VOID__OBJECT_BOXED_UINT_UINT callback;
2007
2008 g_return_if_fail (n_param_values == 5);
2009
2010 if (G_CCLOSURE_SWAP_DATA (closure))
2011 {
2012 data1 = closure->data;
2013 data2 = g_value_peek_pointer (param_values + 0);
2014 }
2015 else
2016 {
2017 data1 = g_value_peek_pointer (param_values + 0);
2018 data2 = closure->data;
2019 }
2020 callback = (GMarshalFunc_VOID__OBJECT_BOXED_UINT_UINT) (marshal_data ? marshal_data : cc->callback);
2021
2022 callback (data1,
2023 g_marshal_value_peek_object (param_values + 1),
2024 g_marshal_value_peek_boxed (param_values + 2),
2025 g_marshal_value_peek_uint (param_values + 3),
2026 g_marshal_value_peek_uint (param_values + 4),
2027 data2);
2028 }
2029
2030 /* VOID:OBJECT,INT (./gtkmarshalers.list:81) */
2031 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)2032 _gtk_marshal_VOID__OBJECT_INT (GClosure *closure,
2033 GValue *return_value G_GNUC_UNUSED,
2034 guint n_param_values,
2035 const GValue *param_values,
2036 gpointer invocation_hint G_GNUC_UNUSED,
2037 gpointer marshal_data)
2038 {
2039 typedef void (*GMarshalFunc_VOID__OBJECT_INT) (gpointer data1,
2040 gpointer arg1,
2041 gint arg2,
2042 gpointer data2);
2043 GCClosure *cc = (GCClosure *) closure;
2044 gpointer data1, data2;
2045 GMarshalFunc_VOID__OBJECT_INT callback;
2046
2047 g_return_if_fail (n_param_values == 3);
2048
2049 if (G_CCLOSURE_SWAP_DATA (closure))
2050 {
2051 data1 = closure->data;
2052 data2 = g_value_peek_pointer (param_values + 0);
2053 }
2054 else
2055 {
2056 data1 = g_value_peek_pointer (param_values + 0);
2057 data2 = closure->data;
2058 }
2059 callback = (GMarshalFunc_VOID__OBJECT_INT) (marshal_data ? marshal_data : cc->callback);
2060
2061 callback (data1,
2062 g_marshal_value_peek_object (param_values + 1),
2063 g_marshal_value_peek_int (param_values + 2),
2064 data2);
2065 }
2066
2067 /* VOID:OBJECT,INT,OBJECT (./gtkmarshalers.list:82) */
2068 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)2069 _gtk_marshal_VOID__OBJECT_INT_OBJECT (GClosure *closure,
2070 GValue *return_value G_GNUC_UNUSED,
2071 guint n_param_values,
2072 const GValue *param_values,
2073 gpointer invocation_hint G_GNUC_UNUSED,
2074 gpointer marshal_data)
2075 {
2076 typedef void (*GMarshalFunc_VOID__OBJECT_INT_OBJECT) (gpointer data1,
2077 gpointer arg1,
2078 gint arg2,
2079 gpointer arg3,
2080 gpointer data2);
2081 GCClosure *cc = (GCClosure *) closure;
2082 gpointer data1, data2;
2083 GMarshalFunc_VOID__OBJECT_INT_OBJECT callback;
2084
2085 g_return_if_fail (n_param_values == 4);
2086
2087 if (G_CCLOSURE_SWAP_DATA (closure))
2088 {
2089 data1 = closure->data;
2090 data2 = g_value_peek_pointer (param_values + 0);
2091 }
2092 else
2093 {
2094 data1 = g_value_peek_pointer (param_values + 0);
2095 data2 = closure->data;
2096 }
2097 callback = (GMarshalFunc_VOID__OBJECT_INT_OBJECT) (marshal_data ? marshal_data : cc->callback);
2098
2099 callback (data1,
2100 g_marshal_value_peek_object (param_values + 1),
2101 g_marshal_value_peek_int (param_values + 2),
2102 g_marshal_value_peek_object (param_values + 3),
2103 data2);
2104 }
2105
2106 /* VOID:OBJECT,INT,INT (./gtkmarshalers.list:83) */
2107 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)2108 _gtk_marshal_VOID__OBJECT_INT_INT (GClosure *closure,
2109 GValue *return_value G_GNUC_UNUSED,
2110 guint n_param_values,
2111 const GValue *param_values,
2112 gpointer invocation_hint G_GNUC_UNUSED,
2113 gpointer marshal_data)
2114 {
2115 typedef void (*GMarshalFunc_VOID__OBJECT_INT_INT) (gpointer data1,
2116 gpointer arg1,
2117 gint arg2,
2118 gint arg3,
2119 gpointer data2);
2120 GCClosure *cc = (GCClosure *) closure;
2121 gpointer data1, data2;
2122 GMarshalFunc_VOID__OBJECT_INT_INT callback;
2123
2124 g_return_if_fail (n_param_values == 4);
2125
2126 if (G_CCLOSURE_SWAP_DATA (closure))
2127 {
2128 data1 = closure->data;
2129 data2 = g_value_peek_pointer (param_values + 0);
2130 }
2131 else
2132 {
2133 data1 = g_value_peek_pointer (param_values + 0);
2134 data2 = closure->data;
2135 }
2136 callback = (GMarshalFunc_VOID__OBJECT_INT_INT) (marshal_data ? marshal_data : cc->callback);
2137
2138 callback (data1,
2139 g_marshal_value_peek_object (param_values + 1),
2140 g_marshal_value_peek_int (param_values + 2),
2141 g_marshal_value_peek_int (param_values + 3),
2142 data2);
2143 }
2144
2145 /* VOID:OBJECT,INT,INT,BOXED,UINT,UINT (./gtkmarshalers.list:84) */
2146 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)2147 _gtk_marshal_VOID__OBJECT_INT_INT_BOXED_UINT_UINT (GClosure *closure,
2148 GValue *return_value G_GNUC_UNUSED,
2149 guint n_param_values,
2150 const GValue *param_values,
2151 gpointer invocation_hint G_GNUC_UNUSED,
2152 gpointer marshal_data)
2153 {
2154 typedef void (*GMarshalFunc_VOID__OBJECT_INT_INT_BOXED_UINT_UINT) (gpointer data1,
2155 gpointer arg1,
2156 gint arg2,
2157 gint arg3,
2158 gpointer arg4,
2159 guint arg5,
2160 guint arg6,
2161 gpointer data2);
2162 GCClosure *cc = (GCClosure *) closure;
2163 gpointer data1, data2;
2164 GMarshalFunc_VOID__OBJECT_INT_INT_BOXED_UINT_UINT callback;
2165
2166 g_return_if_fail (n_param_values == 7);
2167
2168 if (G_CCLOSURE_SWAP_DATA (closure))
2169 {
2170 data1 = closure->data;
2171 data2 = g_value_peek_pointer (param_values + 0);
2172 }
2173 else
2174 {
2175 data1 = g_value_peek_pointer (param_values + 0);
2176 data2 = closure->data;
2177 }
2178 callback = (GMarshalFunc_VOID__OBJECT_INT_INT_BOXED_UINT_UINT) (marshal_data ? marshal_data : cc->callback);
2179
2180 callback (data1,
2181 g_marshal_value_peek_object (param_values + 1),
2182 g_marshal_value_peek_int (param_values + 2),
2183 g_marshal_value_peek_int (param_values + 3),
2184 g_marshal_value_peek_boxed (param_values + 4),
2185 g_marshal_value_peek_uint (param_values + 5),
2186 g_marshal_value_peek_uint (param_values + 6),
2187 data2);
2188 }
2189
2190 /* VOID:OBJECT,OBJECT (./gtkmarshalers.list:85) */
2191 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)2192 _gtk_marshal_VOID__OBJECT_OBJECT (GClosure *closure,
2193 GValue *return_value G_GNUC_UNUSED,
2194 guint n_param_values,
2195 const GValue *param_values,
2196 gpointer invocation_hint G_GNUC_UNUSED,
2197 gpointer marshal_data)
2198 {
2199 typedef void (*GMarshalFunc_VOID__OBJECT_OBJECT) (gpointer data1,
2200 gpointer arg1,
2201 gpointer arg2,
2202 gpointer data2);
2203 GCClosure *cc = (GCClosure *) closure;
2204 gpointer data1, data2;
2205 GMarshalFunc_VOID__OBJECT_OBJECT callback;
2206
2207 g_return_if_fail (n_param_values == 3);
2208
2209 if (G_CCLOSURE_SWAP_DATA (closure))
2210 {
2211 data1 = closure->data;
2212 data2 = g_value_peek_pointer (param_values + 0);
2213 }
2214 else
2215 {
2216 data1 = g_value_peek_pointer (param_values + 0);
2217 data2 = closure->data;
2218 }
2219 callback = (GMarshalFunc_VOID__OBJECT_OBJECT) (marshal_data ? marshal_data : cc->callback);
2220
2221 callback (data1,
2222 g_marshal_value_peek_object (param_values + 1),
2223 g_marshal_value_peek_object (param_values + 2),
2224 data2);
2225 }
2226
2227 /* VOID:OBJECT,STRING (./gtkmarshalers.list:86) */
2228 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)2229 _gtk_marshal_VOID__OBJECT_STRING (GClosure *closure,
2230 GValue *return_value G_GNUC_UNUSED,
2231 guint n_param_values,
2232 const GValue *param_values,
2233 gpointer invocation_hint G_GNUC_UNUSED,
2234 gpointer marshal_data)
2235 {
2236 typedef void (*GMarshalFunc_VOID__OBJECT_STRING) (gpointer data1,
2237 gpointer arg1,
2238 gpointer arg2,
2239 gpointer data2);
2240 GCClosure *cc = (GCClosure *) closure;
2241 gpointer data1, data2;
2242 GMarshalFunc_VOID__OBJECT_STRING callback;
2243
2244 g_return_if_fail (n_param_values == 3);
2245
2246 if (G_CCLOSURE_SWAP_DATA (closure))
2247 {
2248 data1 = closure->data;
2249 data2 = g_value_peek_pointer (param_values + 0);
2250 }
2251 else
2252 {
2253 data1 = g_value_peek_pointer (param_values + 0);
2254 data2 = closure->data;
2255 }
2256 callback = (GMarshalFunc_VOID__OBJECT_STRING) (marshal_data ? marshal_data : cc->callback);
2257
2258 callback (data1,
2259 g_marshal_value_peek_object (param_values + 1),
2260 g_marshal_value_peek_string (param_values + 2),
2261 data2);
2262 }
2263
2264 /* VOID:OBJECT,STRING,STRING (./gtkmarshalers.list:87) */
2265 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)2266 _gtk_marshal_VOID__OBJECT_STRING_STRING (GClosure *closure,
2267 GValue *return_value G_GNUC_UNUSED,
2268 guint n_param_values,
2269 const GValue *param_values,
2270 gpointer invocation_hint G_GNUC_UNUSED,
2271 gpointer marshal_data)
2272 {
2273 typedef void (*GMarshalFunc_VOID__OBJECT_STRING_STRING) (gpointer data1,
2274 gpointer arg1,
2275 gpointer arg2,
2276 gpointer arg3,
2277 gpointer data2);
2278 GCClosure *cc = (GCClosure *) closure;
2279 gpointer data1, data2;
2280 GMarshalFunc_VOID__OBJECT_STRING_STRING callback;
2281
2282 g_return_if_fail (n_param_values == 4);
2283
2284 if (G_CCLOSURE_SWAP_DATA (closure))
2285 {
2286 data1 = closure->data;
2287 data2 = g_value_peek_pointer (param_values + 0);
2288 }
2289 else
2290 {
2291 data1 = g_value_peek_pointer (param_values + 0);
2292 data2 = closure->data;
2293 }
2294 callback = (GMarshalFunc_VOID__OBJECT_STRING_STRING) (marshal_data ? marshal_data : cc->callback);
2295
2296 callback (data1,
2297 g_marshal_value_peek_object (param_values + 1),
2298 g_marshal_value_peek_string (param_values + 2),
2299 g_marshal_value_peek_string (param_values + 3),
2300 data2);
2301 }
2302
2303 /* VOID:OBJECT,UINT (./gtkmarshalers.list:88) */
2304 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)2305 _gtk_marshal_VOID__OBJECT_UINT (GClosure *closure,
2306 GValue *return_value G_GNUC_UNUSED,
2307 guint n_param_values,
2308 const GValue *param_values,
2309 gpointer invocation_hint G_GNUC_UNUSED,
2310 gpointer marshal_data)
2311 {
2312 typedef void (*GMarshalFunc_VOID__OBJECT_UINT) (gpointer data1,
2313 gpointer arg1,
2314 guint arg2,
2315 gpointer data2);
2316 GCClosure *cc = (GCClosure *) closure;
2317 gpointer data1, data2;
2318 GMarshalFunc_VOID__OBJECT_UINT callback;
2319
2320 g_return_if_fail (n_param_values == 3);
2321
2322 if (G_CCLOSURE_SWAP_DATA (closure))
2323 {
2324 data1 = closure->data;
2325 data2 = g_value_peek_pointer (param_values + 0);
2326 }
2327 else
2328 {
2329 data1 = g_value_peek_pointer (param_values + 0);
2330 data2 = closure->data;
2331 }
2332 callback = (GMarshalFunc_VOID__OBJECT_UINT) (marshal_data ? marshal_data : cc->callback);
2333
2334 callback (data1,
2335 g_marshal_value_peek_object (param_values + 1),
2336 g_marshal_value_peek_uint (param_values + 2),
2337 data2);
2338 }
2339
2340 /* VOID:OBJECT,UINT,FLAGS (./gtkmarshalers.list:89) */
2341 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)2342 _gtk_marshal_VOID__OBJECT_UINT_FLAGS (GClosure *closure,
2343 GValue *return_value G_GNUC_UNUSED,
2344 guint n_param_values,
2345 const GValue *param_values,
2346 gpointer invocation_hint G_GNUC_UNUSED,
2347 gpointer marshal_data)
2348 {
2349 typedef void (*GMarshalFunc_VOID__OBJECT_UINT_FLAGS) (gpointer data1,
2350 gpointer arg1,
2351 guint arg2,
2352 guint arg3,
2353 gpointer data2);
2354 GCClosure *cc = (GCClosure *) closure;
2355 gpointer data1, data2;
2356 GMarshalFunc_VOID__OBJECT_UINT_FLAGS callback;
2357
2358 g_return_if_fail (n_param_values == 4);
2359
2360 if (G_CCLOSURE_SWAP_DATA (closure))
2361 {
2362 data1 = closure->data;
2363 data2 = g_value_peek_pointer (param_values + 0);
2364 }
2365 else
2366 {
2367 data1 = g_value_peek_pointer (param_values + 0);
2368 data2 = closure->data;
2369 }
2370 callback = (GMarshalFunc_VOID__OBJECT_UINT_FLAGS) (marshal_data ? marshal_data : cc->callback);
2371
2372 callback (data1,
2373 g_marshal_value_peek_object (param_values + 1),
2374 g_marshal_value_peek_uint (param_values + 2),
2375 g_marshal_value_peek_flags (param_values + 3),
2376 data2);
2377 }
2378
2379 /* VOID:OBJECT,OBJECT,OBJECT (./gtkmarshalers.list:91) */
2380 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)2381 _gtk_marshal_VOID__OBJECT_OBJECT_OBJECT (GClosure *closure,
2382 GValue *return_value G_GNUC_UNUSED,
2383 guint n_param_values,
2384 const GValue *param_values,
2385 gpointer invocation_hint G_GNUC_UNUSED,
2386 gpointer marshal_data)
2387 {
2388 typedef void (*GMarshalFunc_VOID__OBJECT_OBJECT_OBJECT) (gpointer data1,
2389 gpointer arg1,
2390 gpointer arg2,
2391 gpointer arg3,
2392 gpointer data2);
2393 GCClosure *cc = (GCClosure *) closure;
2394 gpointer data1, data2;
2395 GMarshalFunc_VOID__OBJECT_OBJECT_OBJECT callback;
2396
2397 g_return_if_fail (n_param_values == 4);
2398
2399 if (G_CCLOSURE_SWAP_DATA (closure))
2400 {
2401 data1 = closure->data;
2402 data2 = g_value_peek_pointer (param_values + 0);
2403 }
2404 else
2405 {
2406 data1 = g_value_peek_pointer (param_values + 0);
2407 data2 = closure->data;
2408 }
2409 callback = (GMarshalFunc_VOID__OBJECT_OBJECT_OBJECT) (marshal_data ? marshal_data : cc->callback);
2410
2411 callback (data1,
2412 g_marshal_value_peek_object (param_values + 1),
2413 g_marshal_value_peek_object (param_values + 2),
2414 g_marshal_value_peek_object (param_values + 3),
2415 data2);
2416 }
2417
2418 /* VOID:POINTER,INT (./gtkmarshalers.list:93) */
2419 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)2420 _gtk_marshal_VOID__POINTER_INT (GClosure *closure,
2421 GValue *return_value G_GNUC_UNUSED,
2422 guint n_param_values,
2423 const GValue *param_values,
2424 gpointer invocation_hint G_GNUC_UNUSED,
2425 gpointer marshal_data)
2426 {
2427 typedef void (*GMarshalFunc_VOID__POINTER_INT) (gpointer data1,
2428 gpointer arg1,
2429 gint arg2,
2430 gpointer data2);
2431 GCClosure *cc = (GCClosure *) closure;
2432 gpointer data1, data2;
2433 GMarshalFunc_VOID__POINTER_INT callback;
2434
2435 g_return_if_fail (n_param_values == 3);
2436
2437 if (G_CCLOSURE_SWAP_DATA (closure))
2438 {
2439 data1 = closure->data;
2440 data2 = g_value_peek_pointer (param_values + 0);
2441 }
2442 else
2443 {
2444 data1 = g_value_peek_pointer (param_values + 0);
2445 data2 = closure->data;
2446 }
2447 callback = (GMarshalFunc_VOID__POINTER_INT) (marshal_data ? marshal_data : cc->callback);
2448
2449 callback (data1,
2450 g_marshal_value_peek_pointer (param_values + 1),
2451 g_marshal_value_peek_int (param_values + 2),
2452 data2);
2453 }
2454
2455 /* VOID:POINTER,BOOLEAN (./gtkmarshalers.list:94) */
2456 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)2457 _gtk_marshal_VOID__POINTER_BOOLEAN (GClosure *closure,
2458 GValue *return_value G_GNUC_UNUSED,
2459 guint n_param_values,
2460 const GValue *param_values,
2461 gpointer invocation_hint G_GNUC_UNUSED,
2462 gpointer marshal_data)
2463 {
2464 typedef void (*GMarshalFunc_VOID__POINTER_BOOLEAN) (gpointer data1,
2465 gpointer arg1,
2466 gboolean arg2,
2467 gpointer data2);
2468 GCClosure *cc = (GCClosure *) closure;
2469 gpointer data1, data2;
2470 GMarshalFunc_VOID__POINTER_BOOLEAN callback;
2471
2472 g_return_if_fail (n_param_values == 3);
2473
2474 if (G_CCLOSURE_SWAP_DATA (closure))
2475 {
2476 data1 = closure->data;
2477 data2 = g_value_peek_pointer (param_values + 0);
2478 }
2479 else
2480 {
2481 data1 = g_value_peek_pointer (param_values + 0);
2482 data2 = closure->data;
2483 }
2484 callback = (GMarshalFunc_VOID__POINTER_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
2485
2486 callback (data1,
2487 g_marshal_value_peek_pointer (param_values + 1),
2488 g_marshal_value_peek_boolean (param_values + 2),
2489 data2);
2490 }
2491
2492 /* VOID:POINTER,POINTER,BOOLEAN (./gtkmarshalers.list:95) */
2493 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)2494 _gtk_marshal_VOID__POINTER_POINTER_BOOLEAN (GClosure *closure,
2495 GValue *return_value G_GNUC_UNUSED,
2496 guint n_param_values,
2497 const GValue *param_values,
2498 gpointer invocation_hint G_GNUC_UNUSED,
2499 gpointer marshal_data)
2500 {
2501 typedef void (*GMarshalFunc_VOID__POINTER_POINTER_BOOLEAN) (gpointer data1,
2502 gpointer arg1,
2503 gpointer arg2,
2504 gboolean arg3,
2505 gpointer data2);
2506 GCClosure *cc = (GCClosure *) closure;
2507 gpointer data1, data2;
2508 GMarshalFunc_VOID__POINTER_POINTER_BOOLEAN callback;
2509
2510 g_return_if_fail (n_param_values == 4);
2511
2512 if (G_CCLOSURE_SWAP_DATA (closure))
2513 {
2514 data1 = closure->data;
2515 data2 = g_value_peek_pointer (param_values + 0);
2516 }
2517 else
2518 {
2519 data1 = g_value_peek_pointer (param_values + 0);
2520 data2 = closure->data;
2521 }
2522 callback = (GMarshalFunc_VOID__POINTER_POINTER_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
2523
2524 callback (data1,
2525 g_marshal_value_peek_pointer (param_values + 1),
2526 g_marshal_value_peek_pointer (param_values + 2),
2527 g_marshal_value_peek_boolean (param_values + 3),
2528 data2);
2529 }
2530
2531 /* VOID:POINTER,POINTER,POINTER (./gtkmarshalers.list:96) */
2532 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)2533 _gtk_marshal_VOID__POINTER_POINTER_POINTER (GClosure *closure,
2534 GValue *return_value G_GNUC_UNUSED,
2535 guint n_param_values,
2536 const GValue *param_values,
2537 gpointer invocation_hint G_GNUC_UNUSED,
2538 gpointer marshal_data)
2539 {
2540 typedef void (*GMarshalFunc_VOID__POINTER_POINTER_POINTER) (gpointer data1,
2541 gpointer arg1,
2542 gpointer arg2,
2543 gpointer arg3,
2544 gpointer data2);
2545 GCClosure *cc = (GCClosure *) closure;
2546 gpointer data1, data2;
2547 GMarshalFunc_VOID__POINTER_POINTER_POINTER callback;
2548
2549 g_return_if_fail (n_param_values == 4);
2550
2551 if (G_CCLOSURE_SWAP_DATA (closure))
2552 {
2553 data1 = closure->data;
2554 data2 = g_value_peek_pointer (param_values + 0);
2555 }
2556 else
2557 {
2558 data1 = g_value_peek_pointer (param_values + 0);
2559 data2 = closure->data;
2560 }
2561 callback = (GMarshalFunc_VOID__POINTER_POINTER_POINTER) (marshal_data ? marshal_data : cc->callback);
2562
2563 callback (data1,
2564 g_marshal_value_peek_pointer (param_values + 1),
2565 g_marshal_value_peek_pointer (param_values + 2),
2566 g_marshal_value_peek_pointer (param_values + 3),
2567 data2);
2568 }
2569
2570 /* VOID:POINTER,UINT (./gtkmarshalers.list:97) */
2571 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)2572 _gtk_marshal_VOID__POINTER_UINT (GClosure *closure,
2573 GValue *return_value G_GNUC_UNUSED,
2574 guint n_param_values,
2575 const GValue *param_values,
2576 gpointer invocation_hint G_GNUC_UNUSED,
2577 gpointer marshal_data)
2578 {
2579 typedef void (*GMarshalFunc_VOID__POINTER_UINT) (gpointer data1,
2580 gpointer arg1,
2581 guint arg2,
2582 gpointer data2);
2583 GCClosure *cc = (GCClosure *) closure;
2584 gpointer data1, data2;
2585 GMarshalFunc_VOID__POINTER_UINT callback;
2586
2587 g_return_if_fail (n_param_values == 3);
2588
2589 if (G_CCLOSURE_SWAP_DATA (closure))
2590 {
2591 data1 = closure->data;
2592 data2 = g_value_peek_pointer (param_values + 0);
2593 }
2594 else
2595 {
2596 data1 = g_value_peek_pointer (param_values + 0);
2597 data2 = closure->data;
2598 }
2599 callback = (GMarshalFunc_VOID__POINTER_UINT) (marshal_data ? marshal_data : cc->callback);
2600
2601 callback (data1,
2602 g_marshal_value_peek_pointer (param_values + 1),
2603 g_marshal_value_peek_uint (param_values + 2),
2604 data2);
2605 }
2606
2607 /* VOID:STRING,BOXED (./gtkmarshalers.list:99) */
2608 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)2609 _gtk_marshal_VOID__STRING_BOXED (GClosure *closure,
2610 GValue *return_value G_GNUC_UNUSED,
2611 guint n_param_values,
2612 const GValue *param_values,
2613 gpointer invocation_hint G_GNUC_UNUSED,
2614 gpointer marshal_data)
2615 {
2616 typedef void (*GMarshalFunc_VOID__STRING_BOXED) (gpointer data1,
2617 gpointer arg1,
2618 gpointer arg2,
2619 gpointer data2);
2620 GCClosure *cc = (GCClosure *) closure;
2621 gpointer data1, data2;
2622 GMarshalFunc_VOID__STRING_BOXED callback;
2623
2624 g_return_if_fail (n_param_values == 3);
2625
2626 if (G_CCLOSURE_SWAP_DATA (closure))
2627 {
2628 data1 = closure->data;
2629 data2 = g_value_peek_pointer (param_values + 0);
2630 }
2631 else
2632 {
2633 data1 = g_value_peek_pointer (param_values + 0);
2634 data2 = closure->data;
2635 }
2636 callback = (GMarshalFunc_VOID__STRING_BOXED) (marshal_data ? marshal_data : cc->callback);
2637
2638 callback (data1,
2639 g_marshal_value_peek_string (param_values + 1),
2640 g_marshal_value_peek_boxed (param_values + 2),
2641 data2);
2642 }
2643
2644 /* VOID:STRING,STRING (./gtkmarshalers.list:100) */
2645 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)2646 _gtk_marshal_VOID__STRING_STRING (GClosure *closure,
2647 GValue *return_value G_GNUC_UNUSED,
2648 guint n_param_values,
2649 const GValue *param_values,
2650 gpointer invocation_hint G_GNUC_UNUSED,
2651 gpointer marshal_data)
2652 {
2653 typedef void (*GMarshalFunc_VOID__STRING_STRING) (gpointer data1,
2654 gpointer arg1,
2655 gpointer arg2,
2656 gpointer data2);
2657 GCClosure *cc = (GCClosure *) closure;
2658 gpointer data1, data2;
2659 GMarshalFunc_VOID__STRING_STRING callback;
2660
2661 g_return_if_fail (n_param_values == 3);
2662
2663 if (G_CCLOSURE_SWAP_DATA (closure))
2664 {
2665 data1 = closure->data;
2666 data2 = g_value_peek_pointer (param_values + 0);
2667 }
2668 else
2669 {
2670 data1 = g_value_peek_pointer (param_values + 0);
2671 data2 = closure->data;
2672 }
2673 callback = (GMarshalFunc_VOID__STRING_STRING) (marshal_data ? marshal_data : cc->callback);
2674
2675 callback (data1,
2676 g_marshal_value_peek_string (param_values + 1),
2677 g_marshal_value_peek_string (param_values + 2),
2678 data2);
2679 }
2680
2681 /* VOID:STRING,STRING,STRING (./gtkmarshalers.list:101) */
2682 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)2683 _gtk_marshal_VOID__STRING_STRING_STRING (GClosure *closure,
2684 GValue *return_value G_GNUC_UNUSED,
2685 guint n_param_values,
2686 const GValue *param_values,
2687 gpointer invocation_hint G_GNUC_UNUSED,
2688 gpointer marshal_data)
2689 {
2690 typedef void (*GMarshalFunc_VOID__STRING_STRING_STRING) (gpointer data1,
2691 gpointer arg1,
2692 gpointer arg2,
2693 gpointer arg3,
2694 gpointer data2);
2695 GCClosure *cc = (GCClosure *) closure;
2696 gpointer data1, data2;
2697 GMarshalFunc_VOID__STRING_STRING_STRING callback;
2698
2699 g_return_if_fail (n_param_values == 4);
2700
2701 if (G_CCLOSURE_SWAP_DATA (closure))
2702 {
2703 data1 = closure->data;
2704 data2 = g_value_peek_pointer (param_values + 0);
2705 }
2706 else
2707 {
2708 data1 = g_value_peek_pointer (param_values + 0);
2709 data2 = closure->data;
2710 }
2711 callback = (GMarshalFunc_VOID__STRING_STRING_STRING) (marshal_data ? marshal_data : cc->callback);
2712
2713 callback (data1,
2714 g_marshal_value_peek_string (param_values + 1),
2715 g_marshal_value_peek_string (param_values + 2),
2716 g_marshal_value_peek_string (param_values + 3),
2717 data2);
2718 }
2719
2720 /* VOID:STRING,INT,POINTER (./gtkmarshalers.list:102) */
2721 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)2722 _gtk_marshal_VOID__STRING_INT_POINTER (GClosure *closure,
2723 GValue *return_value G_GNUC_UNUSED,
2724 guint n_param_values,
2725 const GValue *param_values,
2726 gpointer invocation_hint G_GNUC_UNUSED,
2727 gpointer marshal_data)
2728 {
2729 typedef void (*GMarshalFunc_VOID__STRING_INT_POINTER) (gpointer data1,
2730 gpointer arg1,
2731 gint arg2,
2732 gpointer arg3,
2733 gpointer data2);
2734 GCClosure *cc = (GCClosure *) closure;
2735 gpointer data1, data2;
2736 GMarshalFunc_VOID__STRING_INT_POINTER callback;
2737
2738 g_return_if_fail (n_param_values == 4);
2739
2740 if (G_CCLOSURE_SWAP_DATA (closure))
2741 {
2742 data1 = closure->data;
2743 data2 = g_value_peek_pointer (param_values + 0);
2744 }
2745 else
2746 {
2747 data1 = g_value_peek_pointer (param_values + 0);
2748 data2 = closure->data;
2749 }
2750 callback = (GMarshalFunc_VOID__STRING_INT_POINTER) (marshal_data ? marshal_data : cc->callback);
2751
2752 callback (data1,
2753 g_marshal_value_peek_string (param_values + 1),
2754 g_marshal_value_peek_int (param_values + 2),
2755 g_marshal_value_peek_pointer (param_values + 3),
2756 data2);
2757 }
2758
2759 /* VOID:STRING,UINT,FLAGS (./gtkmarshalers.list:103) */
2760 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)2761 _gtk_marshal_VOID__STRING_UINT_FLAGS (GClosure *closure,
2762 GValue *return_value G_GNUC_UNUSED,
2763 guint n_param_values,
2764 const GValue *param_values,
2765 gpointer invocation_hint G_GNUC_UNUSED,
2766 gpointer marshal_data)
2767 {
2768 typedef void (*GMarshalFunc_VOID__STRING_UINT_FLAGS) (gpointer data1,
2769 gpointer arg1,
2770 guint arg2,
2771 guint arg3,
2772 gpointer data2);
2773 GCClosure *cc = (GCClosure *) closure;
2774 gpointer data1, data2;
2775 GMarshalFunc_VOID__STRING_UINT_FLAGS callback;
2776
2777 g_return_if_fail (n_param_values == 4);
2778
2779 if (G_CCLOSURE_SWAP_DATA (closure))
2780 {
2781 data1 = closure->data;
2782 data2 = g_value_peek_pointer (param_values + 0);
2783 }
2784 else
2785 {
2786 data1 = g_value_peek_pointer (param_values + 0);
2787 data2 = closure->data;
2788 }
2789 callback = (GMarshalFunc_VOID__STRING_UINT_FLAGS) (marshal_data ? marshal_data : cc->callback);
2790
2791 callback (data1,
2792 g_marshal_value_peek_string (param_values + 1),
2793 g_marshal_value_peek_uint (param_values + 2),
2794 g_marshal_value_peek_flags (param_values + 3),
2795 data2);
2796 }
2797
2798 /* VOID:STRING,UINT,FLAGS,UINT (./gtkmarshalers.list:104) */
2799 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)2800 _gtk_marshal_VOID__STRING_UINT_FLAGS_UINT (GClosure *closure,
2801 GValue *return_value G_GNUC_UNUSED,
2802 guint n_param_values,
2803 const GValue *param_values,
2804 gpointer invocation_hint G_GNUC_UNUSED,
2805 gpointer marshal_data)
2806 {
2807 typedef void (*GMarshalFunc_VOID__STRING_UINT_FLAGS_UINT) (gpointer data1,
2808 gpointer arg1,
2809 guint arg2,
2810 guint arg3,
2811 guint arg4,
2812 gpointer data2);
2813 GCClosure *cc = (GCClosure *) closure;
2814 gpointer data1, data2;
2815 GMarshalFunc_VOID__STRING_UINT_FLAGS_UINT callback;
2816
2817 g_return_if_fail (n_param_values == 5);
2818
2819 if (G_CCLOSURE_SWAP_DATA (closure))
2820 {
2821 data1 = closure->data;
2822 data2 = g_value_peek_pointer (param_values + 0);
2823 }
2824 else
2825 {
2826 data1 = g_value_peek_pointer (param_values + 0);
2827 data2 = closure->data;
2828 }
2829 callback = (GMarshalFunc_VOID__STRING_UINT_FLAGS_UINT) (marshal_data ? marshal_data : cc->callback);
2830
2831 callback (data1,
2832 g_marshal_value_peek_string (param_values + 1),
2833 g_marshal_value_peek_uint (param_values + 2),
2834 g_marshal_value_peek_flags (param_values + 3),
2835 g_marshal_value_peek_uint (param_values + 4),
2836 data2);
2837 }
2838
2839 /* VOID:UINT,FLAGS,BOXED (./gtkmarshalers.list:105) */
2840 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)2841 _gtk_marshal_VOID__UINT_FLAGS_BOXED (GClosure *closure,
2842 GValue *return_value G_GNUC_UNUSED,
2843 guint n_param_values,
2844 const GValue *param_values,
2845 gpointer invocation_hint G_GNUC_UNUSED,
2846 gpointer marshal_data)
2847 {
2848 typedef void (*GMarshalFunc_VOID__UINT_FLAGS_BOXED) (gpointer data1,
2849 guint arg1,
2850 guint arg2,
2851 gpointer arg3,
2852 gpointer data2);
2853 GCClosure *cc = (GCClosure *) closure;
2854 gpointer data1, data2;
2855 GMarshalFunc_VOID__UINT_FLAGS_BOXED callback;
2856
2857 g_return_if_fail (n_param_values == 4);
2858
2859 if (G_CCLOSURE_SWAP_DATA (closure))
2860 {
2861 data1 = closure->data;
2862 data2 = g_value_peek_pointer (param_values + 0);
2863 }
2864 else
2865 {
2866 data1 = g_value_peek_pointer (param_values + 0);
2867 data2 = closure->data;
2868 }
2869 callback = (GMarshalFunc_VOID__UINT_FLAGS_BOXED) (marshal_data ? marshal_data : cc->callback);
2870
2871 callback (data1,
2872 g_marshal_value_peek_uint (param_values + 1),
2873 g_marshal_value_peek_flags (param_values + 2),
2874 g_marshal_value_peek_boxed (param_values + 3),
2875 data2);
2876 }
2877
2878 /* VOID:UINT,UINT (./gtkmarshalers.list:106) */
2879 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)2880 _gtk_marshal_VOID__UINT_UINT (GClosure *closure,
2881 GValue *return_value G_GNUC_UNUSED,
2882 guint n_param_values,
2883 const GValue *param_values,
2884 gpointer invocation_hint G_GNUC_UNUSED,
2885 gpointer marshal_data)
2886 {
2887 typedef void (*GMarshalFunc_VOID__UINT_UINT) (gpointer data1,
2888 guint arg1,
2889 guint arg2,
2890 gpointer data2);
2891 GCClosure *cc = (GCClosure *) closure;
2892 gpointer data1, data2;
2893 GMarshalFunc_VOID__UINT_UINT callback;
2894
2895 g_return_if_fail (n_param_values == 3);
2896
2897 if (G_CCLOSURE_SWAP_DATA (closure))
2898 {
2899 data1 = closure->data;
2900 data2 = g_value_peek_pointer (param_values + 0);
2901 }
2902 else
2903 {
2904 data1 = g_value_peek_pointer (param_values + 0);
2905 data2 = closure->data;
2906 }
2907 callback = (GMarshalFunc_VOID__UINT_UINT) (marshal_data ? marshal_data : cc->callback);
2908
2909 callback (data1,
2910 g_marshal_value_peek_uint (param_values + 1),
2911 g_marshal_value_peek_uint (param_values + 2),
2912 data2);
2913 }
2914
2915 /* VOID:UINT,STRING (./gtkmarshalers.list:107) */
2916 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)2917 _gtk_marshal_VOID__UINT_STRING (GClosure *closure,
2918 GValue *return_value G_GNUC_UNUSED,
2919 guint n_param_values,
2920 const GValue *param_values,
2921 gpointer invocation_hint G_GNUC_UNUSED,
2922 gpointer marshal_data)
2923 {
2924 typedef void (*GMarshalFunc_VOID__UINT_STRING) (gpointer data1,
2925 guint arg1,
2926 gpointer arg2,
2927 gpointer data2);
2928 GCClosure *cc = (GCClosure *) closure;
2929 gpointer data1, data2;
2930 GMarshalFunc_VOID__UINT_STRING callback;
2931
2932 g_return_if_fail (n_param_values == 3);
2933
2934 if (G_CCLOSURE_SWAP_DATA (closure))
2935 {
2936 data1 = closure->data;
2937 data2 = g_value_peek_pointer (param_values + 0);
2938 }
2939 else
2940 {
2941 data1 = g_value_peek_pointer (param_values + 0);
2942 data2 = closure->data;
2943 }
2944 callback = (GMarshalFunc_VOID__UINT_STRING) (marshal_data ? marshal_data : cc->callback);
2945
2946 callback (data1,
2947 g_marshal_value_peek_uint (param_values + 1),
2948 g_marshal_value_peek_string (param_values + 2),
2949 data2);
2950 }
2951
2952 /* VOID:UINT,BOXED,UINT,FLAGS,FLAGS (./gtkmarshalers.list:108) */
2953 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)2954 _gtk_marshal_VOID__UINT_BOXED_UINT_FLAGS_FLAGS (GClosure *closure,
2955 GValue *return_value G_GNUC_UNUSED,
2956 guint n_param_values,
2957 const GValue *param_values,
2958 gpointer invocation_hint G_GNUC_UNUSED,
2959 gpointer marshal_data)
2960 {
2961 typedef void (*GMarshalFunc_VOID__UINT_BOXED_UINT_FLAGS_FLAGS) (gpointer data1,
2962 guint arg1,
2963 gpointer arg2,
2964 guint arg3,
2965 guint arg4,
2966 guint arg5,
2967 gpointer data2);
2968 GCClosure *cc = (GCClosure *) closure;
2969 gpointer data1, data2;
2970 GMarshalFunc_VOID__UINT_BOXED_UINT_FLAGS_FLAGS callback;
2971
2972 g_return_if_fail (n_param_values == 6);
2973
2974 if (G_CCLOSURE_SWAP_DATA (closure))
2975 {
2976 data1 = closure->data;
2977 data2 = g_value_peek_pointer (param_values + 0);
2978 }
2979 else
2980 {
2981 data1 = g_value_peek_pointer (param_values + 0);
2982 data2 = closure->data;
2983 }
2984 callback = (GMarshalFunc_VOID__UINT_BOXED_UINT_FLAGS_FLAGS) (marshal_data ? marshal_data : cc->callback);
2985
2986 callback (data1,
2987 g_marshal_value_peek_uint (param_values + 1),
2988 g_marshal_value_peek_boxed (param_values + 2),
2989 g_marshal_value_peek_uint (param_values + 3),
2990 g_marshal_value_peek_flags (param_values + 4),
2991 g_marshal_value_peek_flags (param_values + 5),
2992 data2);
2993 }
2994
2995 /* VOID:UINT,OBJECT,UINT,FLAGS,FLAGS (./gtkmarshalers.list:109) */
2996 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)2997 _gtk_marshal_VOID__UINT_OBJECT_UINT_FLAGS_FLAGS (GClosure *closure,
2998 GValue *return_value G_GNUC_UNUSED,
2999 guint n_param_values,
3000 const GValue *param_values,
3001 gpointer invocation_hint G_GNUC_UNUSED,
3002 gpointer marshal_data)
3003 {
3004 typedef void (*GMarshalFunc_VOID__UINT_OBJECT_UINT_FLAGS_FLAGS) (gpointer data1,
3005 guint arg1,
3006 gpointer arg2,
3007 guint arg3,
3008 guint arg4,
3009 guint arg5,
3010 gpointer data2);
3011 GCClosure *cc = (GCClosure *) closure;
3012 gpointer data1, data2;
3013 GMarshalFunc_VOID__UINT_OBJECT_UINT_FLAGS_FLAGS callback;
3014
3015 g_return_if_fail (n_param_values == 6);
3016
3017 if (G_CCLOSURE_SWAP_DATA (closure))
3018 {
3019 data1 = closure->data;
3020 data2 = g_value_peek_pointer (param_values + 0);
3021 }
3022 else
3023 {
3024 data1 = g_value_peek_pointer (param_values + 0);
3025 data2 = closure->data;
3026 }
3027 callback = (GMarshalFunc_VOID__UINT_OBJECT_UINT_FLAGS_FLAGS) (marshal_data ? marshal_data : cc->callback);
3028
3029 callback (data1,
3030 g_marshal_value_peek_uint (param_values + 1),
3031 g_marshal_value_peek_object (param_values + 2),
3032 g_marshal_value_peek_uint (param_values + 3),
3033 g_marshal_value_peek_flags (param_values + 4),
3034 g_marshal_value_peek_flags (param_values + 5),
3035 data2);
3036 }
3037
3038 /* VOID:UINT,STRING,UINT (./gtkmarshalers.list:110) */
3039 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)3040 _gtk_marshal_VOID__UINT_STRING_UINT (GClosure *closure,
3041 GValue *return_value G_GNUC_UNUSED,
3042 guint n_param_values,
3043 const GValue *param_values,
3044 gpointer invocation_hint G_GNUC_UNUSED,
3045 gpointer marshal_data)
3046 {
3047 typedef void (*GMarshalFunc_VOID__UINT_STRING_UINT) (gpointer data1,
3048 guint arg1,
3049 gpointer arg2,
3050 guint arg3,
3051 gpointer data2);
3052 GCClosure *cc = (GCClosure *) closure;
3053 gpointer data1, data2;
3054 GMarshalFunc_VOID__UINT_STRING_UINT callback;
3055
3056 g_return_if_fail (n_param_values == 4);
3057
3058 if (G_CCLOSURE_SWAP_DATA (closure))
3059 {
3060 data1 = closure->data;
3061 data2 = g_value_peek_pointer (param_values + 0);
3062 }
3063 else
3064 {
3065 data1 = g_value_peek_pointer (param_values + 0);
3066 data2 = closure->data;
3067 }
3068 callback = (GMarshalFunc_VOID__UINT_STRING_UINT) (marshal_data ? marshal_data : cc->callback);
3069
3070 callback (data1,
3071 g_marshal_value_peek_uint (param_values + 1),
3072 g_marshal_value_peek_string (param_values + 2),
3073 g_marshal_value_peek_uint (param_values + 3),
3074 data2);
3075 }
3076
3077 /* OBJECT:OBJECT,INT,INT (./gtkmarshalers.list:113) */
3078 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)3079 _gtk_marshal_OBJECT__OBJECT_INT_INT (GClosure *closure,
3080 GValue *return_value,
3081 guint n_param_values,
3082 const GValue *param_values,
3083 gpointer invocation_hint G_GNUC_UNUSED,
3084 gpointer marshal_data)
3085 {
3086 typedef GObject* (*GMarshalFunc_OBJECT__OBJECT_INT_INT) (gpointer data1,
3087 gpointer arg1,
3088 gint arg2,
3089 gint arg3,
3090 gpointer data2);
3091 GCClosure *cc = (GCClosure *) closure;
3092 gpointer data1, data2;
3093 GMarshalFunc_OBJECT__OBJECT_INT_INT callback;
3094 GObject* v_return;
3095
3096 g_return_if_fail (return_value != NULL);
3097 g_return_if_fail (n_param_values == 4);
3098
3099 if (G_CCLOSURE_SWAP_DATA (closure))
3100 {
3101 data1 = closure->data;
3102 data2 = g_value_peek_pointer (param_values + 0);
3103 }
3104 else
3105 {
3106 data1 = g_value_peek_pointer (param_values + 0);
3107 data2 = closure->data;
3108 }
3109 callback = (GMarshalFunc_OBJECT__OBJECT_INT_INT) (marshal_data ? marshal_data : cc->callback);
3110
3111 v_return = callback (data1,
3112 g_marshal_value_peek_object (param_values + 1),
3113 g_marshal_value_peek_int (param_values + 2),
3114 g_marshal_value_peek_int (param_values + 3),
3115 data2);
3116
3117 g_value_take_object (return_value, v_return);
3118 }
3119
3120 /* VOID:POINTER,POINTER,POINTER,POINTER,STRING (./gtkmarshalers.list:114) */
3121 void
_gtk_marshal_VOID__POINTER_POINTER_POINTER_POINTER_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)3122 _gtk_marshal_VOID__POINTER_POINTER_POINTER_POINTER_STRING (GClosure *closure,
3123 GValue *return_value G_GNUC_UNUSED,
3124 guint n_param_values,
3125 const GValue *param_values,
3126 gpointer invocation_hint G_GNUC_UNUSED,
3127 gpointer marshal_data)
3128 {
3129 typedef void (*GMarshalFunc_VOID__POINTER_POINTER_POINTER_POINTER_STRING) (gpointer data1,
3130 gpointer arg1,
3131 gpointer arg2,
3132 gpointer arg3,
3133 gpointer arg4,
3134 gpointer arg5,
3135 gpointer data2);
3136 GCClosure *cc = (GCClosure *) closure;
3137 gpointer data1, data2;
3138 GMarshalFunc_VOID__POINTER_POINTER_POINTER_POINTER_STRING callback;
3139
3140 g_return_if_fail (n_param_values == 6);
3141
3142 if (G_CCLOSURE_SWAP_DATA (closure))
3143 {
3144 data1 = closure->data;
3145 data2 = g_value_peek_pointer (param_values + 0);
3146 }
3147 else
3148 {
3149 data1 = g_value_peek_pointer (param_values + 0);
3150 data2 = closure->data;
3151 }
3152 callback = (GMarshalFunc_VOID__POINTER_POINTER_POINTER_POINTER_STRING) (marshal_data ? marshal_data : cc->callback);
3153
3154 callback (data1,
3155 g_marshal_value_peek_pointer (param_values + 1),
3156 g_marshal_value_peek_pointer (param_values + 2),
3157 g_marshal_value_peek_pointer (param_values + 3),
3158 g_marshal_value_peek_pointer (param_values + 4),
3159 g_marshal_value_peek_string (param_values + 5),
3160 data2);
3161 }
3162
3163