← Back to branch summary

~valavanisalex/ubuntu/oneiric/inkscape/inkscape_0.48.1-2ubuntu5

« back to all changes in this revision

Viewing changes to src/helper/sp-marshal.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Wolfram Quester
  • Date: 2004-06-02 10:35:45 UTC
  • Revision ID: james.westby@ubuntu.com-20040602103545-q3x0q6xd2k1yj0fr
Tags: upstream-0.38.1
Import upstream version 0.38.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/helper/sp-marshal.cpp
 
1
#include "helper/sp-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_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 */
 
49
 
 
50
 
 
51
/* NONE:NONE (./sp-marshal.list:2) */
 
52
 
 
53
/* NONE:UINT (./sp-marshal.list:3) */
 
54
 
 
55
/* NONE:POINTER (./sp-marshal.list:4) */
 
56
 
 
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;
 
73
 
 
74
  g_return_if_fail (n_param_values == 3);
 
75
 
 
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);
 
87
 
 
88
  callback (data1,
 
89
            g_marshal_value_peek_pointer (param_values + 1),
 
90
            g_marshal_value_peek_boolean (param_values + 2),
 
91
            data2);
 
92
}
 
93
 
 
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;
 
110
 
 
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_VOID__POINTER_UINT) (marshal_data ? marshal_data : cc->callback);
 
124
 
 
125
  callback (data1,
 
126
            g_marshal_value_peek_pointer (param_values + 1),
 
127
            g_marshal_value_peek_uint (param_values + 2),
 
128
            data2);
 
129
}
 
130
 
 
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;
 
147
 
 
148
  g_return_if_fail (n_param_values == 3);
 
149
 
 
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);
 
161
 
 
162
  callback (data1,
 
163
            g_marshal_value_peek_pointer (param_values + 1),
 
164
            g_marshal_value_peek_double (param_values + 2),
 
165
            data2);
 
166
}
 
167
 
 
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;
 
184
 
 
185
  g_return_if_fail (n_param_values == 3);
 
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__DOUBLE_DOUBLE) (marshal_data ? marshal_data : cc->callback);
 
198
 
 
199
  callback (data1,
 
200
            g_marshal_value_peek_double (param_values + 1),
 
201
            g_marshal_value_peek_double (param_values + 2),
 
202
            data2);
 
203
}
 
204
 
 
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;
 
221
 
 
222
  g_return_if_fail (n_param_values == 3);
 
223
 
 
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);
 
235
 
 
236
  callback (data1,
 
237
            g_marshal_value_peek_string (param_values + 1),
 
238
            g_marshal_value_peek_boolean (param_values + 2),
 
239
            data2);
 
240
}
 
241
 
 
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;
 
257
 
 
258
  g_return_if_fail (return_value != NULL);
 
259
  g_return_if_fail (n_param_values == 1);
 
260
 
 
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);
 
272
 
 
273
  v_return = callback (data1,
 
274
                       data2);
 
275
 
 
276
  g_value_set_boolean (return_value, v_return);
 
277
}
 
278
 
 
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;
 
295
 
 
296
  g_return_if_fail (return_value != NULL);
 
297
  g_return_if_fail (n_param_values == 2);
 
298
 
 
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);
 
310
 
 
311
  v_return = callback (data1,
 
312
                       g_marshal_value_peek_uint (param_values + 1),
 
313
                       data2);
 
314
 
 
315
  g_value_set_boolean (return_value, v_return);
 
316
}
 
317
 
 
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;
 
334
 
 
335
  g_return_if_fail (return_value != NULL);
 
336
  g_return_if_fail (n_param_values == 2);
 
337
 
 
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);
 
349
 
 
350
  v_return = callback (data1,
 
351
                       g_marshal_value_peek_pointer (param_values + 1),
 
352
                       data2);
 
353
 
 
354
  g_value_set_boolean (return_value, v_return);
 
355
}
 
356
 
 
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;
 
374
 
 
375
  g_return_if_fail (return_value != NULL);
 
376
  g_return_if_fail (n_param_values == 3);
 
377
 
 
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);
 
389
 
 
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);
 
394
 
 
395
  g_value_set_boolean (return_value, v_return);
 
396
}
 
397
 
 
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;
 
415
 
 
416
  g_return_if_fail (return_value != NULL);
 
417
  g_return_if_fail (n_param_values == 3);
 
418
 
 
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);
 
430
 
 
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);
 
435
 
 
436
  g_value_set_boolean (return_value, v_return);
 
437
}
 
438
 
 
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;
 
456
 
 
457
  g_return_if_fail (return_value != NULL);
 
458
  g_return_if_fail (n_param_values == 3);
 
459
 
 
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);
 
471
 
 
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);
 
476
 
 
477
  g_value_set_int (return_value, v_return);
 
478
}
 
479
 
 
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;
 
497
 
 
498
  g_return_if_fail (return_value != NULL);
 
499
  g_return_if_fail (n_param_values == 3);
 
500
 
 
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);
 
512
 
 
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);
 
517
 
 
518
  g_value_set_double (return_value, v_return);
 
519
}
 
520