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