1 #include "helper/sp-marshal.h"
3 #include <glib-object.h>
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_char (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 #else /* !G_ENABLE_DEBUG */
26 /* WARNING: This code accesses GValues directly, which is UNSUPPORTED API.
27 * Do not access GValues directly in your code. Instead, use the
28 * g_value_get_*() functions
29 */
30 #define g_marshal_value_peek_boolean(v) (v)->data[0].v_int
31 #define g_marshal_value_peek_char(v) (v)->data[0].v_int
32 #define g_marshal_value_peek_uchar(v) (v)->data[0].v_uint
33 #define g_marshal_value_peek_int(v) (v)->data[0].v_int
34 #define g_marshal_value_peek_uint(v) (v)->data[0].v_uint
35 #define g_marshal_value_peek_long(v) (v)->data[0].v_long
36 #define g_marshal_value_peek_ulong(v) (v)->data[0].v_ulong
37 #define g_marshal_value_peek_int64(v) (v)->data[0].v_int64
38 #define g_marshal_value_peek_uint64(v) (v)->data[0].v_uint64
39 #define g_marshal_value_peek_enum(v) (v)->data[0].v_int
40 #define g_marshal_value_peek_flags(v) (v)->data[0].v_uint
41 #define g_marshal_value_peek_float(v) (v)->data[0].v_float
42 #define g_marshal_value_peek_double(v) (v)->data[0].v_double
43 #define g_marshal_value_peek_string(v) (v)->data[0].v_pointer
44 #define g_marshal_value_peek_param(v) (v)->data[0].v_pointer
45 #define g_marshal_value_peek_boxed(v) (v)->data[0].v_pointer
46 #define g_marshal_value_peek_pointer(v) (v)->data[0].v_pointer
47 #define g_marshal_value_peek_object(v) (v)->data[0].v_pointer
48 #endif /* !G_ENABLE_DEBUG */
51 /* NONE:NONE (sp-marshal.list:2) */
53 /* NONE:UINT (sp-marshal.list:3) */
55 /* NONE:POINTER (sp-marshal.list:4) */
57 /* NONE:POINTER,BOOLEAN (sp-marshal.list:5) */
58 void
59 sp_marshal_VOID__POINTER_BOOLEAN (GClosure *closure,
60 GValue *return_value,
61 guint n_param_values,
62 const GValue *param_values,
63 gpointer invocation_hint,
64 gpointer marshal_data)
65 {
66 typedef void (*GMarshalFunc_VOID__POINTER_BOOLEAN) (gpointer data1,
67 gpointer arg_1,
68 gboolean arg_2,
69 gpointer data2);
70 register GMarshalFunc_VOID__POINTER_BOOLEAN callback;
71 register GCClosure *cc = (GCClosure*) closure;
72 register gpointer data1, data2;
74 g_return_if_fail (n_param_values == 3);
76 if (G_CCLOSURE_SWAP_DATA (closure))
77 {
78 data1 = closure->data;
79 data2 = g_value_peek_pointer (param_values + 0);
80 }
81 else
82 {
83 data1 = g_value_peek_pointer (param_values + 0);
84 data2 = closure->data;
85 }
86 callback = (GMarshalFunc_VOID__POINTER_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
88 callback (data1,
89 g_marshal_value_peek_pointer (param_values + 1),
90 g_marshal_value_peek_boolean (param_values + 2),
91 data2);
92 }
94 /* NONE:POINTER,UINT (sp-marshal.list:6) */
95 void
96 sp_marshal_VOID__POINTER_UINT (GClosure *closure,
97 GValue *return_value,
98 guint n_param_values,
99 const GValue *param_values,
100 gpointer invocation_hint,
101 gpointer marshal_data)
102 {
103 typedef void (*GMarshalFunc_VOID__POINTER_UINT) (gpointer data1,
104 gpointer arg_1,
105 guint arg_2,
106 gpointer data2);
107 register GMarshalFunc_VOID__POINTER_UINT callback;
108 register GCClosure *cc = (GCClosure*) closure;
109 register gpointer data1, data2;
111 g_return_if_fail (n_param_values == 3);
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_VOID__POINTER_UINT) (marshal_data ? marshal_data : cc->callback);
125 callback (data1,
126 g_marshal_value_peek_pointer (param_values + 1),
127 g_marshal_value_peek_uint (param_values + 2),
128 data2);
129 }
131 /* NONE:POINTER,DOUBLE (sp-marshal.list:7) */
132 void
133 sp_marshal_VOID__POINTER_DOUBLE (GClosure *closure,
134 GValue *return_value,
135 guint n_param_values,
136 const GValue *param_values,
137 gpointer invocation_hint,
138 gpointer marshal_data)
139 {
140 typedef void (*GMarshalFunc_VOID__POINTER_DOUBLE) (gpointer data1,
141 gpointer arg_1,
142 gdouble arg_2,
143 gpointer data2);
144 register GMarshalFunc_VOID__POINTER_DOUBLE callback;
145 register GCClosure *cc = (GCClosure*) closure;
146 register gpointer data1, data2;
148 g_return_if_fail (n_param_values == 3);
150 if (G_CCLOSURE_SWAP_DATA (closure))
151 {
152 data1 = closure->data;
153 data2 = g_value_peek_pointer (param_values + 0);
154 }
155 else
156 {
157 data1 = g_value_peek_pointer (param_values + 0);
158 data2 = closure->data;
159 }
160 callback = (GMarshalFunc_VOID__POINTER_DOUBLE) (marshal_data ? marshal_data : cc->callback);
162 callback (data1,
163 g_marshal_value_peek_pointer (param_values + 1),
164 g_marshal_value_peek_double (param_values + 2),
165 data2);
166 }
168 /* NONE:DOUBLE,DOUBLE (sp-marshal.list:8) */
169 void
170 sp_marshal_VOID__DOUBLE_DOUBLE (GClosure *closure,
171 GValue *return_value,
172 guint n_param_values,
173 const GValue *param_values,
174 gpointer invocation_hint,
175 gpointer marshal_data)
176 {
177 typedef void (*GMarshalFunc_VOID__DOUBLE_DOUBLE) (gpointer data1,
178 gdouble arg_1,
179 gdouble arg_2,
180 gpointer data2);
181 register GMarshalFunc_VOID__DOUBLE_DOUBLE callback;
182 register GCClosure *cc = (GCClosure*) closure;
183 register gpointer data1, data2;
185 g_return_if_fail (n_param_values == 3);
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__DOUBLE_DOUBLE) (marshal_data ? marshal_data : cc->callback);
199 callback (data1,
200 g_marshal_value_peek_double (param_values + 1),
201 g_marshal_value_peek_double (param_values + 2),
202 data2);
203 }
205 /* NONE:STRING,BOOL (sp-marshal.list:9) */
206 void
207 sp_marshal_VOID__STRING_BOOLEAN (GClosure *closure,
208 GValue *return_value,
209 guint n_param_values,
210 const GValue *param_values,
211 gpointer invocation_hint,
212 gpointer marshal_data)
213 {
214 typedef void (*GMarshalFunc_VOID__STRING_BOOLEAN) (gpointer data1,
215 gpointer arg_1,
216 gboolean arg_2,
217 gpointer data2);
218 register GMarshalFunc_VOID__STRING_BOOLEAN callback;
219 register GCClosure *cc = (GCClosure*) closure;
220 register gpointer data1, data2;
222 g_return_if_fail (n_param_values == 3);
224 if (G_CCLOSURE_SWAP_DATA (closure))
225 {
226 data1 = closure->data;
227 data2 = g_value_peek_pointer (param_values + 0);
228 }
229 else
230 {
231 data1 = g_value_peek_pointer (param_values + 0);
232 data2 = closure->data;
233 }
234 callback = (GMarshalFunc_VOID__STRING_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
236 callback (data1,
237 g_marshal_value_peek_string (param_values + 1),
238 g_marshal_value_peek_boolean (param_values + 2),
239 data2);
240 }
242 /* BOOLEAN:NONE (sp-marshal.list:10) */
243 void
244 sp_marshal_BOOLEAN__VOID (GClosure *closure,
245 GValue *return_value,
246 guint n_param_values,
247 const GValue *param_values,
248 gpointer invocation_hint,
249 gpointer marshal_data)
250 {
251 typedef gboolean (*GMarshalFunc_BOOLEAN__VOID) (gpointer data1,
252 gpointer data2);
253 register GMarshalFunc_BOOLEAN__VOID callback;
254 register GCClosure *cc = (GCClosure*) closure;
255 register gpointer data1, data2;
256 gboolean v_return;
258 g_return_if_fail (return_value != NULL);
259 g_return_if_fail (n_param_values == 1);
261 if (G_CCLOSURE_SWAP_DATA (closure))
262 {
263 data1 = closure->data;
264 data2 = g_value_peek_pointer (param_values + 0);
265 }
266 else
267 {
268 data1 = g_value_peek_pointer (param_values + 0);
269 data2 = closure->data;
270 }
271 callback = (GMarshalFunc_BOOLEAN__VOID) (marshal_data ? marshal_data : cc->callback);
273 v_return = callback (data1,
274 data2);
276 g_value_set_boolean (return_value, v_return);
277 }
279 /* BOOLEAN:UINT (sp-marshal.list:11) */
280 void
281 sp_marshal_BOOLEAN__UINT (GClosure *closure,
282 GValue *return_value,
283 guint n_param_values,
284 const GValue *param_values,
285 gpointer invocation_hint,
286 gpointer marshal_data)
287 {
288 typedef gboolean (*GMarshalFunc_BOOLEAN__UINT) (gpointer data1,
289 guint arg_1,
290 gpointer data2);
291 register GMarshalFunc_BOOLEAN__UINT callback;
292 register GCClosure *cc = (GCClosure*) closure;
293 register gpointer data1, data2;
294 gboolean v_return;
296 g_return_if_fail (return_value != NULL);
297 g_return_if_fail (n_param_values == 2);
299 if (G_CCLOSURE_SWAP_DATA (closure))
300 {
301 data1 = closure->data;
302 data2 = g_value_peek_pointer (param_values + 0);
303 }
304 else
305 {
306 data1 = g_value_peek_pointer (param_values + 0);
307 data2 = closure->data;
308 }
309 callback = (GMarshalFunc_BOOLEAN__UINT) (marshal_data ? marshal_data : cc->callback);
311 v_return = callback (data1,
312 g_marshal_value_peek_uint (param_values + 1),
313 data2);
315 g_value_set_boolean (return_value, v_return);
316 }
318 /* BOOLEAN:POINTER (sp-marshal.list:12) */
319 void
320 sp_marshal_BOOLEAN__POINTER (GClosure *closure,
321 GValue *return_value,
322 guint n_param_values,
323 const GValue *param_values,
324 gpointer invocation_hint,
325 gpointer marshal_data)
326 {
327 typedef gboolean (*GMarshalFunc_BOOLEAN__POINTER) (gpointer data1,
328 gpointer arg_1,
329 gpointer data2);
330 register GMarshalFunc_BOOLEAN__POINTER callback;
331 register GCClosure *cc = (GCClosure*) closure;
332 register gpointer data1, data2;
333 gboolean v_return;
335 g_return_if_fail (return_value != NULL);
336 g_return_if_fail (n_param_values == 2);
338 if (G_CCLOSURE_SWAP_DATA (closure))
339 {
340 data1 = closure->data;
341 data2 = g_value_peek_pointer (param_values + 0);
342 }
343 else
344 {
345 data1 = g_value_peek_pointer (param_values + 0);
346 data2 = closure->data;
347 }
348 callback = (GMarshalFunc_BOOLEAN__POINTER) (marshal_data ? marshal_data : cc->callback);
350 v_return = callback (data1,
351 g_marshal_value_peek_pointer (param_values + 1),
352 data2);
354 g_value_set_boolean (return_value, v_return);
355 }
357 /* BOOLEAN:POINTER,UINT (sp-marshal.list:13) */
358 void
359 sp_marshal_BOOLEAN__POINTER_UINT (GClosure *closure,
360 GValue *return_value,
361 guint n_param_values,
362 const GValue *param_values,
363 gpointer invocation_hint,
364 gpointer marshal_data)
365 {
366 typedef gboolean (*GMarshalFunc_BOOLEAN__POINTER_UINT) (gpointer data1,
367 gpointer arg_1,
368 guint arg_2,
369 gpointer data2);
370 register GMarshalFunc_BOOLEAN__POINTER_UINT callback;
371 register GCClosure *cc = (GCClosure*) closure;
372 register gpointer data1, data2;
373 gboolean v_return;
375 g_return_if_fail (return_value != NULL);
376 g_return_if_fail (n_param_values == 3);
378 if (G_CCLOSURE_SWAP_DATA (closure))
379 {
380 data1 = closure->data;
381 data2 = g_value_peek_pointer (param_values + 0);
382 }
383 else
384 {
385 data1 = g_value_peek_pointer (param_values + 0);
386 data2 = closure->data;
387 }
388 callback = (GMarshalFunc_BOOLEAN__POINTER_UINT) (marshal_data ? marshal_data : cc->callback);
390 v_return = callback (data1,
391 g_marshal_value_peek_pointer (param_values + 1),
392 g_marshal_value_peek_uint (param_values + 2),
393 data2);
395 g_value_set_boolean (return_value, v_return);
396 }
398 /* BOOLEAN:POINTER,POINTER (sp-marshal.list:14) */
399 void
400 sp_marshal_BOOLEAN__POINTER_POINTER (GClosure *closure,
401 GValue *return_value,
402 guint n_param_values,
403 const GValue *param_values,
404 gpointer invocation_hint,
405 gpointer marshal_data)
406 {
407 typedef gboolean (*GMarshalFunc_BOOLEAN__POINTER_POINTER) (gpointer data1,
408 gpointer arg_1,
409 gpointer arg_2,
410 gpointer data2);
411 register GMarshalFunc_BOOLEAN__POINTER_POINTER callback;
412 register GCClosure *cc = (GCClosure*) closure;
413 register gpointer data1, data2;
414 gboolean v_return;
416 g_return_if_fail (return_value != NULL);
417 g_return_if_fail (n_param_values == 3);
419 if (G_CCLOSURE_SWAP_DATA (closure))
420 {
421 data1 = closure->data;
422 data2 = g_value_peek_pointer (param_values + 0);
423 }
424 else
425 {
426 data1 = g_value_peek_pointer (param_values + 0);
427 data2 = closure->data;
428 }
429 callback = (GMarshalFunc_BOOLEAN__POINTER_POINTER) (marshal_data ? marshal_data : cc->callback);
431 v_return = callback (data1,
432 g_marshal_value_peek_pointer (param_values + 1),
433 g_marshal_value_peek_pointer (param_values + 2),
434 data2);
436 g_value_set_boolean (return_value, v_return);
437 }
439 /* INT:POINTER,POINTER (sp-marshal.list:15) */
440 void
441 sp_marshal_INT__POINTER_POINTER (GClosure *closure,
442 GValue *return_value,
443 guint n_param_values,
444 const GValue *param_values,
445 gpointer invocation_hint,
446 gpointer marshal_data)
447 {
448 typedef gint (*GMarshalFunc_INT__POINTER_POINTER) (gpointer data1,
449 gpointer arg_1,
450 gpointer arg_2,
451 gpointer data2);
452 register GMarshalFunc_INT__POINTER_POINTER callback;
453 register GCClosure *cc = (GCClosure*) closure;
454 register gpointer data1, data2;
455 gint v_return;
457 g_return_if_fail (return_value != NULL);
458 g_return_if_fail (n_param_values == 3);
460 if (G_CCLOSURE_SWAP_DATA (closure))
461 {
462 data1 = closure->data;
463 data2 = g_value_peek_pointer (param_values + 0);
464 }
465 else
466 {
467 data1 = g_value_peek_pointer (param_values + 0);
468 data2 = closure->data;
469 }
470 callback = (GMarshalFunc_INT__POINTER_POINTER) (marshal_data ? marshal_data : cc->callback);
472 v_return = callback (data1,
473 g_marshal_value_peek_pointer (param_values + 1),
474 g_marshal_value_peek_pointer (param_values + 2),
475 data2);
477 g_value_set_int (return_value, v_return);
478 }
480 /* DOUBLE:POINTER,UINT (sp-marshal.list:16) */
481 void
482 sp_marshal_DOUBLE__POINTER_UINT (GClosure *closure,
483 GValue *return_value,
484 guint n_param_values,
485 const GValue *param_values,
486 gpointer invocation_hint,
487 gpointer marshal_data)
488 {
489 typedef gdouble (*GMarshalFunc_DOUBLE__POINTER_UINT) (gpointer data1,
490 gpointer arg_1,
491 guint arg_2,
492 gpointer data2);
493 register GMarshalFunc_DOUBLE__POINTER_UINT callback;
494 register GCClosure *cc = (GCClosure*) closure;
495 register gpointer data1, data2;
496 gdouble v_return;
498 g_return_if_fail (return_value != NULL);
499 g_return_if_fail (n_param_values == 3);
501 if (G_CCLOSURE_SWAP_DATA (closure))
502 {
503 data1 = closure->data;
504 data2 = g_value_peek_pointer (param_values + 0);
505 }
506 else
507 {
508 data1 = g_value_peek_pointer (param_values + 0);
509 data2 = closure->data;
510 }
511 callback = (GMarshalFunc_DOUBLE__POINTER_UINT) (marshal_data ? marshal_data : cc->callback);
513 v_return = callback (data1,
514 g_marshal_value_peek_pointer (param_values + 1),
515 g_marshal_value_peek_uint (param_values + 2),
516 data2);
518 g_value_set_double (return_value, v_return);
519 }