|
1 /* |
|
2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). |
|
3 * All rights reserved. |
|
4 * This component and the accompanying materials are made available |
|
5 * under the terms of "Eclipse Public License v1.0" |
|
6 * which accompanies this distribution, and is available |
|
7 * at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
8 * |
|
9 * Initial Contributors: |
|
10 * Nokia Corporation - initial contribution. |
|
11 * |
|
12 * Contributors: |
|
13 * |
|
14 * Description: |
|
15 * |
|
16 */ |
|
17 |
|
18 |
|
19 |
|
20 |
|
21 #ifdef G_ENABLE_DEBUG |
|
22 #define g_marshal_value_peek_boolean(v) g_value_get_boolean (v) |
|
23 #define g_marshal_value_peek_char(v) g_value_get_char (v) |
|
24 #define g_marshal_value_peek_uchar(v) g_value_get_uchar (v) |
|
25 #define g_marshal_value_peek_int(v) g_value_get_int (v) |
|
26 #define g_marshal_value_peek_uint(v) g_value_get_uint (v) |
|
27 #define g_marshal_value_peek_long(v) g_value_get_long (v) |
|
28 #define g_marshal_value_peek_ulong(v) g_value_get_ulong (v) |
|
29 #define g_marshal_value_peek_int64(v) g_value_get_int64 (v) |
|
30 #define g_marshal_value_peek_uint64(v) g_value_get_uint64 (v) |
|
31 #define g_marshal_value_peek_enum(v) g_value_get_enum (v) |
|
32 #define g_marshal_value_peek_flags(v) g_value_get_flags (v) |
|
33 #define g_marshal_value_peek_float(v) g_value_get_float (v) |
|
34 #define g_marshal_value_peek_double(v) g_value_get_double (v) |
|
35 #define g_marshal_value_peek_string(v) (char*) g_value_get_string (v) |
|
36 #define g_marshal_value_peek_param(v) g_value_get_param (v) |
|
37 #define g_marshal_value_peek_boxed(v) g_value_get_boxed (v) |
|
38 #define g_marshal_value_peek_pointer(v) g_value_get_pointer (v) |
|
39 #define g_marshal_value_peek_object(v) g_value_get_object (v) |
|
40 #else /* !G_ENABLE_DEBUG */ |
|
41 /* WARNING: This code accesses GValues directly, which is UNSUPPORTED API. |
|
42 * Do not access GValues directly in your code. Instead, use the |
|
43 * g_value_get_*() functions |
|
44 */ |
|
45 #define g_marshal_value_peek_boolean(v) (v)->data[0].v_int |
|
46 #define g_marshal_value_peek_char(v) (v)->data[0].v_int |
|
47 #define g_marshal_value_peek_uchar(v) (v)->data[0].v_uint |
|
48 #define g_marshal_value_peek_int(v) (v)->data[0].v_int |
|
49 #define g_marshal_value_peek_uint(v) (v)->data[0].v_uint |
|
50 #define g_marshal_value_peek_long(v) (v)->data[0].v_long |
|
51 #define g_marshal_value_peek_ulong(v) (v)->data[0].v_ulong |
|
52 #define g_marshal_value_peek_int64(v) (v)->data[0].v_int64 |
|
53 #define g_marshal_value_peek_uint64(v) (v)->data[0].v_uint64 |
|
54 #define g_marshal_value_peek_enum(v) (v)->data[0].v_long |
|
55 #define g_marshal_value_peek_flags(v) (v)->data[0].v_ulong |
|
56 #define g_marshal_value_peek_float(v) (v)->data[0].v_float |
|
57 #define g_marshal_value_peek_double(v) (v)->data[0].v_double |
|
58 #define g_marshal_value_peek_string(v) (v)->data[0].v_pointer |
|
59 #define g_marshal_value_peek_param(v) (v)->data[0].v_pointer |
|
60 #define g_marshal_value_peek_boxed(v) (v)->data[0].v_pointer |
|
61 #define g_marshal_value_peek_pointer(v) (v)->data[0].v_pointer |
|
62 #define g_marshal_value_peek_object(v) (v)->data[0].v_pointer |
|
63 #endif /* !G_ENABLE_DEBUG */ |
|
64 |
|
65 |
|
66 /* VOID:VOID (./gmarshal.list:26) */ |
|
67 EXPORT_C void |
|
68 g_cclosure_marshal_VOID__VOID (GClosure *closure, |
|
69 GValue *return_value, |
|
70 guint n_param_values, |
|
71 const GValue *param_values, |
|
72 gpointer invocation_hint, |
|
73 gpointer marshal_data) |
|
74 { |
|
75 typedef void (*GMarshalFunc_VOID__VOID) (gpointer data1, |
|
76 gpointer data2); |
|
77 register GMarshalFunc_VOID__VOID callback; |
|
78 register GCClosure *cc = (GCClosure*) closure; |
|
79 register gpointer data1, data2; |
|
80 |
|
81 g_return_if_fail (n_param_values == 1); |
|
82 |
|
83 if (G_CCLOSURE_SWAP_DATA (closure)) |
|
84 { |
|
85 data1 = closure->data; |
|
86 data2 = g_value_peek_pointer (param_values + 0); |
|
87 } |
|
88 else |
|
89 { |
|
90 data1 = g_value_peek_pointer (param_values + 0); |
|
91 data2 = closure->data; |
|
92 } |
|
93 callback = (GMarshalFunc_VOID__VOID) (marshal_data ? marshal_data : cc->callback); |
|
94 |
|
95 callback (data1, |
|
96 data2); |
|
97 } |
|
98 |
|
99 /* VOID:BOOLEAN (./gmarshal.list:27) */ |
|
100 EXPORT_C void |
|
101 g_cclosure_marshal_VOID__BOOLEAN (GClosure *closure, |
|
102 GValue *return_value, |
|
103 guint n_param_values, |
|
104 const GValue *param_values, |
|
105 gpointer invocation_hint, |
|
106 gpointer marshal_data) |
|
107 { |
|
108 typedef void (*GMarshalFunc_VOID__BOOLEAN) (gpointer data1, |
|
109 gboolean arg_1, |
|
110 gpointer data2); |
|
111 register GMarshalFunc_VOID__BOOLEAN callback; |
|
112 register GCClosure *cc = (GCClosure*) closure; |
|
113 register gpointer data1, data2; |
|
114 |
|
115 g_return_if_fail (n_param_values == 2); |
|
116 |
|
117 if (G_CCLOSURE_SWAP_DATA (closure)) |
|
118 { |
|
119 data1 = closure->data; |
|
120 data2 = g_value_peek_pointer (param_values + 0); |
|
121 } |
|
122 else |
|
123 { |
|
124 data1 = g_value_peek_pointer (param_values + 0); |
|
125 data2 = closure->data; |
|
126 } |
|
127 callback = (GMarshalFunc_VOID__BOOLEAN) (marshal_data ? marshal_data : cc->callback); |
|
128 |
|
129 callback (data1, |
|
130 g_marshal_value_peek_boolean (param_values + 1), |
|
131 data2); |
|
132 } |
|
133 |
|
134 /* VOID:CHAR (./gmarshal.list:28) */ |
|
135 EXPORT_C void |
|
136 g_cclosure_marshal_VOID__CHAR (GClosure *closure, |
|
137 GValue *return_value, |
|
138 guint n_param_values, |
|
139 const GValue *param_values, |
|
140 gpointer invocation_hint, |
|
141 gpointer marshal_data) |
|
142 { |
|
143 typedef void (*GMarshalFunc_VOID__CHAR) (gpointer data1, |
|
144 gchar arg_1, |
|
145 gpointer data2); |
|
146 register GMarshalFunc_VOID__CHAR callback; |
|
147 register GCClosure *cc = (GCClosure*) closure; |
|
148 register gpointer data1, data2; |
|
149 |
|
150 g_return_if_fail (n_param_values == 2); |
|
151 |
|
152 if (G_CCLOSURE_SWAP_DATA (closure)) |
|
153 { |
|
154 data1 = closure->data; |
|
155 data2 = g_value_peek_pointer (param_values + 0); |
|
156 } |
|
157 else |
|
158 { |
|
159 data1 = g_value_peek_pointer (param_values + 0); |
|
160 data2 = closure->data; |
|
161 } |
|
162 callback = (GMarshalFunc_VOID__CHAR) (marshal_data ? marshal_data : cc->callback); |
|
163 |
|
164 callback (data1, |
|
165 g_marshal_value_peek_char (param_values + 1), |
|
166 data2); |
|
167 } |
|
168 |
|
169 /* VOID:UCHAR (./gmarshal.list:29) */ |
|
170 EXPORT_C void |
|
171 g_cclosure_marshal_VOID__UCHAR (GClosure *closure, |
|
172 GValue *return_value, |
|
173 guint n_param_values, |
|
174 const GValue *param_values, |
|
175 gpointer invocation_hint, |
|
176 gpointer marshal_data) |
|
177 { |
|
178 typedef void (*GMarshalFunc_VOID__UCHAR) (gpointer data1, |
|
179 guchar arg_1, |
|
180 gpointer data2); |
|
181 register GMarshalFunc_VOID__UCHAR callback; |
|
182 register GCClosure *cc = (GCClosure*) closure; |
|
183 register gpointer data1, data2; |
|
184 |
|
185 g_return_if_fail (n_param_values == 2); |
|
186 |
|
187 if (G_CCLOSURE_SWAP_DATA (closure)) |
|
188 { |
|
189 data1 = closure->data; |
|
190 data2 = g_value_peek_pointer (param_values + 0); |
|
191 } |
|
192 else |
|
193 { |
|
194 data1 = g_value_peek_pointer (param_values + 0); |
|
195 data2 = closure->data; |
|
196 } |
|
197 callback = (GMarshalFunc_VOID__UCHAR) (marshal_data ? marshal_data : cc->callback); |
|
198 |
|
199 callback (data1, |
|
200 g_marshal_value_peek_uchar (param_values + 1), |
|
201 data2); |
|
202 } |
|
203 |
|
204 /* VOID:INT (./gmarshal.list:30) */ |
|
205 EXPORT_C void |
|
206 g_cclosure_marshal_VOID__INT (GClosure *closure, |
|
207 GValue *return_value, |
|
208 guint n_param_values, |
|
209 const GValue *param_values, |
|
210 gpointer invocation_hint, |
|
211 gpointer marshal_data) |
|
212 { |
|
213 typedef void (*GMarshalFunc_VOID__INT) (gpointer data1, |
|
214 gint arg_1, |
|
215 gpointer data2); |
|
216 register GMarshalFunc_VOID__INT callback; |
|
217 register GCClosure *cc = (GCClosure*) closure; |
|
218 register gpointer data1, data2; |
|
219 |
|
220 g_return_if_fail (n_param_values == 2); |
|
221 |
|
222 if (G_CCLOSURE_SWAP_DATA (closure)) |
|
223 { |
|
224 data1 = closure->data; |
|
225 data2 = g_value_peek_pointer (param_values + 0); |
|
226 } |
|
227 else |
|
228 { |
|
229 data1 = g_value_peek_pointer (param_values + 0); |
|
230 data2 = closure->data; |
|
231 } |
|
232 callback = (GMarshalFunc_VOID__INT) (marshal_data ? marshal_data : cc->callback); |
|
233 |
|
234 callback (data1, |
|
235 g_marshal_value_peek_int (param_values + 1), |
|
236 data2); |
|
237 } |
|
238 |
|
239 /* VOID:UINT (./gmarshal.list:31) */ |
|
240 EXPORT_C void |
|
241 g_cclosure_marshal_VOID__UINT (GClosure *closure, |
|
242 GValue *return_value, |
|
243 guint n_param_values, |
|
244 const GValue *param_values, |
|
245 gpointer invocation_hint, |
|
246 gpointer marshal_data) |
|
247 { |
|
248 typedef void (*GMarshalFunc_VOID__UINT) (gpointer data1, |
|
249 guint arg_1, |
|
250 gpointer data2); |
|
251 register GMarshalFunc_VOID__UINT callback; |
|
252 register GCClosure *cc = (GCClosure*) closure; |
|
253 register gpointer data1, data2; |
|
254 |
|
255 g_return_if_fail (n_param_values == 2); |
|
256 |
|
257 if (G_CCLOSURE_SWAP_DATA (closure)) |
|
258 { |
|
259 data1 = closure->data; |
|
260 data2 = g_value_peek_pointer (param_values + 0); |
|
261 } |
|
262 else |
|
263 { |
|
264 data1 = g_value_peek_pointer (param_values + 0); |
|
265 data2 = closure->data; |
|
266 } |
|
267 callback = (GMarshalFunc_VOID__UINT) (marshal_data ? marshal_data : cc->callback); |
|
268 |
|
269 callback (data1, |
|
270 g_marshal_value_peek_uint (param_values + 1), |
|
271 data2); |
|
272 } |
|
273 |
|
274 /* VOID:LONG (./gmarshal.list:32) */ |
|
275 EXPORT_C void |
|
276 g_cclosure_marshal_VOID__LONG (GClosure *closure, |
|
277 GValue *return_value, |
|
278 guint n_param_values, |
|
279 const GValue *param_values, |
|
280 gpointer invocation_hint, |
|
281 gpointer marshal_data) |
|
282 { |
|
283 typedef void (*GMarshalFunc_VOID__LONG) (gpointer data1, |
|
284 glong arg_1, |
|
285 gpointer data2); |
|
286 register GMarshalFunc_VOID__LONG callback; |
|
287 register GCClosure *cc = (GCClosure*) closure; |
|
288 register gpointer data1, data2; |
|
289 |
|
290 g_return_if_fail (n_param_values == 2); |
|
291 |
|
292 if (G_CCLOSURE_SWAP_DATA (closure)) |
|
293 { |
|
294 data1 = closure->data; |
|
295 data2 = g_value_peek_pointer (param_values + 0); |
|
296 } |
|
297 else |
|
298 { |
|
299 data1 = g_value_peek_pointer (param_values + 0); |
|
300 data2 = closure->data; |
|
301 } |
|
302 callback = (GMarshalFunc_VOID__LONG) (marshal_data ? marshal_data : cc->callback); |
|
303 |
|
304 callback (data1, |
|
305 g_marshal_value_peek_long (param_values + 1), |
|
306 data2); |
|
307 } |
|
308 |
|
309 /* VOID:ULONG (./gmarshal.list:33) */ |
|
310 EXPORT_C void |
|
311 g_cclosure_marshal_VOID__ULONG (GClosure *closure, |
|
312 GValue *return_value, |
|
313 guint n_param_values, |
|
314 const GValue *param_values, |
|
315 gpointer invocation_hint, |
|
316 gpointer marshal_data) |
|
317 { |
|
318 typedef void (*GMarshalFunc_VOID__ULONG) (gpointer data1, |
|
319 gulong arg_1, |
|
320 gpointer data2); |
|
321 register GMarshalFunc_VOID__ULONG callback; |
|
322 register GCClosure *cc = (GCClosure*) closure; |
|
323 register gpointer data1, data2; |
|
324 |
|
325 g_return_if_fail (n_param_values == 2); |
|
326 |
|
327 if (G_CCLOSURE_SWAP_DATA (closure)) |
|
328 { |
|
329 data1 = closure->data; |
|
330 data2 = g_value_peek_pointer (param_values + 0); |
|
331 } |
|
332 else |
|
333 { |
|
334 data1 = g_value_peek_pointer (param_values + 0); |
|
335 data2 = closure->data; |
|
336 } |
|
337 callback = (GMarshalFunc_VOID__ULONG) (marshal_data ? marshal_data : cc->callback); |
|
338 |
|
339 callback (data1, |
|
340 g_marshal_value_peek_ulong (param_values + 1), |
|
341 data2); |
|
342 } |
|
343 |
|
344 /* VOID:ENUM (./gmarshal.list:34) */ |
|
345 EXPORT_C void |
|
346 g_cclosure_marshal_VOID__ENUM (GClosure *closure, |
|
347 GValue *return_value, |
|
348 guint n_param_values, |
|
349 const GValue *param_values, |
|
350 gpointer invocation_hint, |
|
351 gpointer marshal_data) |
|
352 { |
|
353 typedef void (*GMarshalFunc_VOID__ENUM) (gpointer data1, |
|
354 gint arg_1, |
|
355 gpointer data2); |
|
356 register GMarshalFunc_VOID__ENUM callback; |
|
357 register GCClosure *cc = (GCClosure*) closure; |
|
358 register gpointer data1, data2; |
|
359 |
|
360 g_return_if_fail (n_param_values == 2); |
|
361 |
|
362 if (G_CCLOSURE_SWAP_DATA (closure)) |
|
363 { |
|
364 data1 = closure->data; |
|
365 data2 = g_value_peek_pointer (param_values + 0); |
|
366 } |
|
367 else |
|
368 { |
|
369 data1 = g_value_peek_pointer (param_values + 0); |
|
370 data2 = closure->data; |
|
371 } |
|
372 callback = (GMarshalFunc_VOID__ENUM) (marshal_data ? marshal_data : cc->callback); |
|
373 |
|
374 callback (data1, |
|
375 g_marshal_value_peek_enum (param_values + 1), |
|
376 data2); |
|
377 } |
|
378 |
|
379 /* VOID:FLAGS (./gmarshal.list:35) */ |
|
380 EXPORT_C void |
|
381 g_cclosure_marshal_VOID__FLAGS (GClosure *closure, |
|
382 GValue *return_value, |
|
383 guint n_param_values, |
|
384 const GValue *param_values, |
|
385 gpointer invocation_hint, |
|
386 gpointer marshal_data) |
|
387 { |
|
388 typedef void (*GMarshalFunc_VOID__FLAGS) (gpointer data1, |
|
389 guint arg_1, |
|
390 gpointer data2); |
|
391 register GMarshalFunc_VOID__FLAGS callback; |
|
392 register GCClosure *cc = (GCClosure*) closure; |
|
393 register gpointer data1, data2; |
|
394 |
|
395 g_return_if_fail (n_param_values == 2); |
|
396 |
|
397 if (G_CCLOSURE_SWAP_DATA (closure)) |
|
398 { |
|
399 data1 = closure->data; |
|
400 data2 = g_value_peek_pointer (param_values + 0); |
|
401 } |
|
402 else |
|
403 { |
|
404 data1 = g_value_peek_pointer (param_values + 0); |
|
405 data2 = closure->data; |
|
406 } |
|
407 callback = (GMarshalFunc_VOID__FLAGS) (marshal_data ? marshal_data : cc->callback); |
|
408 |
|
409 callback (data1, |
|
410 g_marshal_value_peek_flags (param_values + 1), |
|
411 data2); |
|
412 } |
|
413 |
|
414 /* VOID:FLOAT (./gmarshal.list:36) */ |
|
415 EXPORT_C void |
|
416 g_cclosure_marshal_VOID__FLOAT (GClosure *closure, |
|
417 GValue *return_value, |
|
418 guint n_param_values, |
|
419 const GValue *param_values, |
|
420 gpointer invocation_hint, |
|
421 gpointer marshal_data) |
|
422 { |
|
423 typedef void (*GMarshalFunc_VOID__FLOAT) (gpointer data1, |
|
424 gfloat arg_1, |
|
425 gpointer data2); |
|
426 register GMarshalFunc_VOID__FLOAT callback; |
|
427 register GCClosure *cc = (GCClosure*) closure; |
|
428 register gpointer data1, data2; |
|
429 |
|
430 g_return_if_fail (n_param_values == 2); |
|
431 |
|
432 if (G_CCLOSURE_SWAP_DATA (closure)) |
|
433 { |
|
434 data1 = closure->data; |
|
435 data2 = g_value_peek_pointer (param_values + 0); |
|
436 } |
|
437 else |
|
438 { |
|
439 data1 = g_value_peek_pointer (param_values + 0); |
|
440 data2 = closure->data; |
|
441 } |
|
442 callback = (GMarshalFunc_VOID__FLOAT) (marshal_data ? marshal_data : cc->callback); |
|
443 |
|
444 callback (data1, |
|
445 g_marshal_value_peek_float (param_values + 1), |
|
446 data2); |
|
447 } |
|
448 |
|
449 /* VOID:DOUBLE (./gmarshal.list:37) */ |
|
450 EXPORT_C void |
|
451 g_cclosure_marshal_VOID__DOUBLE (GClosure *closure, |
|
452 GValue *return_value, |
|
453 guint n_param_values, |
|
454 const GValue *param_values, |
|
455 gpointer invocation_hint, |
|
456 gpointer marshal_data) |
|
457 { |
|
458 typedef void (*GMarshalFunc_VOID__DOUBLE) (gpointer data1, |
|
459 gdouble arg_1, |
|
460 gpointer data2); |
|
461 register GMarshalFunc_VOID__DOUBLE callback; |
|
462 register GCClosure *cc = (GCClosure*) closure; |
|
463 register gpointer data1, data2; |
|
464 |
|
465 g_return_if_fail (n_param_values == 2); |
|
466 |
|
467 if (G_CCLOSURE_SWAP_DATA (closure)) |
|
468 { |
|
469 data1 = closure->data; |
|
470 data2 = g_value_peek_pointer (param_values + 0); |
|
471 } |
|
472 else |
|
473 { |
|
474 data1 = g_value_peek_pointer (param_values + 0); |
|
475 data2 = closure->data; |
|
476 } |
|
477 callback = (GMarshalFunc_VOID__DOUBLE) (marshal_data ? marshal_data : cc->callback); |
|
478 |
|
479 callback (data1, |
|
480 g_marshal_value_peek_double (param_values + 1), |
|
481 data2); |
|
482 } |
|
483 |
|
484 /* VOID:STRING (./gmarshal.list:38) */ |
|
485 EXPORT_C void |
|
486 g_cclosure_marshal_VOID__STRING (GClosure *closure, |
|
487 GValue *return_value, |
|
488 guint n_param_values, |
|
489 const GValue *param_values, |
|
490 gpointer invocation_hint, |
|
491 gpointer marshal_data) |
|
492 { |
|
493 typedef void (*GMarshalFunc_VOID__STRING) (gpointer data1, |
|
494 gpointer arg_1, |
|
495 gpointer data2); |
|
496 register GMarshalFunc_VOID__STRING callback; |
|
497 register GCClosure *cc = (GCClosure*) closure; |
|
498 register gpointer data1, data2; |
|
499 |
|
500 g_return_if_fail (n_param_values == 2); |
|
501 |
|
502 if (G_CCLOSURE_SWAP_DATA (closure)) |
|
503 { |
|
504 data1 = closure->data; |
|
505 data2 = g_value_peek_pointer (param_values + 0); |
|
506 } |
|
507 else |
|
508 { |
|
509 data1 = g_value_peek_pointer (param_values + 0); |
|
510 data2 = closure->data; |
|
511 } |
|
512 callback = (GMarshalFunc_VOID__STRING) (marshal_data ? marshal_data : cc->callback); |
|
513 |
|
514 callback (data1, |
|
515 g_marshal_value_peek_string (param_values + 1), |
|
516 data2); |
|
517 } |
|
518 |
|
519 /* VOID:PARAM (./gmarshal.list:39) */ |
|
520 EXPORT_C void |
|
521 g_cclosure_marshal_VOID__PARAM (GClosure *closure, |
|
522 GValue *return_value, |
|
523 guint n_param_values, |
|
524 const GValue *param_values, |
|
525 gpointer invocation_hint, |
|
526 gpointer marshal_data) |
|
527 { |
|
528 typedef void (*GMarshalFunc_VOID__PARAM) (gpointer data1, |
|
529 gpointer arg_1, |
|
530 gpointer data2); |
|
531 register GMarshalFunc_VOID__PARAM callback; |
|
532 register GCClosure *cc = (GCClosure*) closure; |
|
533 register gpointer data1, data2; |
|
534 |
|
535 g_return_if_fail (n_param_values == 2); |
|
536 |
|
537 if (G_CCLOSURE_SWAP_DATA (closure)) |
|
538 { |
|
539 data1 = closure->data; |
|
540 data2 = g_value_peek_pointer (param_values + 0); |
|
541 } |
|
542 else |
|
543 { |
|
544 data1 = g_value_peek_pointer (param_values + 0); |
|
545 data2 = closure->data; |
|
546 } |
|
547 callback = (GMarshalFunc_VOID__PARAM) (marshal_data ? marshal_data : cc->callback); |
|
548 |
|
549 callback (data1, |
|
550 g_marshal_value_peek_param (param_values + 1), |
|
551 data2); |
|
552 } |
|
553 |
|
554 /* VOID:BOXED (./gmarshal.list:40) */ |
|
555 EXPORT_C void |
|
556 g_cclosure_marshal_VOID__BOXED (GClosure *closure, |
|
557 GValue *return_value, |
|
558 guint n_param_values, |
|
559 const GValue *param_values, |
|
560 gpointer invocation_hint, |
|
561 gpointer marshal_data) |
|
562 { |
|
563 typedef void (*GMarshalFunc_VOID__BOXED) (gpointer data1, |
|
564 gpointer arg_1, |
|
565 gpointer data2); |
|
566 register GMarshalFunc_VOID__BOXED callback; |
|
567 register GCClosure *cc = (GCClosure*) closure; |
|
568 register gpointer data1, data2; |
|
569 |
|
570 g_return_if_fail (n_param_values == 2); |
|
571 |
|
572 if (G_CCLOSURE_SWAP_DATA (closure)) |
|
573 { |
|
574 data1 = closure->data; |
|
575 data2 = g_value_peek_pointer (param_values + 0); |
|
576 } |
|
577 else |
|
578 { |
|
579 data1 = g_value_peek_pointer (param_values + 0); |
|
580 data2 = closure->data; |
|
581 } |
|
582 callback = (GMarshalFunc_VOID__BOXED) (marshal_data ? marshal_data : cc->callback); |
|
583 |
|
584 callback (data1, |
|
585 g_marshal_value_peek_boxed (param_values + 1), |
|
586 data2); |
|
587 } |
|
588 |
|
589 /* VOID:POINTER (./gmarshal.list:41) */ |
|
590 EXPORT_C void |
|
591 g_cclosure_marshal_VOID__POINTER (GClosure *closure, |
|
592 GValue *return_value, |
|
593 guint n_param_values, |
|
594 const GValue *param_values, |
|
595 gpointer invocation_hint, |
|
596 gpointer marshal_data) |
|
597 { |
|
598 typedef void (*GMarshalFunc_VOID__POINTER) (gpointer data1, |
|
599 gpointer arg_1, |
|
600 gpointer data2); |
|
601 register GMarshalFunc_VOID__POINTER callback; |
|
602 register GCClosure *cc = (GCClosure*) closure; |
|
603 register gpointer data1, data2; |
|
604 |
|
605 g_return_if_fail (n_param_values == 2); |
|
606 |
|
607 if (G_CCLOSURE_SWAP_DATA (closure)) |
|
608 { |
|
609 data1 = closure->data; |
|
610 data2 = g_value_peek_pointer (param_values + 0); |
|
611 } |
|
612 else |
|
613 { |
|
614 data1 = g_value_peek_pointer (param_values + 0); |
|
615 data2 = closure->data; |
|
616 } |
|
617 callback = (GMarshalFunc_VOID__POINTER) (marshal_data ? marshal_data : cc->callback); |
|
618 |
|
619 callback (data1, |
|
620 g_marshal_value_peek_pointer (param_values + 1), |
|
621 data2); |
|
622 } |
|
623 |
|
624 /* VOID:OBJECT (./gmarshal.list:42) */ |
|
625 EXPORT_C void |
|
626 g_cclosure_marshal_VOID__OBJECT (GClosure *closure, |
|
627 GValue *return_value, |
|
628 guint n_param_values, |
|
629 const GValue *param_values, |
|
630 gpointer invocation_hint, |
|
631 gpointer marshal_data) |
|
632 { |
|
633 typedef void (*GMarshalFunc_VOID__OBJECT) (gpointer data1, |
|
634 gpointer arg_1, |
|
635 gpointer data2); |
|
636 register GMarshalFunc_VOID__OBJECT callback; |
|
637 register GCClosure *cc = (GCClosure*) closure; |
|
638 register gpointer data1, data2; |
|
639 |
|
640 g_return_if_fail (n_param_values == 2); |
|
641 |
|
642 if (G_CCLOSURE_SWAP_DATA (closure)) |
|
643 { |
|
644 data1 = closure->data; |
|
645 data2 = g_value_peek_pointer (param_values + 0); |
|
646 } |
|
647 else |
|
648 { |
|
649 data1 = g_value_peek_pointer (param_values + 0); |
|
650 data2 = closure->data; |
|
651 } |
|
652 callback = (GMarshalFunc_VOID__OBJECT) (marshal_data ? marshal_data : cc->callback); |
|
653 |
|
654 callback (data1, |
|
655 g_marshal_value_peek_object (param_values + 1), |
|
656 data2); |
|
657 } |
|
658 |
|
659 /* VOID:UINT,POINTER (./gmarshal.list:45) */ |
|
660 EXPORT_C void |
|
661 g_cclosure_marshal_VOID__UINT_POINTER (GClosure *closure, |
|
662 GValue *return_value, |
|
663 guint n_param_values, |
|
664 const GValue *param_values, |
|
665 gpointer invocation_hint, |
|
666 gpointer marshal_data) |
|
667 { |
|
668 typedef void (*GMarshalFunc_VOID__UINT_POINTER) (gpointer data1, |
|
669 guint arg_1, |
|
670 gpointer arg_2, |
|
671 gpointer data2); |
|
672 register GMarshalFunc_VOID__UINT_POINTER callback; |
|
673 register GCClosure *cc = (GCClosure*) closure; |
|
674 register gpointer data1, data2; |
|
675 |
|
676 g_return_if_fail (n_param_values == 3); |
|
677 |
|
678 if (G_CCLOSURE_SWAP_DATA (closure)) |
|
679 { |
|
680 data1 = closure->data; |
|
681 data2 = g_value_peek_pointer (param_values + 0); |
|
682 } |
|
683 else |
|
684 { |
|
685 data1 = g_value_peek_pointer (param_values + 0); |
|
686 data2 = closure->data; |
|
687 } |
|
688 callback = (GMarshalFunc_VOID__UINT_POINTER) (marshal_data ? marshal_data : cc->callback); |
|
689 |
|
690 callback (data1, |
|
691 g_marshal_value_peek_uint (param_values + 1), |
|
692 g_marshal_value_peek_pointer (param_values + 2), |
|
693 data2); |
|
694 } |
|
695 |
|
696 /* BOOL:FLAGS (./gmarshal.list:46) */ |
|
697 EXPORT_C void |
|
698 g_cclosure_marshal_BOOLEAN__FLAGS (GClosure *closure, |
|
699 GValue *return_value, |
|
700 guint n_param_values, |
|
701 const GValue *param_values, |
|
702 gpointer invocation_hint, |
|
703 gpointer marshal_data) |
|
704 { |
|
705 typedef gboolean (*GMarshalFunc_BOOLEAN__FLAGS) (gpointer data1, |
|
706 guint arg_1, |
|
707 gpointer data2); |
|
708 register GMarshalFunc_BOOLEAN__FLAGS callback; |
|
709 register GCClosure *cc = (GCClosure*) closure; |
|
710 register gpointer data1, data2; |
|
711 gboolean v_return; |
|
712 |
|
713 g_return_if_fail (return_value != NULL); |
|
714 g_return_if_fail (n_param_values == 2); |
|
715 |
|
716 if (G_CCLOSURE_SWAP_DATA (closure)) |
|
717 { |
|
718 data1 = closure->data; |
|
719 data2 = g_value_peek_pointer (param_values + 0); |
|
720 } |
|
721 else |
|
722 { |
|
723 data1 = g_value_peek_pointer (param_values + 0); |
|
724 data2 = closure->data; |
|
725 } |
|
726 callback = (GMarshalFunc_BOOLEAN__FLAGS) (marshal_data ? marshal_data : cc->callback); |
|
727 |
|
728 v_return = callback (data1, |
|
729 g_marshal_value_peek_flags (param_values + 1), |
|
730 data2); |
|
731 |
|
732 g_value_set_boolean (return_value, v_return); |
|
733 } |
|
734 |
|
735 /* STRING:OBJECT,POINTER (./gmarshal.list:47) */ |
|
736 EXPORT_C void |
|
737 g_cclosure_marshal_STRING__OBJECT_POINTER (GClosure *closure, |
|
738 GValue *return_value, |
|
739 guint n_param_values, |
|
740 const GValue *param_values, |
|
741 gpointer invocation_hint, |
|
742 gpointer marshal_data) |
|
743 { |
|
744 typedef gchar* (*GMarshalFunc_STRING__OBJECT_POINTER) (gpointer data1, |
|
745 gpointer arg_1, |
|
746 gpointer arg_2, |
|
747 gpointer data2); |
|
748 register GMarshalFunc_STRING__OBJECT_POINTER callback; |
|
749 register GCClosure *cc = (GCClosure*) closure; |
|
750 register gpointer data1, data2; |
|
751 gchar* v_return; |
|
752 |
|
753 g_return_if_fail (return_value != NULL); |
|
754 g_return_if_fail (n_param_values == 3); |
|
755 |
|
756 if (G_CCLOSURE_SWAP_DATA (closure)) |
|
757 { |
|
758 data1 = closure->data; |
|
759 data2 = g_value_peek_pointer (param_values + 0); |
|
760 } |
|
761 else |
|
762 { |
|
763 data1 = g_value_peek_pointer (param_values + 0); |
|
764 data2 = closure->data; |
|
765 } |
|
766 callback = (GMarshalFunc_STRING__OBJECT_POINTER) (marshal_data ? marshal_data : cc->callback); |
|
767 |
|
768 v_return = callback (data1, |
|
769 g_marshal_value_peek_object (param_values + 1), |
|
770 g_marshal_value_peek_pointer (param_values + 2), |
|
771 data2); |
|
772 |
|
773 g_value_take_string (return_value, v_return); |
|
774 } |
|
775 |