← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/rhythmbox/oneiric

« back to all changes in this revision

Viewing changes to lib/rb-marshal.c

  • Committer: Bazaar Package Importer
  • Author(s): Rico Tzschichholz
  • Date: 2011-07-29 16:41:38 UTC
  • mto: This revision was merged to the branch mainline in revision 191.
  • Revision ID: james.westby@ubuntu.com-20110729164138-wwicy8nqalm18ck7
Tags: upstream-2.90.1~20110802
Import upstream version 2.90.1~20110802

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/rb-marshal.c
 
1
 
 
2
#ifndef __rb_marshal_MARSHAL_H__
 
3
#define __rb_marshal_MARSHAL_H__
 
4
 
 
5
#include        <glib-object.h>
 
6
 
 
7
G_BEGIN_DECLS
 
8
 
 
9
#ifdef G_ENABLE_DEBUG
 
10
#define g_marshal_value_peek_boolean(v)  g_value_get_boolean (v)
 
11
#define g_marshal_value_peek_char(v)     g_value_get_char (v)
 
12
#define g_marshal_value_peek_uchar(v)    g_value_get_uchar (v)
 
13
#define g_marshal_value_peek_int(v)      g_value_get_int (v)
 
14
#define g_marshal_value_peek_uint(v)     g_value_get_uint (v)
 
15
#define g_marshal_value_peek_long(v)     g_value_get_long (v)
 
16
#define g_marshal_value_peek_ulong(v)    g_value_get_ulong (v)
 
17
#define g_marshal_value_peek_int64(v)    g_value_get_int64 (v)
 
18
#define g_marshal_value_peek_uint64(v)   g_value_get_uint64 (v)
 
19
#define g_marshal_value_peek_enum(v)     g_value_get_enum (v)
 
20
#define g_marshal_value_peek_flags(v)    g_value_get_flags (v)
 
21
#define g_marshal_value_peek_float(v)    g_value_get_float (v)
 
22
#define g_marshal_value_peek_double(v)   g_value_get_double (v)
 
23
#define g_marshal_value_peek_string(v)   (char*) g_value_get_string (v)
 
24
#define g_marshal_value_peek_param(v)    g_value_get_param (v)
 
25
#define g_marshal_value_peek_boxed(v)    g_value_get_boxed (v)
 
26
#define g_marshal_value_peek_pointer(v)  g_value_get_pointer (v)
 
27
#define g_marshal_value_peek_object(v)   g_value_get_object (v)
 
28
#define g_marshal_value_peek_variant(v)  g_value_get_variant (v)
 
29
#else /* !G_ENABLE_DEBUG */
 
30
/* WARNING: This code accesses GValues directly, which is UNSUPPORTED API.
 
31
 *          Do not access GValues directly in your code. Instead, use the
 
32
 *          g_value_get_*() functions
 
33
 */
 
34
#define g_marshal_value_peek_boolean(v)  (v)->data[0].v_int
 
35
#define g_marshal_value_peek_char(v)     (v)->data[0].v_int
 
36
#define g_marshal_value_peek_uchar(v)    (v)->data[0].v_uint
 
37
#define g_marshal_value_peek_int(v)      (v)->data[0].v_int
 
38
#define g_marshal_value_peek_uint(v)     (v)->data[0].v_uint
 
39
#define g_marshal_value_peek_long(v)     (v)->data[0].v_long
 
40
#define g_marshal_value_peek_ulong(v)    (v)->data[0].v_ulong
 
41
#define g_marshal_value_peek_int64(v)    (v)->data[0].v_int64
 
42
#define g_marshal_value_peek_uint64(v)   (v)->data[0].v_uint64
 
43
#define g_marshal_value_peek_enum(v)     (v)->data[0].v_long
 
44
#define g_marshal_value_peek_flags(v)    (v)->data[0].v_ulong
 
45
#define g_marshal_value_peek_float(v)    (v)->data[0].v_float
 
46
#define g_marshal_value_peek_double(v)   (v)->data[0].v_double
 
47
#define g_marshal_value_peek_string(v)   (v)->data[0].v_pointer
 
48
#define g_marshal_value_peek_param(v)    (v)->data[0].v_pointer
 
49
#define g_marshal_value_peek_boxed(v)    (v)->data[0].v_pointer
 
50
#define g_marshal_value_peek_pointer(v)  (v)->data[0].v_pointer
 
51
#define g_marshal_value_peek_object(v)   (v)->data[0].v_pointer
 
52
#define g_marshal_value_peek_variant(v)  (v)->data[0].v_pointer
 
53
#endif /* !G_ENABLE_DEBUG */
 
54
 
 
55
 
 
56
/* BOOLEAN:BOOLEAN,BOOLEAN (./rb-marshal.list:1) */
 
57
extern void rb_marshal_BOOLEAN__BOOLEAN_BOOLEAN (GClosure     *closure,
 
58
                                                 GValue       *return_value,
 
59
                                                 guint         n_param_values,
 
60
                                                 const GValue *param_values,
 
61
                                                 gpointer      invocation_hint,
 
62
                                                 gpointer      marshal_data);
 
63
void
 
64
rb_marshal_BOOLEAN__BOOLEAN_BOOLEAN (GClosure     *closure,
 
65
                                     GValue       *return_value G_GNUC_UNUSED,
 
66
                                     guint         n_param_values,
 
67
                                     const GValue *param_values,
 
68
                                     gpointer      invocation_hint G_GNUC_UNUSED,
 
69
                                     gpointer      marshal_data)
 
70
{
 
71
  typedef gboolean (*GMarshalFunc_BOOLEAN__BOOLEAN_BOOLEAN) (gpointer     data1,
 
72
                                                             gboolean     arg_1,
 
73
                                                             gboolean     arg_2,
 
74
                                                             gpointer     data2);
 
75
  register GMarshalFunc_BOOLEAN__BOOLEAN_BOOLEAN callback;
 
76
  register GCClosure *cc = (GCClosure*) closure;
 
77
  register gpointer data1, data2;
 
78
  gboolean v_return;
 
79
 
 
80
  g_return_if_fail (return_value != NULL);
 
81
  g_return_if_fail (n_param_values == 3);
 
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_BOOLEAN__BOOLEAN_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
 
94
 
 
95
  v_return = callback (data1,
 
96
                       g_marshal_value_peek_boolean (param_values + 1),
 
97
                       g_marshal_value_peek_boolean (param_values + 2),
 
98
                       data2);
 
99
 
 
100
  g_value_set_boolean (return_value, v_return);
 
101
}
 
102
 
 
103
/* BOOLEAN:BOOLEAN,BOOLEAN,BOOLEAN (./rb-marshal.list:2) */
 
104
extern void rb_marshal_BOOLEAN__BOOLEAN_BOOLEAN_BOOLEAN (GClosure     *closure,
 
105
                                                         GValue       *return_value,
 
106
                                                         guint         n_param_values,
 
107
                                                         const GValue *param_values,
 
108
                                                         gpointer      invocation_hint,
 
109
                                                         gpointer      marshal_data);
 
110
void
 
111
rb_marshal_BOOLEAN__BOOLEAN_BOOLEAN_BOOLEAN (GClosure     *closure,
 
112
                                             GValue       *return_value G_GNUC_UNUSED,
 
113
                                             guint         n_param_values,
 
114
                                             const GValue *param_values,
 
115
                                             gpointer      invocation_hint G_GNUC_UNUSED,
 
116
                                             gpointer      marshal_data)
 
117
{
 
118
  typedef gboolean (*GMarshalFunc_BOOLEAN__BOOLEAN_BOOLEAN_BOOLEAN) (gpointer     data1,
 
119
                                                                     gboolean     arg_1,
 
120
                                                                     gboolean     arg_2,
 
121
                                                                     gboolean     arg_3,
 
122
                                                                     gpointer     data2);
 
123
  register GMarshalFunc_BOOLEAN__BOOLEAN_BOOLEAN_BOOLEAN callback;
 
124
  register GCClosure *cc = (GCClosure*) closure;
 
125
  register gpointer data1, data2;
 
126
  gboolean v_return;
 
127
 
 
128
  g_return_if_fail (return_value != NULL);
 
129
  g_return_if_fail (n_param_values == 4);
 
130
 
 
131
  if (G_CCLOSURE_SWAP_DATA (closure))
 
132
    {
 
133
      data1 = closure->data;
 
134
      data2 = g_value_peek_pointer (param_values + 0);
 
135
    }
 
136
  else
 
137
    {
 
138
      data1 = g_value_peek_pointer (param_values + 0);
 
139
      data2 = closure->data;
 
140
    }
 
141
  callback = (GMarshalFunc_BOOLEAN__BOOLEAN_BOOLEAN_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
 
142
 
 
143
  v_return = callback (data1,
 
144
                       g_marshal_value_peek_boolean (param_values + 1),
 
145
                       g_marshal_value_peek_boolean (param_values + 2),
 
146
                       g_marshal_value_peek_boolean (param_values + 3),
 
147
                       data2);
 
148
 
 
149
  g_value_set_boolean (return_value, v_return);
 
150
}
 
151
 
 
152
/* BOOLEAN:BOXED (./rb-marshal.list:3) */
 
153
extern void rb_marshal_BOOLEAN__BOXED (GClosure     *closure,
 
154
                                       GValue       *return_value,
 
155
                                       guint         n_param_values,
 
156
                                       const GValue *param_values,
 
157
                                       gpointer      invocation_hint,
 
158
                                       gpointer      marshal_data);
 
159
void
 
160
rb_marshal_BOOLEAN__BOXED (GClosure     *closure,
 
161
                           GValue       *return_value G_GNUC_UNUSED,
 
162
                           guint         n_param_values,
 
163
                           const GValue *param_values,
 
164
                           gpointer      invocation_hint G_GNUC_UNUSED,
 
165
                           gpointer      marshal_data)
 
166
{
 
167
  typedef gboolean (*GMarshalFunc_BOOLEAN__BOXED) (gpointer     data1,
 
168
                                                   gpointer     arg_1,
 
169
                                                   gpointer     data2);
 
170
  register GMarshalFunc_BOOLEAN__BOXED callback;
 
171
  register GCClosure *cc = (GCClosure*) closure;
 
172
  register gpointer data1, data2;
 
173
  gboolean v_return;
 
174
 
 
175
  g_return_if_fail (return_value != NULL);
 
176
  g_return_if_fail (n_param_values == 2);
 
177
 
 
178
  if (G_CCLOSURE_SWAP_DATA (closure))
 
179
    {
 
180
      data1 = closure->data;
 
181
      data2 = g_value_peek_pointer (param_values + 0);
 
182
    }
 
183
  else
 
184
    {
 
185
      data1 = g_value_peek_pointer (param_values + 0);
 
186
      data2 = closure->data;
 
187
    }
 
188
  callback = (GMarshalFunc_BOOLEAN__BOXED) (marshal_data ? marshal_data : cc->callback);
 
189
 
 
190
  v_return = callback (data1,
 
191
                       g_marshal_value_peek_boxed (param_values + 1),
 
192
                       data2);
 
193
 
 
194
  g_value_set_boolean (return_value, v_return);
 
195
}
 
196
 
 
197
/* BOOLEAN:OBJECT (./rb-marshal.list:4) */
 
198
extern void rb_marshal_BOOLEAN__OBJECT (GClosure     *closure,
 
199
                                        GValue       *return_value,
 
200
                                        guint         n_param_values,
 
201
                                        const GValue *param_values,
 
202
                                        gpointer      invocation_hint,
 
203
                                        gpointer      marshal_data);
 
204
void
 
205
rb_marshal_BOOLEAN__OBJECT (GClosure     *closure,
 
206
                            GValue       *return_value G_GNUC_UNUSED,
 
207
                            guint         n_param_values,
 
208
                            const GValue *param_values,
 
209
                            gpointer      invocation_hint G_GNUC_UNUSED,
 
210
                            gpointer      marshal_data)
 
211
{
 
212
  typedef gboolean (*GMarshalFunc_BOOLEAN__OBJECT) (gpointer     data1,
 
213
                                                    gpointer     arg_1,
 
214
                                                    gpointer     data2);
 
215
  register GMarshalFunc_BOOLEAN__OBJECT callback;
 
216
  register GCClosure *cc = (GCClosure*) closure;
 
217
  register gpointer data1, data2;
 
218
  gboolean v_return;
 
219
 
 
220
  g_return_if_fail (return_value != NULL);
 
221
  g_return_if_fail (n_param_values == 2);
 
222
 
 
223
  if (G_CCLOSURE_SWAP_DATA (closure))
 
224
    {
 
225
      data1 = closure->data;
 
226
      data2 = g_value_peek_pointer (param_values + 0);
 
227
    }
 
228
  else
 
229
    {
 
230
      data1 = g_value_peek_pointer (param_values + 0);
 
231
      data2 = closure->data;
 
232
    }
 
233
  callback = (GMarshalFunc_BOOLEAN__OBJECT) (marshal_data ? marshal_data : cc->callback);
 
234
 
 
235
  v_return = callback (data1,
 
236
                       g_marshal_value_peek_object (param_values + 1),
 
237
                       data2);
 
238
 
 
239
  g_value_set_boolean (return_value, v_return);
 
240
}
 
241
 
 
242
/* BOOLEAN:POINTER (./rb-marshal.list:5) */
 
243
extern void rb_marshal_BOOLEAN__POINTER (GClosure     *closure,
 
244
                                         GValue       *return_value,
 
245
                                         guint         n_param_values,
 
246
                                         const GValue *param_values,
 
247
                                         gpointer      invocation_hint,
 
248
                                         gpointer      marshal_data);
 
249
void
 
250
rb_marshal_BOOLEAN__POINTER (GClosure     *closure,
 
251
                             GValue       *return_value G_GNUC_UNUSED,
 
252
                             guint         n_param_values,
 
253
                             const GValue *param_values,
 
254
                             gpointer      invocation_hint G_GNUC_UNUSED,
 
255
                             gpointer      marshal_data)
 
256
{
 
257
  typedef gboolean (*GMarshalFunc_BOOLEAN__POINTER) (gpointer     data1,
 
258
                                                     gpointer     arg_1,
 
259
                                                     gpointer     data2);
 
260
  register GMarshalFunc_BOOLEAN__POINTER callback;
 
261
  register GCClosure *cc = (GCClosure*) closure;
 
262
  register gpointer data1, data2;
 
263
  gboolean v_return;
 
264
 
 
265
  g_return_if_fail (return_value != NULL);
 
266
  g_return_if_fail (n_param_values == 2);
 
267
 
 
268
  if (G_CCLOSURE_SWAP_DATA (closure))
 
269
    {
 
270
      data1 = closure->data;
 
271
      data2 = g_value_peek_pointer (param_values + 0);
 
272
    }
 
273
  else
 
274
    {
 
275
      data1 = g_value_peek_pointer (param_values + 0);
 
276
      data2 = closure->data;
 
277
    }
 
278
  callback = (GMarshalFunc_BOOLEAN__POINTER) (marshal_data ? marshal_data : cc->callback);
 
279
 
 
280
  v_return = callback (data1,
 
281
                       g_marshal_value_peek_pointer (param_values + 1),
 
282
                       data2);
 
283
 
 
284
  g_value_set_boolean (return_value, v_return);
 
285
}
 
286
 
 
287
/* BOOLEAN:POINTER,POINTER (./rb-marshal.list:6) */
 
288
extern void rb_marshal_BOOLEAN__POINTER_POINTER (GClosure     *closure,
 
289
                                                 GValue       *return_value,
 
290
                                                 guint         n_param_values,
 
291
                                                 const GValue *param_values,
 
292
                                                 gpointer      invocation_hint,
 
293
                                                 gpointer      marshal_data);
 
294
void
 
295
rb_marshal_BOOLEAN__POINTER_POINTER (GClosure     *closure,
 
296
                                     GValue       *return_value G_GNUC_UNUSED,
 
297
                                     guint         n_param_values,
 
298
                                     const GValue *param_values,
 
299
                                     gpointer      invocation_hint G_GNUC_UNUSED,
 
300
                                     gpointer      marshal_data)
 
301
{
 
302
  typedef gboolean (*GMarshalFunc_BOOLEAN__POINTER_POINTER) (gpointer     data1,
 
303
                                                             gpointer     arg_1,
 
304
                                                             gpointer     arg_2,
 
305
                                                             gpointer     data2);
 
306
  register GMarshalFunc_BOOLEAN__POINTER_POINTER callback;
 
307
  register GCClosure *cc = (GCClosure*) closure;
 
308
  register gpointer data1, data2;
 
309
  gboolean v_return;
 
310
 
 
311
  g_return_if_fail (return_value != NULL);
 
312
  g_return_if_fail (n_param_values == 3);
 
313
 
 
314
  if (G_CCLOSURE_SWAP_DATA (closure))
 
315
    {
 
316
      data1 = closure->data;
 
317
      data2 = g_value_peek_pointer (param_values + 0);
 
318
    }
 
319
  else
 
320
    {
 
321
      data1 = g_value_peek_pointer (param_values + 0);
 
322
      data2 = closure->data;
 
323
    }
 
324
  callback = (GMarshalFunc_BOOLEAN__POINTER_POINTER) (marshal_data ? marshal_data : cc->callback);
 
325
 
 
326
  v_return = callback (data1,
 
327
                       g_marshal_value_peek_pointer (param_values + 1),
 
328
                       g_marshal_value_peek_pointer (param_values + 2),
 
329
                       data2);
 
330
 
 
331
  g_value_set_boolean (return_value, v_return);
 
332
}
 
333
 
 
334
/* BOOLEAN:POINTER,POINTER,POINTER (./rb-marshal.list:7) */
 
335
extern void rb_marshal_BOOLEAN__POINTER_POINTER_POINTER (GClosure     *closure,
 
336
                                                         GValue       *return_value,
 
337
                                                         guint         n_param_values,
 
338
                                                         const GValue *param_values,
 
339
                                                         gpointer      invocation_hint,
 
340
                                                         gpointer      marshal_data);
 
341
void
 
342
rb_marshal_BOOLEAN__POINTER_POINTER_POINTER (GClosure     *closure,
 
343
                                             GValue       *return_value G_GNUC_UNUSED,
 
344
                                             guint         n_param_values,
 
345
                                             const GValue *param_values,
 
346
                                             gpointer      invocation_hint G_GNUC_UNUSED,
 
347
                                             gpointer      marshal_data)
 
348
{
 
349
  typedef gboolean (*GMarshalFunc_BOOLEAN__POINTER_POINTER_POINTER) (gpointer     data1,
 
350
                                                                     gpointer     arg_1,
 
351
                                                                     gpointer     arg_2,
 
352
                                                                     gpointer     arg_3,
 
353
                                                                     gpointer     data2);
 
354
  register GMarshalFunc_BOOLEAN__POINTER_POINTER_POINTER callback;
 
355
  register GCClosure *cc = (GCClosure*) closure;
 
356
  register gpointer data1, data2;
 
357
  gboolean v_return;
 
358
 
 
359
  g_return_if_fail (return_value != NULL);
 
360
  g_return_if_fail (n_param_values == 4);
 
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_BOOLEAN__POINTER_POINTER_POINTER) (marshal_data ? marshal_data : cc->callback);
 
373
 
 
374
  v_return = callback (data1,
 
375
                       g_marshal_value_peek_pointer (param_values + 1),
 
376
                       g_marshal_value_peek_pointer (param_values + 2),
 
377
                       g_marshal_value_peek_pointer (param_values + 3),
 
378
                       data2);
 
379
 
 
380
  g_value_set_boolean (return_value, v_return);
 
381
}
 
382
 
 
383
/* BOOLEAN:STRING,BOOLEAN (./rb-marshal.list:8) */
 
384
extern void rb_marshal_BOOLEAN__STRING_BOOLEAN (GClosure     *closure,
 
385
                                                GValue       *return_value,
 
386
                                                guint         n_param_values,
 
387
                                                const GValue *param_values,
 
388
                                                gpointer      invocation_hint,
 
389
                                                gpointer      marshal_data);
 
390
void
 
391
rb_marshal_BOOLEAN__STRING_BOOLEAN (GClosure     *closure,
 
392
                                    GValue       *return_value G_GNUC_UNUSED,
 
393
                                    guint         n_param_values,
 
394
                                    const GValue *param_values,
 
395
                                    gpointer      invocation_hint G_GNUC_UNUSED,
 
396
                                    gpointer      marshal_data)
 
397
{
 
398
  typedef gboolean (*GMarshalFunc_BOOLEAN__STRING_BOOLEAN) (gpointer     data1,
 
399
                                                            gpointer     arg_1,
 
400
                                                            gboolean     arg_2,
 
401
                                                            gpointer     data2);
 
402
  register GMarshalFunc_BOOLEAN__STRING_BOOLEAN callback;
 
403
  register GCClosure *cc = (GCClosure*) closure;
 
404
  register gpointer data1, data2;
 
405
  gboolean v_return;
 
406
 
 
407
  g_return_if_fail (return_value != NULL);
 
408
  g_return_if_fail (n_param_values == 3);
 
409
 
 
410
  if (G_CCLOSURE_SWAP_DATA (closure))
 
411
    {
 
412
      data1 = closure->data;
 
413
      data2 = g_value_peek_pointer (param_values + 0);
 
414
    }
 
415
  else
 
416
    {
 
417
      data1 = g_value_peek_pointer (param_values + 0);
 
418
      data2 = closure->data;
 
419
    }
 
420
  callback = (GMarshalFunc_BOOLEAN__STRING_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
 
421
 
 
422
  v_return = callback (data1,
 
423
                       g_marshal_value_peek_string (param_values + 1),
 
424
                       g_marshal_value_peek_boolean (param_values + 2),
 
425
                       data2);
 
426
 
 
427
  g_value_set_boolean (return_value, v_return);
 
428
}
 
429
 
 
430
/* BOOLEAN:STRING,STRING,OBJECT (./rb-marshal.list:9) */
 
431
extern void rb_marshal_BOOLEAN__STRING_STRING_OBJECT (GClosure     *closure,
 
432
                                                      GValue       *return_value,
 
433
                                                      guint         n_param_values,
 
434
                                                      const GValue *param_values,
 
435
                                                      gpointer      invocation_hint,
 
436
                                                      gpointer      marshal_data);
 
437
void
 
438
rb_marshal_BOOLEAN__STRING_STRING_OBJECT (GClosure     *closure,
 
439
                                          GValue       *return_value G_GNUC_UNUSED,
 
440
                                          guint         n_param_values,
 
441
                                          const GValue *param_values,
 
442
                                          gpointer      invocation_hint G_GNUC_UNUSED,
 
443
                                          gpointer      marshal_data)
 
444
{
 
445
  typedef gboolean (*GMarshalFunc_BOOLEAN__STRING_STRING_OBJECT) (gpointer     data1,
 
446
                                                                  gpointer     arg_1,
 
447
                                                                  gpointer     arg_2,
 
448
                                                                  gpointer     arg_3,
 
449
                                                                  gpointer     data2);
 
450
  register GMarshalFunc_BOOLEAN__STRING_STRING_OBJECT callback;
 
451
  register GCClosure *cc = (GCClosure*) closure;
 
452
  register gpointer data1, data2;
 
453
  gboolean v_return;
 
454
 
 
455
  g_return_if_fail (return_value != NULL);
 
456
  g_return_if_fail (n_param_values == 4);
 
457
 
 
458
  if (G_CCLOSURE_SWAP_DATA (closure))
 
459
    {
 
460
      data1 = closure->data;
 
461
      data2 = g_value_peek_pointer (param_values + 0);
 
462
    }
 
463
  else
 
464
    {
 
465
      data1 = g_value_peek_pointer (param_values + 0);
 
466
      data2 = closure->data;
 
467
    }
 
468
  callback = (GMarshalFunc_BOOLEAN__STRING_STRING_OBJECT) (marshal_data ? marshal_data : cc->callback);
 
469
 
 
470
  v_return = callback (data1,
 
471
                       g_marshal_value_peek_string (param_values + 1),
 
472
                       g_marshal_value_peek_string (param_values + 2),
 
473
                       g_marshal_value_peek_object (param_values + 3),
 
474
                       data2);
 
475
 
 
476
  g_value_set_boolean (return_value, v_return);
 
477
}
 
478
 
 
479
/* INT:VOID (./rb-marshal.list:10) */
 
480
extern void rb_marshal_INT__VOID (GClosure     *closure,
 
481
                                  GValue       *return_value,
 
482
                                  guint         n_param_values,
 
483
                                  const GValue *param_values,
 
484
                                  gpointer      invocation_hint,
 
485
                                  gpointer      marshal_data);
 
486
void
 
487
rb_marshal_INT__VOID (GClosure     *closure,
 
488
                      GValue       *return_value G_GNUC_UNUSED,
 
489
                      guint         n_param_values,
 
490
                      const GValue *param_values,
 
491
                      gpointer      invocation_hint G_GNUC_UNUSED,
 
492
                      gpointer      marshal_data)
 
493
{
 
494
  typedef gint (*GMarshalFunc_INT__VOID) (gpointer     data1,
 
495
                                          gpointer     data2);
 
496
  register GMarshalFunc_INT__VOID callback;
 
497
  register GCClosure *cc = (GCClosure*) closure;
 
498
  register gpointer data1, data2;
 
499
  gint v_return;
 
500
 
 
501
  g_return_if_fail (return_value != NULL);
 
502
  g_return_if_fail (n_param_values == 1);
 
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_INT__VOID) (marshal_data ? marshal_data : cc->callback);
 
515
 
 
516
  v_return = callback (data1,
 
517
                       data2);
 
518
 
 
519
  g_value_set_int (return_value, v_return);
 
520
}
 
521
 
 
522
/* OBJECT:OBJECT (./rb-marshal.list:11) */
 
523
extern void rb_marshal_OBJECT__OBJECT (GClosure     *closure,
 
524
                                       GValue       *return_value,
 
525
                                       guint         n_param_values,
 
526
                                       const GValue *param_values,
 
527
                                       gpointer      invocation_hint,
 
528
                                       gpointer      marshal_data);
 
529
void
 
530
rb_marshal_OBJECT__OBJECT (GClosure     *closure,
 
531
                           GValue       *return_value G_GNUC_UNUSED,
 
532
                           guint         n_param_values,
 
533
                           const GValue *param_values,
 
534
                           gpointer      invocation_hint G_GNUC_UNUSED,
 
535
                           gpointer      marshal_data)
 
536
{
 
537
  typedef GObject* (*GMarshalFunc_OBJECT__OBJECT) (gpointer     data1,
 
538
                                                   gpointer     arg_1,
 
539
                                                   gpointer     data2);
 
540
  register GMarshalFunc_OBJECT__OBJECT callback;
 
541
  register GCClosure *cc = (GCClosure*) closure;
 
542
  register gpointer data1, data2;
 
543
  GObject* v_return;
 
544
 
 
545
  g_return_if_fail (return_value != NULL);
 
546
  g_return_if_fail (n_param_values == 2);
 
547
 
 
548
  if (G_CCLOSURE_SWAP_DATA (closure))
 
549
    {
 
550
      data1 = closure->data;
 
551
      data2 = g_value_peek_pointer (param_values + 0);
 
552
    }
 
553
  else
 
554
    {
 
555
      data1 = g_value_peek_pointer (param_values + 0);
 
556
      data2 = closure->data;
 
557
    }
 
558
  callback = (GMarshalFunc_OBJECT__OBJECT) (marshal_data ? marshal_data : cc->callback);
 
559
 
 
560
  v_return = callback (data1,
 
561
                       g_marshal_value_peek_object (param_values + 1),
 
562
                       data2);
 
563
 
 
564
  g_value_take_object (return_value, v_return);
 
565
}
 
566
 
 
567
/* OBJECT:OBJECT,OBJECT (./rb-marshal.list:12) */
 
568
extern void rb_marshal_OBJECT__OBJECT_OBJECT (GClosure     *closure,
 
569
                                              GValue       *return_value,
 
570
                                              guint         n_param_values,
 
571
                                              const GValue *param_values,
 
572
                                              gpointer      invocation_hint,
 
573
                                              gpointer      marshal_data);
 
574
void
 
575
rb_marshal_OBJECT__OBJECT_OBJECT (GClosure     *closure,
 
576
                                  GValue       *return_value G_GNUC_UNUSED,
 
577
                                  guint         n_param_values,
 
578
                                  const GValue *param_values,
 
579
                                  gpointer      invocation_hint G_GNUC_UNUSED,
 
580
                                  gpointer      marshal_data)
 
581
{
 
582
  typedef GObject* (*GMarshalFunc_OBJECT__OBJECT_OBJECT) (gpointer     data1,
 
583
                                                          gpointer     arg_1,
 
584
                                                          gpointer     arg_2,
 
585
                                                          gpointer     data2);
 
586
  register GMarshalFunc_OBJECT__OBJECT_OBJECT callback;
 
587
  register GCClosure *cc = (GCClosure*) closure;
 
588
  register gpointer data1, data2;
 
589
  GObject* v_return;
 
590
 
 
591
  g_return_if_fail (return_value != NULL);
 
592
  g_return_if_fail (n_param_values == 3);
 
593
 
 
594
  if (G_CCLOSURE_SWAP_DATA (closure))
 
595
    {
 
596
      data1 = closure->data;
 
597
      data2 = g_value_peek_pointer (param_values + 0);
 
598
    }
 
599
  else
 
600
    {
 
601
      data1 = g_value_peek_pointer (param_values + 0);
 
602
      data2 = closure->data;
 
603
    }
 
604
  callback = (GMarshalFunc_OBJECT__OBJECT_OBJECT) (marshal_data ? marshal_data : cc->callback);
 
605
 
 
606
  v_return = callback (data1,
 
607
                       g_marshal_value_peek_object (param_values + 1),
 
608
                       g_marshal_value_peek_object (param_values + 2),
 
609
                       data2);
 
610
 
 
611
  g_value_take_object (return_value, v_return);
 
612
}
 
613
 
 
614
/* OBJECT:VOID (./rb-marshal.list:13) */
 
615
extern void rb_marshal_OBJECT__VOID (GClosure     *closure,
 
616
                                     GValue       *return_value,
 
617
                                     guint         n_param_values,
 
618
                                     const GValue *param_values,
 
619
                                     gpointer      invocation_hint,
 
620
                                     gpointer      marshal_data);
 
621
void
 
622
rb_marshal_OBJECT__VOID (GClosure     *closure,
 
623
                         GValue       *return_value G_GNUC_UNUSED,
 
624
                         guint         n_param_values,
 
625
                         const GValue *param_values,
 
626
                         gpointer      invocation_hint G_GNUC_UNUSED,
 
627
                         gpointer      marshal_data)
 
628
{
 
629
  typedef GObject* (*GMarshalFunc_OBJECT__VOID) (gpointer     data1,
 
630
                                                 gpointer     data2);
 
631
  register GMarshalFunc_OBJECT__VOID callback;
 
632
  register GCClosure *cc = (GCClosure*) closure;
 
633
  register gpointer data1, data2;
 
634
  GObject* v_return;
 
635
 
 
636
  g_return_if_fail (return_value != NULL);
 
637
  g_return_if_fail (n_param_values == 1);
 
638
 
 
639
  if (G_CCLOSURE_SWAP_DATA (closure))
 
640
    {
 
641
      data1 = closure->data;
 
642
      data2 = g_value_peek_pointer (param_values + 0);
 
643
    }
 
644
  else
 
645
    {
 
646
      data1 = g_value_peek_pointer (param_values + 0);
 
647
      data2 = closure->data;
 
648
    }
 
649
  callback = (GMarshalFunc_OBJECT__VOID) (marshal_data ? marshal_data : cc->callback);
 
650
 
 
651
  v_return = callback (data1,
 
652
                       data2);
 
653
 
 
654
  g_value_take_object (return_value, v_return);
 
655
}
 
656
 
 
657
/* STRING:STRING (./rb-marshal.list:14) */
 
658
extern void rb_marshal_STRING__STRING (GClosure     *closure,
 
659
                                       GValue       *return_value,
 
660
                                       guint         n_param_values,
 
661
                                       const GValue *param_values,
 
662
                                       gpointer      invocation_hint,
 
663
                                       gpointer      marshal_data);
 
664
void
 
665
rb_marshal_STRING__STRING (GClosure     *closure,
 
666
                           GValue       *return_value G_GNUC_UNUSED,
 
667
                           guint         n_param_values,
 
668
                           const GValue *param_values,
 
669
                           gpointer      invocation_hint G_GNUC_UNUSED,
 
670
                           gpointer      marshal_data)
 
671
{
 
672
  typedef gchar* (*GMarshalFunc_STRING__STRING) (gpointer     data1,
 
673
                                                 gpointer     arg_1,
 
674
                                                 gpointer     data2);
 
675
  register GMarshalFunc_STRING__STRING callback;
 
676
  register GCClosure *cc = (GCClosure*) closure;
 
677
  register gpointer data1, data2;
 
678
  gchar* v_return;
 
679
 
 
680
  g_return_if_fail (return_value != NULL);
 
681
  g_return_if_fail (n_param_values == 2);
 
682
 
 
683
  if (G_CCLOSURE_SWAP_DATA (closure))
 
684
    {
 
685
      data1 = closure->data;
 
686
      data2 = g_value_peek_pointer (param_values + 0);
 
687
    }
 
688
  else
 
689
    {
 
690
      data1 = g_value_peek_pointer (param_values + 0);
 
691
      data2 = closure->data;
 
692
    }
 
693
  callback = (GMarshalFunc_STRING__STRING) (marshal_data ? marshal_data : cc->callback);
 
694
 
 
695
  v_return = callback (data1,
 
696
                       g_marshal_value_peek_string (param_values + 1),
 
697
                       data2);
 
698
 
 
699
  g_value_take_string (return_value, v_return);
 
700
}
 
701
 
 
702
/* STRING:BOXED,STRING,STRING (./rb-marshal.list:15) */
 
703
extern void rb_marshal_STRING__BOXED_STRING_STRING (GClosure     *closure,
 
704
                                                    GValue       *return_value,
 
705
                                                    guint         n_param_values,
 
706
                                                    const GValue *param_values,
 
707
                                                    gpointer      invocation_hint,
 
708
                                                    gpointer      marshal_data);
 
709
void
 
710
rb_marshal_STRING__BOXED_STRING_STRING (GClosure     *closure,
 
711
                                        GValue       *return_value G_GNUC_UNUSED,
 
712
                                        guint         n_param_values,
 
713
                                        const GValue *param_values,
 
714
                                        gpointer      invocation_hint G_GNUC_UNUSED,
 
715
                                        gpointer      marshal_data)
 
716
{
 
717
  typedef gchar* (*GMarshalFunc_STRING__BOXED_STRING_STRING) (gpointer     data1,
 
718
                                                              gpointer     arg_1,
 
719
                                                              gpointer     arg_2,
 
720
                                                              gpointer     arg_3,
 
721
                                                              gpointer     data2);
 
722
  register GMarshalFunc_STRING__BOXED_STRING_STRING callback;
 
723
  register GCClosure *cc = (GCClosure*) closure;
 
724
  register gpointer data1, data2;
 
725
  gchar* v_return;
 
726
 
 
727
  g_return_if_fail (return_value != NULL);
 
728
  g_return_if_fail (n_param_values == 4);
 
729
 
 
730
  if (G_CCLOSURE_SWAP_DATA (closure))
 
731
    {
 
732
      data1 = closure->data;
 
733
      data2 = g_value_peek_pointer (param_values + 0);
 
734
    }
 
735
  else
 
736
    {
 
737
      data1 = g_value_peek_pointer (param_values + 0);
 
738
      data2 = closure->data;
 
739
    }
 
740
  callback = (GMarshalFunc_STRING__BOXED_STRING_STRING) (marshal_data ? marshal_data : cc->callback);
 
741
 
 
742
  v_return = callback (data1,
 
743
                       g_marshal_value_peek_boxed (param_values + 1),
 
744
                       g_marshal_value_peek_string (param_values + 2),
 
745
                       g_marshal_value_peek_string (param_values + 3),
 
746
                       data2);
 
747
 
 
748
  g_value_take_string (return_value, v_return);
 
749
}
 
750
 
 
751
/* VOID:BOOLEAN,BOOLEAN (./rb-marshal.list:16) */
 
752
extern void rb_marshal_VOID__BOOLEAN_BOOLEAN (GClosure     *closure,
 
753
                                              GValue       *return_value,
 
754
                                              guint         n_param_values,
 
755
                                              const GValue *param_values,
 
756
                                              gpointer      invocation_hint,
 
757
                                              gpointer      marshal_data);
 
758
void
 
759
rb_marshal_VOID__BOOLEAN_BOOLEAN (GClosure     *closure,
 
760
                                  GValue       *return_value G_GNUC_UNUSED,
 
761
                                  guint         n_param_values,
 
762
                                  const GValue *param_values,
 
763
                                  gpointer      invocation_hint G_GNUC_UNUSED,
 
764
                                  gpointer      marshal_data)
 
765
{
 
766
  typedef void (*GMarshalFunc_VOID__BOOLEAN_BOOLEAN) (gpointer     data1,
 
767
                                                      gboolean     arg_1,
 
768
                                                      gboolean     arg_2,
 
769
                                                      gpointer     data2);
 
770
  register GMarshalFunc_VOID__BOOLEAN_BOOLEAN callback;
 
771
  register GCClosure *cc = (GCClosure*) closure;
 
772
  register gpointer data1, data2;
 
773
 
 
774
  g_return_if_fail (n_param_values == 3);
 
775
 
 
776
  if (G_CCLOSURE_SWAP_DATA (closure))
 
777
    {
 
778
      data1 = closure->data;
 
779
      data2 = g_value_peek_pointer (param_values + 0);
 
780
    }
 
781
  else
 
782
    {
 
783
      data1 = g_value_peek_pointer (param_values + 0);
 
784
      data2 = closure->data;
 
785
    }
 
786
  callback = (GMarshalFunc_VOID__BOOLEAN_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
 
787
 
 
788
  callback (data1,
 
789
            g_marshal_value_peek_boolean (param_values + 1),
 
790
            g_marshal_value_peek_boolean (param_values + 2),
 
791
            data2);
 
792
}
 
793
 
 
794
/* BOXED:BOXED (./rb-marshal.list:17) */
 
795
extern void rb_marshal_BOXED__BOXED (GClosure     *closure,
 
796
                                     GValue       *return_value,
 
797
                                     guint         n_param_values,
 
798
                                     const GValue *param_values,
 
799
                                     gpointer      invocation_hint,
 
800
                                     gpointer      marshal_data);
 
801
void
 
802
rb_marshal_BOXED__BOXED (GClosure     *closure,
 
803
                         GValue       *return_value G_GNUC_UNUSED,
 
804
                         guint         n_param_values,
 
805
                         const GValue *param_values,
 
806
                         gpointer      invocation_hint G_GNUC_UNUSED,
 
807
                         gpointer      marshal_data)
 
808
{
 
809
  typedef gpointer (*GMarshalFunc_BOXED__BOXED) (gpointer     data1,
 
810
                                                 gpointer     arg_1,
 
811
                                                 gpointer     data2);
 
812
  register GMarshalFunc_BOXED__BOXED callback;
 
813
  register GCClosure *cc = (GCClosure*) closure;
 
814
  register gpointer data1, data2;
 
815
  gpointer v_return;
 
816
 
 
817
  g_return_if_fail (return_value != NULL);
 
818
  g_return_if_fail (n_param_values == 2);
 
819
 
 
820
  if (G_CCLOSURE_SWAP_DATA (closure))
 
821
    {
 
822
      data1 = closure->data;
 
823
      data2 = g_value_peek_pointer (param_values + 0);
 
824
    }
 
825
  else
 
826
    {
 
827
      data1 = g_value_peek_pointer (param_values + 0);
 
828
      data2 = closure->data;
 
829
    }
 
830
  callback = (GMarshalFunc_BOXED__BOXED) (marshal_data ? marshal_data : cc->callback);
 
831
 
 
832
  v_return = callback (data1,
 
833
                       g_marshal_value_peek_boxed (param_values + 1),
 
834
                       data2);
 
835
 
 
836
  g_value_take_boxed (return_value, v_return);
 
837
}
 
838
 
 
839
/* BOXED:OBJECT (./rb-marshal.list:18) */
 
840
extern void rb_marshal_BOXED__OBJECT (GClosure     *closure,
 
841
                                      GValue       *return_value,
 
842
                                      guint         n_param_values,
 
843
                                      const GValue *param_values,
 
844
                                      gpointer      invocation_hint,
 
845
                                      gpointer      marshal_data);
 
846
void
 
847
rb_marshal_BOXED__OBJECT (GClosure     *closure,
 
848
                          GValue       *return_value G_GNUC_UNUSED,
 
849
                          guint         n_param_values,
 
850
                          const GValue *param_values,
 
851
                          gpointer      invocation_hint G_GNUC_UNUSED,
 
852
                          gpointer      marshal_data)
 
853
{
 
854
  typedef gpointer (*GMarshalFunc_BOXED__OBJECT) (gpointer     data1,
 
855
                                                  gpointer     arg_1,
 
856
                                                  gpointer     data2);
 
857
  register GMarshalFunc_BOXED__OBJECT callback;
 
858
  register GCClosure *cc = (GCClosure*) closure;
 
859
  register gpointer data1, data2;
 
860
  gpointer v_return;
 
861
 
 
862
  g_return_if_fail (return_value != NULL);
 
863
  g_return_if_fail (n_param_values == 2);
 
864
 
 
865
  if (G_CCLOSURE_SWAP_DATA (closure))
 
866
    {
 
867
      data1 = closure->data;
 
868
      data2 = g_value_peek_pointer (param_values + 0);
 
869
    }
 
870
  else
 
871
    {
 
872
      data1 = g_value_peek_pointer (param_values + 0);
 
873
      data2 = closure->data;
 
874
    }
 
875
  callback = (GMarshalFunc_BOXED__OBJECT) (marshal_data ? marshal_data : cc->callback);
 
876
 
 
877
  v_return = callback (data1,
 
878
                       g_marshal_value_peek_object (param_values + 1),
 
879
                       data2);
 
880
 
 
881
  g_value_take_boxed (return_value, v_return);
 
882
}
 
883
 
 
884
/* BOXED:STRING (./rb-marshal.list:19) */
 
885
extern void rb_marshal_BOXED__STRING (GClosure     *closure,
 
886
                                      GValue       *return_value,
 
887
                                      guint         n_param_values,
 
888
                                      const GValue *param_values,
 
889
                                      gpointer      invocation_hint,
 
890
                                      gpointer      marshal_data);
 
891
void
 
892
rb_marshal_BOXED__STRING (GClosure     *closure,
 
893
                          GValue       *return_value G_GNUC_UNUSED,
 
894
                          guint         n_param_values,
 
895
                          const GValue *param_values,
 
896
                          gpointer      invocation_hint G_GNUC_UNUSED,
 
897
                          gpointer      marshal_data)
 
898
{
 
899
  typedef gpointer (*GMarshalFunc_BOXED__STRING) (gpointer     data1,
 
900
                                                  gpointer     arg_1,
 
901
                                                  gpointer     data2);
 
902
  register GMarshalFunc_BOXED__STRING callback;
 
903
  register GCClosure *cc = (GCClosure*) closure;
 
904
  register gpointer data1, data2;
 
905
  gpointer v_return;
 
906
 
 
907
  g_return_if_fail (return_value != NULL);
 
908
  g_return_if_fail (n_param_values == 2);
 
909
 
 
910
  if (G_CCLOSURE_SWAP_DATA (closure))
 
911
    {
 
912
      data1 = closure->data;
 
913
      data2 = g_value_peek_pointer (param_values + 0);
 
914
    }
 
915
  else
 
916
    {
 
917
      data1 = g_value_peek_pointer (param_values + 0);
 
918
      data2 = closure->data;
 
919
    }
 
920
  callback = (GMarshalFunc_BOXED__STRING) (marshal_data ? marshal_data : cc->callback);
 
921
 
 
922
  v_return = callback (data1,
 
923
                       g_marshal_value_peek_string (param_values + 1),
 
924
                       data2);
 
925
 
 
926
  g_value_take_boxed (return_value, v_return);
 
927
}
 
928
 
 
929
/* VOID:BOXED,BOXED (./rb-marshal.list:20) */
 
930
extern void rb_marshal_VOID__BOXED_BOXED (GClosure     *closure,
 
931
                                          GValue       *return_value,
 
932
                                          guint         n_param_values,
 
933
                                          const GValue *param_values,
 
934
                                          gpointer      invocation_hint,
 
935
                                          gpointer      marshal_data);
 
936
void
 
937
rb_marshal_VOID__BOXED_BOXED (GClosure     *closure,
 
938
                              GValue       *return_value G_GNUC_UNUSED,
 
939
                              guint         n_param_values,
 
940
                              const GValue *param_values,
 
941
                              gpointer      invocation_hint G_GNUC_UNUSED,
 
942
                              gpointer      marshal_data)
 
943
{
 
944
  typedef void (*GMarshalFunc_VOID__BOXED_BOXED) (gpointer     data1,
 
945
                                                  gpointer     arg_1,
 
946
                                                  gpointer     arg_2,
 
947
                                                  gpointer     data2);
 
948
  register GMarshalFunc_VOID__BOXED_BOXED callback;
 
949
  register GCClosure *cc = (GCClosure*) closure;
 
950
  register gpointer data1, data2;
 
951
 
 
952
  g_return_if_fail (n_param_values == 3);
 
953
 
 
954
  if (G_CCLOSURE_SWAP_DATA (closure))
 
955
    {
 
956
      data1 = closure->data;
 
957
      data2 = g_value_peek_pointer (param_values + 0);
 
958
    }
 
959
  else
 
960
    {
 
961
      data1 = g_value_peek_pointer (param_values + 0);
 
962
      data2 = closure->data;
 
963
    }
 
964
  callback = (GMarshalFunc_VOID__BOXED_BOXED) (marshal_data ? marshal_data : cc->callback);
 
965
 
 
966
  callback (data1,
 
967
            g_marshal_value_peek_boxed (param_values + 1),
 
968
            g_marshal_value_peek_boxed (param_values + 2),
 
969
            data2);
 
970
}
 
971
 
 
972
/* VOID:BOXED,INT,POINTER,POINTER (./rb-marshal.list:21) */
 
973
extern void rb_marshal_VOID__BOXED_INT_POINTER_POINTER (GClosure     *closure,
 
974
                                                        GValue       *return_value,
 
975
                                                        guint         n_param_values,
 
976
                                                        const GValue *param_values,
 
977
                                                        gpointer      invocation_hint,
 
978
                                                        gpointer      marshal_data);
 
979
void
 
980
rb_marshal_VOID__BOXED_INT_POINTER_POINTER (GClosure     *closure,
 
981
                                            GValue       *return_value G_GNUC_UNUSED,
 
982
                                            guint         n_param_values,
 
983
                                            const GValue *param_values,
 
984
                                            gpointer      invocation_hint G_GNUC_UNUSED,
 
985
                                            gpointer      marshal_data)
 
986
{
 
987
  typedef void (*GMarshalFunc_VOID__BOXED_INT_POINTER_POINTER) (gpointer     data1,
 
988
                                                                gpointer     arg_1,
 
989
                                                                gint         arg_2,
 
990
                                                                gpointer     arg_3,
 
991
                                                                gpointer     arg_4,
 
992
                                                                gpointer     data2);
 
993
  register GMarshalFunc_VOID__BOXED_INT_POINTER_POINTER callback;
 
994
  register GCClosure *cc = (GCClosure*) closure;
 
995
  register gpointer data1, data2;
 
996
 
 
997
  g_return_if_fail (n_param_values == 5);
 
998
 
 
999
  if (G_CCLOSURE_SWAP_DATA (closure))
 
1000
    {
 
1001
      data1 = closure->data;
 
1002
      data2 = g_value_peek_pointer (param_values + 0);
 
1003
    }
 
1004
  else
 
1005
    {
 
1006
      data1 = g_value_peek_pointer (param_values + 0);
 
1007
      data2 = closure->data;
 
1008
    }
 
1009
  callback = (GMarshalFunc_VOID__BOXED_INT_POINTER_POINTER) (marshal_data ? marshal_data : cc->callback);
 
1010
 
 
1011
  callback (data1,
 
1012
            g_marshal_value_peek_boxed (param_values + 1),
 
1013
            g_marshal_value_peek_int (param_values + 2),
 
1014
            g_marshal_value_peek_pointer (param_values + 3),
 
1015
            g_marshal_value_peek_pointer (param_values + 4),
 
1016
            data2);
 
1017
}
 
1018
 
 
1019
/* VOID:BOXED,OBJECT (./rb-marshal.list:22) */
 
1020
extern void rb_marshal_VOID__BOXED_OBJECT (GClosure     *closure,
 
1021
                                           GValue       *return_value,
 
1022
                                           guint         n_param_values,
 
1023
                                           const GValue *param_values,
 
1024
                                           gpointer      invocation_hint,
 
1025
                                           gpointer      marshal_data);
 
1026
void
 
1027
rb_marshal_VOID__BOXED_OBJECT (GClosure     *closure,
 
1028
                               GValue       *return_value G_GNUC_UNUSED,
 
1029
                               guint         n_param_values,
 
1030
                               const GValue *param_values,
 
1031
                               gpointer      invocation_hint G_GNUC_UNUSED,
 
1032
                               gpointer      marshal_data)
 
1033
{
 
1034
  typedef void (*GMarshalFunc_VOID__BOXED_OBJECT) (gpointer     data1,
 
1035
                                                   gpointer     arg_1,
 
1036
                                                   gpointer     arg_2,
 
1037
                                                   gpointer     data2);
 
1038
  register GMarshalFunc_VOID__BOXED_OBJECT callback;
 
1039
  register GCClosure *cc = (GCClosure*) closure;
 
1040
  register gpointer data1, data2;
 
1041
 
 
1042
  g_return_if_fail (n_param_values == 3);
 
1043
 
 
1044
  if (G_CCLOSURE_SWAP_DATA (closure))
 
1045
    {
 
1046
      data1 = closure->data;
 
1047
      data2 = g_value_peek_pointer (param_values + 0);
 
1048
    }
 
1049
  else
 
1050
    {
 
1051
      data1 = g_value_peek_pointer (param_values + 0);
 
1052
      data2 = closure->data;
 
1053
    }
 
1054
  callback = (GMarshalFunc_VOID__BOXED_OBJECT) (marshal_data ? marshal_data : cc->callback);
 
1055
 
 
1056
  callback (data1,
 
1057
            g_marshal_value_peek_boxed (param_values + 1),
 
1058
            g_marshal_value_peek_object (param_values + 2),
 
1059
            data2);
 
1060
}
 
1061
 
 
1062
/* VOID:BOXED,POINTER (./rb-marshal.list:23) */
 
1063
extern void rb_marshal_VOID__BOXED_POINTER (GClosure     *closure,
 
1064
                                            GValue       *return_value,
 
1065
                                            guint         n_param_values,
 
1066
                                            const GValue *param_values,
 
1067
                                            gpointer      invocation_hint,
 
1068
                                            gpointer      marshal_data);
 
1069
void
 
1070
rb_marshal_VOID__BOXED_POINTER (GClosure     *closure,
 
1071
                                GValue       *return_value G_GNUC_UNUSED,
 
1072
                                guint         n_param_values,
 
1073
                                const GValue *param_values,
 
1074
                                gpointer      invocation_hint G_GNUC_UNUSED,
 
1075
                                gpointer      marshal_data)
 
1076
{
 
1077
  typedef void (*GMarshalFunc_VOID__BOXED_POINTER) (gpointer     data1,
 
1078
                                                    gpointer     arg_1,
 
1079
                                                    gpointer     arg_2,
 
1080
                                                    gpointer     data2);
 
1081
  register GMarshalFunc_VOID__BOXED_POINTER callback;
 
1082
  register GCClosure *cc = (GCClosure*) closure;
 
1083
  register gpointer data1, data2;
 
1084
 
 
1085
  g_return_if_fail (n_param_values == 3);
 
1086
 
 
1087
  if (G_CCLOSURE_SWAP_DATA (closure))
 
1088
    {
 
1089
      data1 = closure->data;
 
1090
      data2 = g_value_peek_pointer (param_values + 0);
 
1091
    }
 
1092
  else
 
1093
    {
 
1094
      data1 = g_value_peek_pointer (param_values + 0);
 
1095
      data2 = closure->data;
 
1096
    }
 
1097
  callback = (GMarshalFunc_VOID__BOXED_POINTER) (marshal_data ? marshal_data : cc->callback);
 
1098
 
 
1099
  callback (data1,
 
1100
            g_marshal_value_peek_boxed (param_values + 1),
 
1101
            g_marshal_value_peek_pointer (param_values + 2),
 
1102
            data2);
 
1103
}
 
1104
 
 
1105
/* VOID:BOXED,STRING (./rb-marshal.list:24) */
 
1106
extern void rb_marshal_VOID__BOXED_STRING (GClosure     *closure,
 
1107
                                           GValue       *return_value,
 
1108
                                           guint         n_param_values,
 
1109
                                           const GValue *param_values,
 
1110
                                           gpointer      invocation_hint,
 
1111
                                           gpointer      marshal_data);
 
1112
void
 
1113
rb_marshal_VOID__BOXED_STRING (GClosure     *closure,
 
1114
                               GValue       *return_value G_GNUC_UNUSED,
 
1115
                               guint         n_param_values,
 
1116
                               const GValue *param_values,
 
1117
                               gpointer      invocation_hint G_GNUC_UNUSED,
 
1118
                               gpointer      marshal_data)
 
1119
{
 
1120
  typedef void (*GMarshalFunc_VOID__BOXED_STRING) (gpointer     data1,
 
1121
                                                   gpointer     arg_1,
 
1122
                                                   gpointer     arg_2,
 
1123
                                                   gpointer     data2);
 
1124
  register GMarshalFunc_VOID__BOXED_STRING callback;
 
1125
  register GCClosure *cc = (GCClosure*) closure;
 
1126
  register gpointer data1, data2;
 
1127
 
 
1128
  g_return_if_fail (n_param_values == 3);
 
1129
 
 
1130
  if (G_CCLOSURE_SWAP_DATA (closure))
 
1131
    {
 
1132
      data1 = closure->data;
 
1133
      data2 = g_value_peek_pointer (param_values + 0);
 
1134
    }
 
1135
  else
 
1136
    {
 
1137
      data1 = g_value_peek_pointer (param_values + 0);
 
1138
      data2 = closure->data;
 
1139
    }
 
1140
  callback = (GMarshalFunc_VOID__BOXED_STRING) (marshal_data ? marshal_data : cc->callback);
 
1141
 
 
1142
  callback (data1,
 
1143
            g_marshal_value_peek_boxed (param_values + 1),
 
1144
            g_marshal_value_peek_string (param_values + 2),
 
1145
            data2);
 
1146
}
 
1147
 
 
1148
/* VOID:BOXED,STRING,BOXED (./rb-marshal.list:25) */
 
1149
extern void rb_marshal_VOID__BOXED_STRING_BOXED (GClosure     *closure,
 
1150
                                                 GValue       *return_value,
 
1151
                                                 guint         n_param_values,
 
1152
                                                 const GValue *param_values,
 
1153
                                                 gpointer      invocation_hint,
 
1154
                                                 gpointer      marshal_data);
 
1155
void
 
1156
rb_marshal_VOID__BOXED_STRING_BOXED (GClosure     *closure,
 
1157
                                     GValue       *return_value G_GNUC_UNUSED,
 
1158
                                     guint         n_param_values,
 
1159
                                     const GValue *param_values,
 
1160
                                     gpointer      invocation_hint G_GNUC_UNUSED,
 
1161
                                     gpointer      marshal_data)
 
1162
{
 
1163
  typedef void (*GMarshalFunc_VOID__BOXED_STRING_BOXED) (gpointer     data1,
 
1164
                                                         gpointer     arg_1,
 
1165
                                                         gpointer     arg_2,
 
1166
                                                         gpointer     arg_3,
 
1167
                                                         gpointer     data2);
 
1168
  register GMarshalFunc_VOID__BOXED_STRING_BOXED callback;
 
1169
  register GCClosure *cc = (GCClosure*) closure;
 
1170
  register gpointer data1, data2;
 
1171
 
 
1172
  g_return_if_fail (n_param_values == 4);
 
1173
 
 
1174
  if (G_CCLOSURE_SWAP_DATA (closure))
 
1175
    {
 
1176
      data1 = closure->data;
 
1177
      data2 = g_value_peek_pointer (param_values + 0);
 
1178
    }
 
1179
  else
 
1180
    {
 
1181
      data1 = g_value_peek_pointer (param_values + 0);
 
1182
      data2 = closure->data;
 
1183
    }
 
1184
  callback = (GMarshalFunc_VOID__BOXED_STRING_BOXED) (marshal_data ? marshal_data : cc->callback);
 
1185
 
 
1186
  callback (data1,
 
1187
            g_marshal_value_peek_boxed (param_values + 1),
 
1188
            g_marshal_value_peek_string (param_values + 2),
 
1189
            g_marshal_value_peek_boxed (param_values + 3),
 
1190
            data2);
 
1191
}
 
1192
 
 
1193
/* VOID:BOXED,STRING,INT,INT,DOUBLE (./rb-marshal.list:26) */
 
1194
extern void rb_marshal_VOID__BOXED_STRING_INT_INT_DOUBLE (GClosure     *closure,
 
1195
                                                          GValue       *return_value,
 
1196
                                                          guint         n_param_values,
 
1197
                                                          const GValue *param_values,
 
1198
                                                          gpointer      invocation_hint,
 
1199
                                                          gpointer      marshal_data);
 
1200
void
 
1201
rb_marshal_VOID__BOXED_STRING_INT_INT_DOUBLE (GClosure     *closure,
 
1202
                                              GValue       *return_value G_GNUC_UNUSED,
 
1203
                                              guint         n_param_values,
 
1204
                                              const GValue *param_values,
 
1205
                                              gpointer      invocation_hint G_GNUC_UNUSED,
 
1206
                                              gpointer      marshal_data)
 
1207
{
 
1208
  typedef void (*GMarshalFunc_VOID__BOXED_STRING_INT_INT_DOUBLE) (gpointer     data1,
 
1209
                                                                  gpointer     arg_1,
 
1210
                                                                  gpointer     arg_2,
 
1211
                                                                  gint         arg_3,
 
1212
                                                                  gint         arg_4,
 
1213
                                                                  gdouble      arg_5,
 
1214
                                                                  gpointer     data2);
 
1215
  register GMarshalFunc_VOID__BOXED_STRING_INT_INT_DOUBLE callback;
 
1216
  register GCClosure *cc = (GCClosure*) closure;
 
1217
  register gpointer data1, data2;
 
1218
 
 
1219
  g_return_if_fail (n_param_values == 6);
 
1220
 
 
1221
  if (G_CCLOSURE_SWAP_DATA (closure))
 
1222
    {
 
1223
      data1 = closure->data;
 
1224
      data2 = g_value_peek_pointer (param_values + 0);
 
1225
    }
 
1226
  else
 
1227
    {
 
1228
      data1 = g_value_peek_pointer (param_values + 0);
 
1229
      data2 = closure->data;
 
1230
    }
 
1231
  callback = (GMarshalFunc_VOID__BOXED_STRING_INT_INT_DOUBLE) (marshal_data ? marshal_data : cc->callback);
 
1232
 
 
1233
  callback (data1,
 
1234
            g_marshal_value_peek_boxed (param_values + 1),
 
1235
            g_marshal_value_peek_string (param_values + 2),
 
1236
            g_marshal_value_peek_int (param_values + 3),
 
1237
            g_marshal_value_peek_int (param_values + 4),
 
1238
            g_marshal_value_peek_double (param_values + 5),
 
1239
            data2);
 
1240
}
 
1241
 
 
1242
/* VOID:BOXED,STRING,UINT64,STRING,POINTER (./rb-marshal.list:27) */
 
1243
extern void rb_marshal_VOID__BOXED_STRING_UINT64_STRING_POINTER (GClosure     *closure,
 
1244
                                                                 GValue       *return_value,
 
1245
                                                                 guint         n_param_values,
 
1246
                                                                 const GValue *param_values,
 
1247
                                                                 gpointer      invocation_hint,
 
1248
                                                                 gpointer      marshal_data);
 
1249
void
 
1250
rb_marshal_VOID__BOXED_STRING_UINT64_STRING_POINTER (GClosure     *closure,
 
1251
                                                     GValue       *return_value G_GNUC_UNUSED,
 
1252
                                                     guint         n_param_values,
 
1253
                                                     const GValue *param_values,
 
1254
                                                     gpointer      invocation_hint G_GNUC_UNUSED,
 
1255
                                                     gpointer      marshal_data)
 
1256
{
 
1257
  typedef void (*GMarshalFunc_VOID__BOXED_STRING_UINT64_STRING_POINTER) (gpointer     data1,
 
1258
                                                                         gpointer     arg_1,
 
1259
                                                                         gpointer     arg_2,
 
1260
                                                                         guint64      arg_3,
 
1261
                                                                         gpointer     arg_4,
 
1262
                                                                         gpointer     arg_5,
 
1263
                                                                         gpointer     data2);
 
1264
  register GMarshalFunc_VOID__BOXED_STRING_UINT64_STRING_POINTER callback;
 
1265
  register GCClosure *cc = (GCClosure*) closure;
 
1266
  register gpointer data1, data2;
 
1267
 
 
1268
  g_return_if_fail (n_param_values == 6);
 
1269
 
 
1270
  if (G_CCLOSURE_SWAP_DATA (closure))
 
1271
    {
 
1272
      data1 = closure->data;
 
1273
      data2 = g_value_peek_pointer (param_values + 0);
 
1274
    }
 
1275
  else
 
1276
    {
 
1277
      data1 = g_value_peek_pointer (param_values + 0);
 
1278
      data2 = closure->data;
 
1279
    }
 
1280
  callback = (GMarshalFunc_VOID__BOXED_STRING_UINT64_STRING_POINTER) (marshal_data ? marshal_data : cc->callback);
 
1281
 
 
1282
  callback (data1,
 
1283
            g_marshal_value_peek_boxed (param_values + 1),
 
1284
            g_marshal_value_peek_string (param_values + 2),
 
1285
            g_marshal_value_peek_uint64 (param_values + 3),
 
1286
            g_marshal_value_peek_string (param_values + 4),
 
1287
            g_marshal_value_peek_pointer (param_values + 5),
 
1288
            data2);
 
1289
}
 
1290
 
 
1291
/* VOID:BOXED,ULONG (./rb-marshal.list:28) */
 
1292
extern void rb_marshal_VOID__BOXED_ULONG (GClosure     *closure,
 
1293
                                          GValue       *return_value,
 
1294
                                          guint         n_param_values,
 
1295
                                          const GValue *param_values,
 
1296
                                          gpointer      invocation_hint,
 
1297
                                          gpointer      marshal_data);
 
1298
void
 
1299
rb_marshal_VOID__BOXED_ULONG (GClosure     *closure,
 
1300
                              GValue       *return_value G_GNUC_UNUSED,
 
1301
                              guint         n_param_values,
 
1302
                              const GValue *param_values,
 
1303
                              gpointer      invocation_hint G_GNUC_UNUSED,
 
1304
                              gpointer      marshal_data)
 
1305
{
 
1306
  typedef void (*GMarshalFunc_VOID__BOXED_ULONG) (gpointer     data1,
 
1307
                                                  gpointer     arg_1,
 
1308
                                                  gulong       arg_2,
 
1309
                                                  gpointer     data2);
 
1310
  register GMarshalFunc_VOID__BOXED_ULONG callback;
 
1311
  register GCClosure *cc = (GCClosure*) closure;
 
1312
  register gpointer data1, data2;
 
1313
 
 
1314
  g_return_if_fail (n_param_values == 3);
 
1315
 
 
1316
  if (G_CCLOSURE_SWAP_DATA (closure))
 
1317
    {
 
1318
      data1 = closure->data;
 
1319
      data2 = g_value_peek_pointer (param_values + 0);
 
1320
    }
 
1321
  else
 
1322
    {
 
1323
      data1 = g_value_peek_pointer (param_values + 0);
 
1324
      data2 = closure->data;
 
1325
    }
 
1326
  callback = (GMarshalFunc_VOID__BOXED_ULONG) (marshal_data ? marshal_data : cc->callback);
 
1327
 
 
1328
  callback (data1,
 
1329
            g_marshal_value_peek_boxed (param_values + 1),
 
1330
            g_marshal_value_peek_ulong (param_values + 2),
 
1331
            data2);
 
1332
}
 
1333
 
 
1334
/* VOID:DOUBLE,LONG (./rb-marshal.list:29) */
 
1335
extern void rb_marshal_VOID__DOUBLE_LONG (GClosure     *closure,
 
1336
                                          GValue       *return_value,
 
1337
                                          guint         n_param_values,
 
1338
                                          const GValue *param_values,
 
1339
                                          gpointer      invocation_hint,
 
1340
                                          gpointer      marshal_data);
 
1341
void
 
1342
rb_marshal_VOID__DOUBLE_LONG (GClosure     *closure,
 
1343
                              GValue       *return_value G_GNUC_UNUSED,
 
1344
                              guint         n_param_values,
 
1345
                              const GValue *param_values,
 
1346
                              gpointer      invocation_hint G_GNUC_UNUSED,
 
1347
                              gpointer      marshal_data)
 
1348
{
 
1349
  typedef void (*GMarshalFunc_VOID__DOUBLE_LONG) (gpointer     data1,
 
1350
                                                  gdouble      arg_1,
 
1351
                                                  glong        arg_2,
 
1352
                                                  gpointer     data2);
 
1353
  register GMarshalFunc_VOID__DOUBLE_LONG callback;
 
1354
  register GCClosure *cc = (GCClosure*) closure;
 
1355
  register gpointer data1, data2;
 
1356
 
 
1357
  g_return_if_fail (n_param_values == 3);
 
1358
 
 
1359
  if (G_CCLOSURE_SWAP_DATA (closure))
 
1360
    {
 
1361
      data1 = closure->data;
 
1362
      data2 = g_value_peek_pointer (param_values + 0);
 
1363
    }
 
1364
  else
 
1365
    {
 
1366
      data1 = g_value_peek_pointer (param_values + 0);
 
1367
      data2 = closure->data;
 
1368
    }
 
1369
  callback = (GMarshalFunc_VOID__DOUBLE_LONG) (marshal_data ? marshal_data : cc->callback);
 
1370
 
 
1371
  callback (data1,
 
1372
            g_marshal_value_peek_double (param_values + 1),
 
1373
            g_marshal_value_peek_long (param_values + 2),
 
1374
            data2);
 
1375
}
 
1376
 
 
1377
/* VOID:INT,INT (./rb-marshal.list:30) */
 
1378
extern void rb_marshal_VOID__INT_INT (GClosure     *closure,
 
1379
                                      GValue       *return_value,
 
1380
                                      guint         n_param_values,
 
1381
                                      const GValue *param_values,
 
1382
                                      gpointer      invocation_hint,
 
1383
                                      gpointer      marshal_data);
 
1384
void
 
1385
rb_marshal_VOID__INT_INT (GClosure     *closure,
 
1386
                          GValue       *return_value G_GNUC_UNUSED,
 
1387
                          guint         n_param_values,
 
1388
                          const GValue *param_values,
 
1389
                          gpointer      invocation_hint G_GNUC_UNUSED,
 
1390
                          gpointer      marshal_data)
 
1391
{
 
1392
  typedef void (*GMarshalFunc_VOID__INT_INT) (gpointer     data1,
 
1393
                                              gint         arg_1,
 
1394
                                              gint         arg_2,
 
1395
                                              gpointer     data2);
 
1396
  register GMarshalFunc_VOID__INT_INT callback;
 
1397
  register GCClosure *cc = (GCClosure*) closure;
 
1398
  register gpointer data1, data2;
 
1399
 
 
1400
  g_return_if_fail (n_param_values == 3);
 
1401
 
 
1402
  if (G_CCLOSURE_SWAP_DATA (closure))
 
1403
    {
 
1404
      data1 = closure->data;
 
1405
      data2 = g_value_peek_pointer (param_values + 0);
 
1406
    }
 
1407
  else
 
1408
    {
 
1409
      data1 = g_value_peek_pointer (param_values + 0);
 
1410
      data2 = closure->data;
 
1411
    }
 
1412
  callback = (GMarshalFunc_VOID__INT_INT) (marshal_data ? marshal_data : cc->callback);
 
1413
 
 
1414
  callback (data1,
 
1415
            g_marshal_value_peek_int (param_values + 1),
 
1416
            g_marshal_value_peek_int (param_values + 2),
 
1417
            data2);
 
1418
}
 
1419
 
 
1420
/* VOID:INT,INT,DOUBLE,INT (./rb-marshal.list:31) */
 
1421
extern void rb_marshal_VOID__INT_INT_DOUBLE_INT (GClosure     *closure,
 
1422
                                                 GValue       *return_value,
 
1423
                                                 guint         n_param_values,
 
1424
                                                 const GValue *param_values,
 
1425
                                                 gpointer      invocation_hint,
 
1426
                                                 gpointer      marshal_data);
 
1427
void
 
1428
rb_marshal_VOID__INT_INT_DOUBLE_INT (GClosure     *closure,
 
1429
                                     GValue       *return_value G_GNUC_UNUSED,
 
1430
                                     guint         n_param_values,
 
1431
                                     const GValue *param_values,
 
1432
                                     gpointer      invocation_hint G_GNUC_UNUSED,
 
1433
                                     gpointer      marshal_data)
 
1434
{
 
1435
  typedef void (*GMarshalFunc_VOID__INT_INT_DOUBLE_INT) (gpointer     data1,
 
1436
                                                         gint         arg_1,
 
1437
                                                         gint         arg_2,
 
1438
                                                         gdouble      arg_3,
 
1439
                                                         gint         arg_4,
 
1440
                                                         gpointer     data2);
 
1441
  register GMarshalFunc_VOID__INT_INT_DOUBLE_INT callback;
 
1442
  register GCClosure *cc = (GCClosure*) closure;
 
1443
  register gpointer data1, data2;
 
1444
 
 
1445
  g_return_if_fail (n_param_values == 5);
 
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_INT_DOUBLE_INT) (marshal_data ? marshal_data : cc->callback);
 
1458
 
 
1459
  callback (data1,
 
1460
            g_marshal_value_peek_int (param_values + 1),
 
1461
            g_marshal_value_peek_int (param_values + 2),
 
1462
            g_marshal_value_peek_double (param_values + 3),
 
1463
            g_marshal_value_peek_int (param_values + 4),
 
1464
            data2);
 
1465
}
 
1466
 
 
1467
/* VOID:INT64 (./rb-marshal.list:32) */
 
1468
extern void rb_marshal_VOID__INT64 (GClosure     *closure,
 
1469
                                    GValue       *return_value,
 
1470
                                    guint         n_param_values,
 
1471
                                    const GValue *param_values,
 
1472
                                    gpointer      invocation_hint,
 
1473
                                    gpointer      marshal_data);
 
1474
void
 
1475
rb_marshal_VOID__INT64 (GClosure     *closure,
 
1476
                        GValue       *return_value G_GNUC_UNUSED,
 
1477
                        guint         n_param_values,
 
1478
                        const GValue *param_values,
 
1479
                        gpointer      invocation_hint G_GNUC_UNUSED,
 
1480
                        gpointer      marshal_data)
 
1481
{
 
1482
  typedef void (*GMarshalFunc_VOID__INT64) (gpointer     data1,
 
1483
                                            gint64       arg_1,
 
1484
                                            gpointer     data2);
 
1485
  register GMarshalFunc_VOID__INT64 callback;
 
1486
  register GCClosure *cc = (GCClosure*) closure;
 
1487
  register gpointer data1, data2;
 
1488
 
 
1489
  g_return_if_fail (n_param_values == 2);
 
1490
 
 
1491
  if (G_CCLOSURE_SWAP_DATA (closure))
 
1492
    {
 
1493
      data1 = closure->data;
 
1494
      data2 = g_value_peek_pointer (param_values + 0);
 
1495
    }
 
1496
  else
 
1497
    {
 
1498
      data1 = g_value_peek_pointer (param_values + 0);
 
1499
      data2 = closure->data;
 
1500
    }
 
1501
  callback = (GMarshalFunc_VOID__INT64) (marshal_data ? marshal_data : cc->callback);
 
1502
 
 
1503
  callback (data1,
 
1504
            g_marshal_value_peek_int64 (param_values + 1),
 
1505
            data2);
 
1506
}
 
1507
 
 
1508
/* VOID:OBJECT,INT,INT (./rb-marshal.list:33) */
 
1509
extern void rb_marshal_VOID__OBJECT_INT_INT (GClosure     *closure,
 
1510
                                             GValue       *return_value,
 
1511
                                             guint         n_param_values,
 
1512
                                             const GValue *param_values,
 
1513
                                             gpointer      invocation_hint,
 
1514
                                             gpointer      marshal_data);
 
1515
void
 
1516
rb_marshal_VOID__OBJECT_INT_INT (GClosure     *closure,
 
1517
                                 GValue       *return_value G_GNUC_UNUSED,
 
1518
                                 guint         n_param_values,
 
1519
                                 const GValue *param_values,
 
1520
                                 gpointer      invocation_hint G_GNUC_UNUSED,
 
1521
                                 gpointer      marshal_data)
 
1522
{
 
1523
  typedef void (*GMarshalFunc_VOID__OBJECT_INT_INT) (gpointer     data1,
 
1524
                                                     gpointer     arg_1,
 
1525
                                                     gint         arg_2,
 
1526
                                                     gint         arg_3,
 
1527
                                                     gpointer     data2);
 
1528
  register GMarshalFunc_VOID__OBJECT_INT_INT callback;
 
1529
  register GCClosure *cc = (GCClosure*) closure;
 
1530
  register gpointer data1, data2;
 
1531
 
 
1532
  g_return_if_fail (n_param_values == 4);
 
1533
 
 
1534
  if (G_CCLOSURE_SWAP_DATA (closure))
 
1535
    {
 
1536
      data1 = closure->data;
 
1537
      data2 = g_value_peek_pointer (param_values + 0);
 
1538
    }
 
1539
  else
 
1540
    {
 
1541
      data1 = g_value_peek_pointer (param_values + 0);
 
1542
      data2 = closure->data;
 
1543
    }
 
1544
  callback = (GMarshalFunc_VOID__OBJECT_INT_INT) (marshal_data ? marshal_data : cc->callback);
 
1545
 
 
1546
  callback (data1,
 
1547
            g_marshal_value_peek_object (param_values + 1),
 
1548
            g_marshal_value_peek_int (param_values + 2),
 
1549
            g_marshal_value_peek_int (param_values + 3),
 
1550
            data2);
 
1551
}
 
1552
 
 
1553
/* VOID:OBJECT,INT,INT,BOXED,UINT,UINT (./rb-marshal.list:34) */
 
1554
extern void rb_marshal_VOID__OBJECT_INT_INT_BOXED_UINT_UINT (GClosure     *closure,
 
1555
                                                             GValue       *return_value,
 
1556
                                                             guint         n_param_values,
 
1557
                                                             const GValue *param_values,
 
1558
                                                             gpointer      invocation_hint,
 
1559
                                                             gpointer      marshal_data);
 
1560
void
 
1561
rb_marshal_VOID__OBJECT_INT_INT_BOXED_UINT_UINT (GClosure     *closure,
 
1562
                                                 GValue       *return_value G_GNUC_UNUSED,
 
1563
                                                 guint         n_param_values,
 
1564
                                                 const GValue *param_values,
 
1565
                                                 gpointer      invocation_hint G_GNUC_UNUSED,
 
1566
                                                 gpointer      marshal_data)
 
1567
{
 
1568
  typedef void (*GMarshalFunc_VOID__OBJECT_INT_INT_BOXED_UINT_UINT) (gpointer     data1,
 
1569
                                                                     gpointer     arg_1,
 
1570
                                                                     gint         arg_2,
 
1571
                                                                     gint         arg_3,
 
1572
                                                                     gpointer     arg_4,
 
1573
                                                                     guint        arg_5,
 
1574
                                                                     guint        arg_6,
 
1575
                                                                     gpointer     data2);
 
1576
  register GMarshalFunc_VOID__OBJECT_INT_INT_BOXED_UINT_UINT callback;
 
1577
  register GCClosure *cc = (GCClosure*) closure;
 
1578
  register gpointer data1, data2;
 
1579
 
 
1580
  g_return_if_fail (n_param_values == 7);
 
1581
 
 
1582
  if (G_CCLOSURE_SWAP_DATA (closure))
 
1583
    {
 
1584
      data1 = closure->data;
 
1585
      data2 = g_value_peek_pointer (param_values + 0);
 
1586
    }
 
1587
  else
 
1588
    {
 
1589
      data1 = g_value_peek_pointer (param_values + 0);
 
1590
      data2 = closure->data;
 
1591
    }
 
1592
  callback = (GMarshalFunc_VOID__OBJECT_INT_INT_BOXED_UINT_UINT) (marshal_data ? marshal_data : cc->callback);
 
1593
 
 
1594
  callback (data1,
 
1595
            g_marshal_value_peek_object (param_values + 1),
 
1596
            g_marshal_value_peek_int (param_values + 2),
 
1597
            g_marshal_value_peek_int (param_values + 3),
 
1598
            g_marshal_value_peek_boxed (param_values + 4),
 
1599
            g_marshal_value_peek_uint (param_values + 5),
 
1600
            g_marshal_value_peek_uint (param_values + 6),
 
1601
            data2);
 
1602
}
 
1603
 
 
1604
/* VOID:OBJECT,INT,POINTER (./rb-marshal.list:35) */
 
1605
extern void rb_marshal_VOID__OBJECT_INT_POINTER (GClosure     *closure,
 
1606
                                                 GValue       *return_value,
 
1607
                                                 guint         n_param_values,
 
1608
                                                 const GValue *param_values,
 
1609
                                                 gpointer      invocation_hint,
 
1610
                                                 gpointer      marshal_data);
 
1611
void
 
1612
rb_marshal_VOID__OBJECT_INT_POINTER (GClosure     *closure,
 
1613
                                     GValue       *return_value G_GNUC_UNUSED,
 
1614
                                     guint         n_param_values,
 
1615
                                     const GValue *param_values,
 
1616
                                     gpointer      invocation_hint G_GNUC_UNUSED,
 
1617
                                     gpointer      marshal_data)
 
1618
{
 
1619
  typedef void (*GMarshalFunc_VOID__OBJECT_INT_POINTER) (gpointer     data1,
 
1620
                                                         gpointer     arg_1,
 
1621
                                                         gint         arg_2,
 
1622
                                                         gpointer     arg_3,
 
1623
                                                         gpointer     data2);
 
1624
  register GMarshalFunc_VOID__OBJECT_INT_POINTER callback;
 
1625
  register GCClosure *cc = (GCClosure*) closure;
 
1626
  register gpointer data1, data2;
 
1627
 
 
1628
  g_return_if_fail (n_param_values == 4);
 
1629
 
 
1630
  if (G_CCLOSURE_SWAP_DATA (closure))
 
1631
    {
 
1632
      data1 = closure->data;
 
1633
      data2 = g_value_peek_pointer (param_values + 0);
 
1634
    }
 
1635
  else
 
1636
    {
 
1637
      data1 = g_value_peek_pointer (param_values + 0);
 
1638
      data2 = closure->data;
 
1639
    }
 
1640
  callback = (GMarshalFunc_VOID__OBJECT_INT_POINTER) (marshal_data ? marshal_data : cc->callback);
 
1641
 
 
1642
  callback (data1,
 
1643
            g_marshal_value_peek_object (param_values + 1),
 
1644
            g_marshal_value_peek_int (param_values + 2),
 
1645
            g_marshal_value_peek_pointer (param_values + 3),
 
1646
            data2);
 
1647
}
 
1648
 
 
1649
/* VOID:POINTER,BOOLEAN (./rb-marshal.list:36) */
 
1650
extern void rb_marshal_VOID__POINTER_BOOLEAN (GClosure     *closure,
 
1651
                                              GValue       *return_value,
 
1652
                                              guint         n_param_values,
 
1653
                                              const GValue *param_values,
 
1654
                                              gpointer      invocation_hint,
 
1655
                                              gpointer      marshal_data);
 
1656
void
 
1657
rb_marshal_VOID__POINTER_BOOLEAN (GClosure     *closure,
 
1658
                                  GValue       *return_value G_GNUC_UNUSED,
 
1659
                                  guint         n_param_values,
 
1660
                                  const GValue *param_values,
 
1661
                                  gpointer      invocation_hint G_GNUC_UNUSED,
 
1662
                                  gpointer      marshal_data)
 
1663
{
 
1664
  typedef void (*GMarshalFunc_VOID__POINTER_BOOLEAN) (gpointer     data1,
 
1665
                                                      gpointer     arg_1,
 
1666
                                                      gboolean     arg_2,
 
1667
                                                      gpointer     data2);
 
1668
  register GMarshalFunc_VOID__POINTER_BOOLEAN callback;
 
1669
  register GCClosure *cc = (GCClosure*) closure;
 
1670
  register gpointer data1, data2;
 
1671
 
 
1672
  g_return_if_fail (n_param_values == 3);
 
1673
 
 
1674
  if (G_CCLOSURE_SWAP_DATA (closure))
 
1675
    {
 
1676
      data1 = closure->data;
 
1677
      data2 = g_value_peek_pointer (param_values + 0);
 
1678
    }
 
1679
  else
 
1680
    {
 
1681
      data1 = g_value_peek_pointer (param_values + 0);
 
1682
      data2 = closure->data;
 
1683
    }
 
1684
  callback = (GMarshalFunc_VOID__POINTER_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
 
1685
 
 
1686
  callback (data1,
 
1687
            g_marshal_value_peek_pointer (param_values + 1),
 
1688
            g_marshal_value_peek_boolean (param_values + 2),
 
1689
            data2);
 
1690
}
 
1691
 
 
1692
/* VOID:POINTER,INT (./rb-marshal.list:37) */
 
1693
extern void rb_marshal_VOID__POINTER_INT (GClosure     *closure,
 
1694
                                          GValue       *return_value,
 
1695
                                          guint         n_param_values,
 
1696
                                          const GValue *param_values,
 
1697
                                          gpointer      invocation_hint,
 
1698
                                          gpointer      marshal_data);
 
1699
void
 
1700
rb_marshal_VOID__POINTER_INT (GClosure     *closure,
 
1701
                              GValue       *return_value G_GNUC_UNUSED,
 
1702
                              guint         n_param_values,
 
1703
                              const GValue *param_values,
 
1704
                              gpointer      invocation_hint G_GNUC_UNUSED,
 
1705
                              gpointer      marshal_data)
 
1706
{
 
1707
  typedef void (*GMarshalFunc_VOID__POINTER_INT) (gpointer     data1,
 
1708
                                                  gpointer     arg_1,
 
1709
                                                  gint         arg_2,
 
1710
                                                  gpointer     data2);
 
1711
  register GMarshalFunc_VOID__POINTER_INT callback;
 
1712
  register GCClosure *cc = (GCClosure*) closure;
 
1713
  register gpointer data1, data2;
 
1714
 
 
1715
  g_return_if_fail (n_param_values == 3);
 
1716
 
 
1717
  if (G_CCLOSURE_SWAP_DATA (closure))
 
1718
    {
 
1719
      data1 = closure->data;
 
1720
      data2 = g_value_peek_pointer (param_values + 0);
 
1721
    }
 
1722
  else
 
1723
    {
 
1724
      data1 = g_value_peek_pointer (param_values + 0);
 
1725
      data2 = closure->data;
 
1726
    }
 
1727
  callback = (GMarshalFunc_VOID__POINTER_INT) (marshal_data ? marshal_data : cc->callback);
 
1728
 
 
1729
  callback (data1,
 
1730
            g_marshal_value_peek_pointer (param_values + 1),
 
1731
            g_marshal_value_peek_int (param_values + 2),
 
1732
            data2);
 
1733
}
 
1734
 
 
1735
/* VOID:POINTER,INT64,INT64 (./rb-marshal.list:38) */
 
1736
extern void rb_marshal_VOID__POINTER_INT64_INT64 (GClosure     *closure,
 
1737
                                                  GValue       *return_value,
 
1738
                                                  guint         n_param_values,
 
1739
                                                  const GValue *param_values,
 
1740
                                                  gpointer      invocation_hint,
 
1741
                                                  gpointer      marshal_data);
 
1742
void
 
1743
rb_marshal_VOID__POINTER_INT64_INT64 (GClosure     *closure,
 
1744
                                      GValue       *return_value G_GNUC_UNUSED,
 
1745
                                      guint         n_param_values,
 
1746
                                      const GValue *param_values,
 
1747
                                      gpointer      invocation_hint G_GNUC_UNUSED,
 
1748
                                      gpointer      marshal_data)
 
1749
{
 
1750
  typedef void (*GMarshalFunc_VOID__POINTER_INT64_INT64) (gpointer     data1,
 
1751
                                                          gpointer     arg_1,
 
1752
                                                          gint64       arg_2,
 
1753
                                                          gint64       arg_3,
 
1754
                                                          gpointer     data2);
 
1755
  register GMarshalFunc_VOID__POINTER_INT64_INT64 callback;
 
1756
  register GCClosure *cc = (GCClosure*) closure;
 
1757
  register gpointer data1, data2;
 
1758
 
 
1759
  g_return_if_fail (n_param_values == 4);
 
1760
 
 
1761
  if (G_CCLOSURE_SWAP_DATA (closure))
 
1762
    {
 
1763
      data1 = closure->data;
 
1764
      data2 = g_value_peek_pointer (param_values + 0);
 
1765
    }
 
1766
  else
 
1767
    {
 
1768
      data1 = g_value_peek_pointer (param_values + 0);
 
1769
      data2 = closure->data;
 
1770
    }
 
1771
  callback = (GMarshalFunc_VOID__POINTER_INT64_INT64) (marshal_data ? marshal_data : cc->callback);
 
1772
 
 
1773
  callback (data1,
 
1774
            g_marshal_value_peek_pointer (param_values + 1),
 
1775
            g_marshal_value_peek_int64 (param_values + 2),
 
1776
            g_marshal_value_peek_int64 (param_values + 3),
 
1777
            data2);
 
1778
}
 
1779
 
 
1780
/* VOID:POINTER,INT,POINTER (./rb-marshal.list:39) */
 
1781
extern void rb_marshal_VOID__POINTER_INT_POINTER (GClosure     *closure,
 
1782
                                                  GValue       *return_value,
 
1783
                                                  guint         n_param_values,
 
1784
                                                  const GValue *param_values,
 
1785
                                                  gpointer      invocation_hint,
 
1786
                                                  gpointer      marshal_data);
 
1787
void
 
1788
rb_marshal_VOID__POINTER_INT_POINTER (GClosure     *closure,
 
1789
                                      GValue       *return_value G_GNUC_UNUSED,
 
1790
                                      guint         n_param_values,
 
1791
                                      const GValue *param_values,
 
1792
                                      gpointer      invocation_hint G_GNUC_UNUSED,
 
1793
                                      gpointer      marshal_data)
 
1794
{
 
1795
  typedef void (*GMarshalFunc_VOID__POINTER_INT_POINTER) (gpointer     data1,
 
1796
                                                          gpointer     arg_1,
 
1797
                                                          gint         arg_2,
 
1798
                                                          gpointer     arg_3,
 
1799
                                                          gpointer     data2);
 
1800
  register GMarshalFunc_VOID__POINTER_INT_POINTER callback;
 
1801
  register GCClosure *cc = (GCClosure*) closure;
 
1802
  register gpointer data1, data2;
 
1803
 
 
1804
  g_return_if_fail (n_param_values == 4);
 
1805
 
 
1806
  if (G_CCLOSURE_SWAP_DATA (closure))
 
1807
    {
 
1808
      data1 = closure->data;
 
1809
      data2 = g_value_peek_pointer (param_values + 0);
 
1810
    }
 
1811
  else
 
1812
    {
 
1813
      data1 = g_value_peek_pointer (param_values + 0);
 
1814
      data2 = closure->data;
 
1815
    }
 
1816
  callback = (GMarshalFunc_VOID__POINTER_INT_POINTER) (marshal_data ? marshal_data : cc->callback);
 
1817
 
 
1818
  callback (data1,
 
1819
            g_marshal_value_peek_pointer (param_values + 1),
 
1820
            g_marshal_value_peek_int (param_values + 2),
 
1821
            g_marshal_value_peek_pointer (param_values + 3),
 
1822
            data2);
 
1823
}
 
1824
 
 
1825
/* VOID:POINTER,LONG,LONG (./rb-marshal.list:40) */
 
1826
extern void rb_marshal_VOID__POINTER_LONG_LONG (GClosure     *closure,
 
1827
                                                GValue       *return_value,
 
1828
                                                guint         n_param_values,
 
1829
                                                const GValue *param_values,
 
1830
                                                gpointer      invocation_hint,
 
1831
                                                gpointer      marshal_data);
 
1832
void
 
1833
rb_marshal_VOID__POINTER_LONG_LONG (GClosure     *closure,
 
1834
                                    GValue       *return_value G_GNUC_UNUSED,
 
1835
                                    guint         n_param_values,
 
1836
                                    const GValue *param_values,
 
1837
                                    gpointer      invocation_hint G_GNUC_UNUSED,
 
1838
                                    gpointer      marshal_data)
 
1839
{
 
1840
  typedef void (*GMarshalFunc_VOID__POINTER_LONG_LONG) (gpointer     data1,
 
1841
                                                        gpointer     arg_1,
 
1842
                                                        glong        arg_2,
 
1843
                                                        glong        arg_3,
 
1844
                                                        gpointer     data2);
 
1845
  register GMarshalFunc_VOID__POINTER_LONG_LONG callback;
 
1846
  register GCClosure *cc = (GCClosure*) closure;
 
1847
  register gpointer data1, data2;
 
1848
 
 
1849
  g_return_if_fail (n_param_values == 4);
 
1850
 
 
1851
  if (G_CCLOSURE_SWAP_DATA (closure))
 
1852
    {
 
1853
      data1 = closure->data;
 
1854
      data2 = g_value_peek_pointer (param_values + 0);
 
1855
    }
 
1856
  else
 
1857
    {
 
1858
      data1 = g_value_peek_pointer (param_values + 0);
 
1859
      data2 = closure->data;
 
1860
    }
 
1861
  callback = (GMarshalFunc_VOID__POINTER_LONG_LONG) (marshal_data ? marshal_data : cc->callback);
 
1862
 
 
1863
  callback (data1,
 
1864
            g_marshal_value_peek_pointer (param_values + 1),
 
1865
            g_marshal_value_peek_long (param_values + 2),
 
1866
            g_marshal_value_peek_long (param_values + 3),
 
1867
            data2);
 
1868
}
 
1869
 
 
1870
/* VOID:POINTER,OBJECT (./rb-marshal.list:41) */
 
1871
extern void rb_marshal_VOID__POINTER_OBJECT (GClosure     *closure,
 
1872
                                             GValue       *return_value,
 
1873
                                             guint         n_param_values,
 
1874
                                             const GValue *param_values,
 
1875
                                             gpointer      invocation_hint,
 
1876
                                             gpointer      marshal_data);
 
1877
void
 
1878
rb_marshal_VOID__POINTER_OBJECT (GClosure     *closure,
 
1879
                                 GValue       *return_value G_GNUC_UNUSED,
 
1880
                                 guint         n_param_values,
 
1881
                                 const GValue *param_values,
 
1882
                                 gpointer      invocation_hint G_GNUC_UNUSED,
 
1883
                                 gpointer      marshal_data)
 
1884
{
 
1885
  typedef void (*GMarshalFunc_VOID__POINTER_OBJECT) (gpointer     data1,
 
1886
                                                     gpointer     arg_1,
 
1887
                                                     gpointer     arg_2,
 
1888
                                                     gpointer     data2);
 
1889
  register GMarshalFunc_VOID__POINTER_OBJECT callback;
 
1890
  register GCClosure *cc = (GCClosure*) closure;
 
1891
  register gpointer data1, data2;
 
1892
 
 
1893
  g_return_if_fail (n_param_values == 3);
 
1894
 
 
1895
  if (G_CCLOSURE_SWAP_DATA (closure))
 
1896
    {
 
1897
      data1 = closure->data;
 
1898
      data2 = g_value_peek_pointer (param_values + 0);
 
1899
    }
 
1900
  else
 
1901
    {
 
1902
      data1 = g_value_peek_pointer (param_values + 0);
 
1903
      data2 = closure->data;
 
1904
    }
 
1905
  callback = (GMarshalFunc_VOID__POINTER_OBJECT) (marshal_data ? marshal_data : cc->callback);
 
1906
 
 
1907
  callback (data1,
 
1908
            g_marshal_value_peek_pointer (param_values + 1),
 
1909
            g_marshal_value_peek_object (param_values + 2),
 
1910
            data2);
 
1911
}
 
1912
 
 
1913
/* VOID:POINTER,POINTER (./rb-marshal.list:42) */
 
1914
extern void rb_marshal_VOID__POINTER_POINTER (GClosure     *closure,
 
1915
                                              GValue       *return_value,
 
1916
                                              guint         n_param_values,
 
1917
                                              const GValue *param_values,
 
1918
                                              gpointer      invocation_hint,
 
1919
                                              gpointer      marshal_data);
 
1920
void
 
1921
rb_marshal_VOID__POINTER_POINTER (GClosure     *closure,
 
1922
                                  GValue       *return_value G_GNUC_UNUSED,
 
1923
                                  guint         n_param_values,
 
1924
                                  const GValue *param_values,
 
1925
                                  gpointer      invocation_hint G_GNUC_UNUSED,
 
1926
                                  gpointer      marshal_data)
 
1927
{
 
1928
  typedef void (*GMarshalFunc_VOID__POINTER_POINTER) (gpointer     data1,
 
1929
                                                      gpointer     arg_1,
 
1930
                                                      gpointer     arg_2,
 
1931
                                                      gpointer     data2);
 
1932
  register GMarshalFunc_VOID__POINTER_POINTER callback;
 
1933
  register GCClosure *cc = (GCClosure*) closure;
 
1934
  register gpointer data1, data2;
 
1935
 
 
1936
  g_return_if_fail (n_param_values == 3);
 
1937
 
 
1938
  if (G_CCLOSURE_SWAP_DATA (closure))
 
1939
    {
 
1940
      data1 = closure->data;
 
1941
      data2 = g_value_peek_pointer (param_values + 0);
 
1942
    }
 
1943
  else
 
1944
    {
 
1945
      data1 = g_value_peek_pointer (param_values + 0);
 
1946
      data2 = closure->data;
 
1947
    }
 
1948
  callback = (GMarshalFunc_VOID__POINTER_POINTER) (marshal_data ? marshal_data : cc->callback);
 
1949
 
 
1950
  callback (data1,
 
1951
            g_marshal_value_peek_pointer (param_values + 1),
 
1952
            g_marshal_value_peek_pointer (param_values + 2),
 
1953
            data2);
 
1954
}
 
1955
 
 
1956
/* VOID:POINTER,POINTER,POINTER (./rb-marshal.list:43) */
 
1957
extern void rb_marshal_VOID__POINTER_POINTER_POINTER (GClosure     *closure,
 
1958
                                                      GValue       *return_value,
 
1959
                                                      guint         n_param_values,
 
1960
                                                      const GValue *param_values,
 
1961
                                                      gpointer      invocation_hint,
 
1962
                                                      gpointer      marshal_data);
 
1963
void
 
1964
rb_marshal_VOID__POINTER_POINTER_POINTER (GClosure     *closure,
 
1965
                                          GValue       *return_value G_GNUC_UNUSED,
 
1966
                                          guint         n_param_values,
 
1967
                                          const GValue *param_values,
 
1968
                                          gpointer      invocation_hint G_GNUC_UNUSED,
 
1969
                                          gpointer      marshal_data)
 
1970
{
 
1971
  typedef void (*GMarshalFunc_VOID__POINTER_POINTER_POINTER) (gpointer     data1,
 
1972
                                                              gpointer     arg_1,
 
1973
                                                              gpointer     arg_2,
 
1974
                                                              gpointer     arg_3,
 
1975
                                                              gpointer     data2);
 
1976
  register GMarshalFunc_VOID__POINTER_POINTER_POINTER callback;
 
1977
  register GCClosure *cc = (GCClosure*) closure;
 
1978
  register gpointer data1, data2;
 
1979
 
 
1980
  g_return_if_fail (n_param_values == 4);
 
1981
 
 
1982
  if (G_CCLOSURE_SWAP_DATA (closure))
 
1983
    {
 
1984
      data1 = closure->data;
 
1985
      data2 = g_value_peek_pointer (param_values + 0);
 
1986
    }
 
1987
  else
 
1988
    {
 
1989
      data1 = g_value_peek_pointer (param_values + 0);
 
1990
      data2 = closure->data;
 
1991
    }
 
1992
  callback = (GMarshalFunc_VOID__POINTER_POINTER_POINTER) (marshal_data ? marshal_data : cc->callback);
 
1993
 
 
1994
  callback (data1,
 
1995
            g_marshal_value_peek_pointer (param_values + 1),
 
1996
            g_marshal_value_peek_pointer (param_values + 2),
 
1997
            g_marshal_value_peek_pointer (param_values + 3),
 
1998
            data2);
 
1999
}
 
2000
 
 
2001
/* VOID:POINTER,STRING (./rb-marshal.list:44) */
 
2002
extern void rb_marshal_VOID__POINTER_STRING (GClosure     *closure,
 
2003
                                             GValue       *return_value,
 
2004
                                             guint         n_param_values,
 
2005
                                             const GValue *param_values,
 
2006
                                             gpointer      invocation_hint,
 
2007
                                             gpointer      marshal_data);
 
2008
void
 
2009
rb_marshal_VOID__POINTER_STRING (GClosure     *closure,
 
2010
                                 GValue       *return_value G_GNUC_UNUSED,
 
2011
                                 guint         n_param_values,
 
2012
                                 const GValue *param_values,
 
2013
                                 gpointer      invocation_hint G_GNUC_UNUSED,
 
2014
                                 gpointer      marshal_data)
 
2015
{
 
2016
  typedef void (*GMarshalFunc_VOID__POINTER_STRING) (gpointer     data1,
 
2017
                                                     gpointer     arg_1,
 
2018
                                                     gpointer     arg_2,
 
2019
                                                     gpointer     data2);
 
2020
  register GMarshalFunc_VOID__POINTER_STRING callback;
 
2021
  register GCClosure *cc = (GCClosure*) closure;
 
2022
  register gpointer data1, data2;
 
2023
 
 
2024
  g_return_if_fail (n_param_values == 3);
 
2025
 
 
2026
  if (G_CCLOSURE_SWAP_DATA (closure))
 
2027
    {
 
2028
      data1 = closure->data;
 
2029
      data2 = g_value_peek_pointer (param_values + 0);
 
2030
    }
 
2031
  else
 
2032
    {
 
2033
      data1 = g_value_peek_pointer (param_values + 0);
 
2034
      data2 = closure->data;
 
2035
    }
 
2036
  callback = (GMarshalFunc_VOID__POINTER_STRING) (marshal_data ? marshal_data : cc->callback);
 
2037
 
 
2038
  callback (data1,
 
2039
            g_marshal_value_peek_pointer (param_values + 1),
 
2040
            g_marshal_value_peek_string (param_values + 2),
 
2041
            data2);
 
2042
}
 
2043
 
 
2044
/* VOID:POINTER,UINT (./rb-marshal.list:45) */
 
2045
extern void rb_marshal_VOID__POINTER_UINT (GClosure     *closure,
 
2046
                                           GValue       *return_value,
 
2047
                                           guint         n_param_values,
 
2048
                                           const GValue *param_values,
 
2049
                                           gpointer      invocation_hint,
 
2050
                                           gpointer      marshal_data);
 
2051
void
 
2052
rb_marshal_VOID__POINTER_UINT (GClosure     *closure,
 
2053
                               GValue       *return_value G_GNUC_UNUSED,
 
2054
                               guint         n_param_values,
 
2055
                               const GValue *param_values,
 
2056
                               gpointer      invocation_hint G_GNUC_UNUSED,
 
2057
                               gpointer      marshal_data)
 
2058
{
 
2059
  typedef void (*GMarshalFunc_VOID__POINTER_UINT) (gpointer     data1,
 
2060
                                                   gpointer     arg_1,
 
2061
                                                   guint        arg_2,
 
2062
                                                   gpointer     data2);
 
2063
  register GMarshalFunc_VOID__POINTER_UINT callback;
 
2064
  register GCClosure *cc = (GCClosure*) closure;
 
2065
  register gpointer data1, data2;
 
2066
 
 
2067
  g_return_if_fail (n_param_values == 3);
 
2068
 
 
2069
  if (G_CCLOSURE_SWAP_DATA (closure))
 
2070
    {
 
2071
      data1 = closure->data;
 
2072
      data2 = g_value_peek_pointer (param_values + 0);
 
2073
    }
 
2074
  else
 
2075
    {
 
2076
      data1 = g_value_peek_pointer (param_values + 0);
 
2077
      data2 = closure->data;
 
2078
    }
 
2079
  callback = (GMarshalFunc_VOID__POINTER_UINT) (marshal_data ? marshal_data : cc->callback);
 
2080
 
 
2081
  callback (data1,
 
2082
            g_marshal_value_peek_pointer (param_values + 1),
 
2083
            g_marshal_value_peek_uint (param_values + 2),
 
2084
            data2);
 
2085
}
 
2086
 
 
2087
/* VOID:POINTER,ULONG (./rb-marshal.list:46) */
 
2088
extern void rb_marshal_VOID__POINTER_ULONG (GClosure     *closure,
 
2089
                                            GValue       *return_value,
 
2090
                                            guint         n_param_values,
 
2091
                                            const GValue *param_values,
 
2092
                                            gpointer      invocation_hint,
 
2093
                                            gpointer      marshal_data);
 
2094
void
 
2095
rb_marshal_VOID__POINTER_ULONG (GClosure     *closure,
 
2096
                                GValue       *return_value G_GNUC_UNUSED,
 
2097
                                guint         n_param_values,
 
2098
                                const GValue *param_values,
 
2099
                                gpointer      invocation_hint G_GNUC_UNUSED,
 
2100
                                gpointer      marshal_data)
 
2101
{
 
2102
  typedef void (*GMarshalFunc_VOID__POINTER_ULONG) (gpointer     data1,
 
2103
                                                    gpointer     arg_1,
 
2104
                                                    gulong       arg_2,
 
2105
                                                    gpointer     data2);
 
2106
  register GMarshalFunc_VOID__POINTER_ULONG callback;
 
2107
  register GCClosure *cc = (GCClosure*) closure;
 
2108
  register gpointer data1, data2;
 
2109
 
 
2110
  g_return_if_fail (n_param_values == 3);
 
2111
 
 
2112
  if (G_CCLOSURE_SWAP_DATA (closure))
 
2113
    {
 
2114
      data1 = closure->data;
 
2115
      data2 = g_value_peek_pointer (param_values + 0);
 
2116
    }
 
2117
  else
 
2118
    {
 
2119
      data1 = g_value_peek_pointer (param_values + 0);
 
2120
      data2 = closure->data;
 
2121
    }
 
2122
  callback = (GMarshalFunc_VOID__POINTER_ULONG) (marshal_data ? marshal_data : cc->callback);
 
2123
 
 
2124
  callback (data1,
 
2125
            g_marshal_value_peek_pointer (param_values + 1),
 
2126
            g_marshal_value_peek_ulong (param_values + 2),
 
2127
            data2);
 
2128
}
 
2129
 
 
2130
/* VOID:STRING,DOUBLE (./rb-marshal.list:47) */
 
2131
extern void rb_marshal_VOID__STRING_DOUBLE (GClosure     *closure,
 
2132
                                            GValue       *return_value,
 
2133
                                            guint         n_param_values,
 
2134
                                            const GValue *param_values,
 
2135
                                            gpointer      invocation_hint,
 
2136
                                            gpointer      marshal_data);
 
2137
void
 
2138
rb_marshal_VOID__STRING_DOUBLE (GClosure     *closure,
 
2139
                                GValue       *return_value G_GNUC_UNUSED,
 
2140
                                guint         n_param_values,
 
2141
                                const GValue *param_values,
 
2142
                                gpointer      invocation_hint G_GNUC_UNUSED,
 
2143
                                gpointer      marshal_data)
 
2144
{
 
2145
  typedef void (*GMarshalFunc_VOID__STRING_DOUBLE) (gpointer     data1,
 
2146
                                                    gpointer     arg_1,
 
2147
                                                    gdouble      arg_2,
 
2148
                                                    gpointer     data2);
 
2149
  register GMarshalFunc_VOID__STRING_DOUBLE callback;
 
2150
  register GCClosure *cc = (GCClosure*) closure;
 
2151
  register gpointer data1, data2;
 
2152
 
 
2153
  g_return_if_fail (n_param_values == 3);
 
2154
 
 
2155
  if (G_CCLOSURE_SWAP_DATA (closure))
 
2156
    {
 
2157
      data1 = closure->data;
 
2158
      data2 = g_value_peek_pointer (param_values + 0);
 
2159
    }
 
2160
  else
 
2161
    {
 
2162
      data1 = g_value_peek_pointer (param_values + 0);
 
2163
      data2 = closure->data;
 
2164
    }
 
2165
  callback = (GMarshalFunc_VOID__STRING_DOUBLE) (marshal_data ? marshal_data : cc->callback);
 
2166
 
 
2167
  callback (data1,
 
2168
            g_marshal_value_peek_string (param_values + 1),
 
2169
            g_marshal_value_peek_double (param_values + 2),
 
2170
            data2);
 
2171
}
 
2172
 
 
2173
/* VOID:STRING,INT (./rb-marshal.list:48) */
 
2174
extern void rb_marshal_VOID__STRING_INT (GClosure     *closure,
 
2175
                                         GValue       *return_value,
 
2176
                                         guint         n_param_values,
 
2177
                                         const GValue *param_values,
 
2178
                                         gpointer      invocation_hint,
 
2179
                                         gpointer      marshal_data);
 
2180
void
 
2181
rb_marshal_VOID__STRING_INT (GClosure     *closure,
 
2182
                             GValue       *return_value G_GNUC_UNUSED,
 
2183
                             guint         n_param_values,
 
2184
                             const GValue *param_values,
 
2185
                             gpointer      invocation_hint G_GNUC_UNUSED,
 
2186
                             gpointer      marshal_data)
 
2187
{
 
2188
  typedef void (*GMarshalFunc_VOID__STRING_INT) (gpointer     data1,
 
2189
                                                 gpointer     arg_1,
 
2190
                                                 gint         arg_2,
 
2191
                                                 gpointer     data2);
 
2192
  register GMarshalFunc_VOID__STRING_INT callback;
 
2193
  register GCClosure *cc = (GCClosure*) closure;
 
2194
  register gpointer data1, data2;
 
2195
 
 
2196
  g_return_if_fail (n_param_values == 3);
 
2197
 
 
2198
  if (G_CCLOSURE_SWAP_DATA (closure))
 
2199
    {
 
2200
      data1 = closure->data;
 
2201
      data2 = g_value_peek_pointer (param_values + 0);
 
2202
    }
 
2203
  else
 
2204
    {
 
2205
      data1 = g_value_peek_pointer (param_values + 0);
 
2206
      data2 = closure->data;
 
2207
    }
 
2208
  callback = (GMarshalFunc_VOID__STRING_INT) (marshal_data ? marshal_data : cc->callback);
 
2209
 
 
2210
  callback (data1,
 
2211
            g_marshal_value_peek_string (param_values + 1),
 
2212
            g_marshal_value_peek_int (param_values + 2),
 
2213
            data2);
 
2214
}
 
2215
 
 
2216
/* VOID:STRING,OBJECT (./rb-marshal.list:49) */
 
2217
extern void rb_marshal_VOID__STRING_OBJECT (GClosure     *closure,
 
2218
                                            GValue       *return_value,
 
2219
                                            guint         n_param_values,
 
2220
                                            const GValue *param_values,
 
2221
                                            gpointer      invocation_hint,
 
2222
                                            gpointer      marshal_data);
 
2223
void
 
2224
rb_marshal_VOID__STRING_OBJECT (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_OBJECT) (gpointer     data1,
 
2232
                                                    gpointer     arg_1,
 
2233
                                                    gpointer     arg_2,
 
2234
                                                    gpointer     data2);
 
2235
  register GMarshalFunc_VOID__STRING_OBJECT 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_OBJECT) (marshal_data ? marshal_data : cc->callback);
 
2252
 
 
2253
  callback (data1,
 
2254
            g_marshal_value_peek_string (param_values + 1),
 
2255
            g_marshal_value_peek_object (param_values + 2),
 
2256
            data2);
 
2257
}
 
2258
 
 
2259
/* VOID:STRING,POINTER (./rb-marshal.list:50) */
 
2260
extern void rb_marshal_VOID__STRING_POINTER (GClosure     *closure,
 
2261
                                             GValue       *return_value,
 
2262
                                             guint         n_param_values,
 
2263
                                             const GValue *param_values,
 
2264
                                             gpointer      invocation_hint,
 
2265
                                             gpointer      marshal_data);
 
2266
void
 
2267
rb_marshal_VOID__STRING_POINTER (GClosure     *closure,
 
2268
                                 GValue       *return_value G_GNUC_UNUSED,
 
2269
                                 guint         n_param_values,
 
2270
                                 const GValue *param_values,
 
2271
                                 gpointer      invocation_hint G_GNUC_UNUSED,
 
2272
                                 gpointer      marshal_data)
 
2273
{
 
2274
  typedef void (*GMarshalFunc_VOID__STRING_POINTER) (gpointer     data1,
 
2275
                                                     gpointer     arg_1,
 
2276
                                                     gpointer     arg_2,
 
2277
                                                     gpointer     data2);
 
2278
  register GMarshalFunc_VOID__STRING_POINTER callback;
 
2279
  register GCClosure *cc = (GCClosure*) closure;
 
2280
  register gpointer data1, data2;
 
2281
 
 
2282
  g_return_if_fail (n_param_values == 3);
 
2283
 
 
2284
  if (G_CCLOSURE_SWAP_DATA (closure))
 
2285
    {
 
2286
      data1 = closure->data;
 
2287
      data2 = g_value_peek_pointer (param_values + 0);
 
2288
    }
 
2289
  else
 
2290
    {
 
2291
      data1 = g_value_peek_pointer (param_values + 0);
 
2292
      data2 = closure->data;
 
2293
    }
 
2294
  callback = (GMarshalFunc_VOID__STRING_POINTER) (marshal_data ? marshal_data : cc->callback);
 
2295
 
 
2296
  callback (data1,
 
2297
            g_marshal_value_peek_string (param_values + 1),
 
2298
            g_marshal_value_peek_pointer (param_values + 2),
 
2299
            data2);
 
2300
}
 
2301
 
 
2302
/* VOID:STRING,STRING (./rb-marshal.list:51) */
 
2303
extern void rb_marshal_VOID__STRING_STRING (GClosure     *closure,
 
2304
                                            GValue       *return_value,
 
2305
                                            guint         n_param_values,
 
2306
                                            const GValue *param_values,
 
2307
                                            gpointer      invocation_hint,
 
2308
                                            gpointer      marshal_data);
 
2309
void
 
2310
rb_marshal_VOID__STRING_STRING (GClosure     *closure,
 
2311
                                GValue       *return_value G_GNUC_UNUSED,
 
2312
                                guint         n_param_values,
 
2313
                                const GValue *param_values,
 
2314
                                gpointer      invocation_hint G_GNUC_UNUSED,
 
2315
                                gpointer      marshal_data)
 
2316
{
 
2317
  typedef void (*GMarshalFunc_VOID__STRING_STRING) (gpointer     data1,
 
2318
                                                    gpointer     arg_1,
 
2319
                                                    gpointer     arg_2,
 
2320
                                                    gpointer     data2);
 
2321
  register GMarshalFunc_VOID__STRING_STRING callback;
 
2322
  register GCClosure *cc = (GCClosure*) closure;
 
2323
  register gpointer data1, data2;
 
2324
 
 
2325
  g_return_if_fail (n_param_values == 3);
 
2326
 
 
2327
  if (G_CCLOSURE_SWAP_DATA (closure))
 
2328
    {
 
2329
      data1 = closure->data;
 
2330
      data2 = g_value_peek_pointer (param_values + 0);
 
2331
    }
 
2332
  else
 
2333
    {
 
2334
      data1 = g_value_peek_pointer (param_values + 0);
 
2335
      data2 = closure->data;
 
2336
    }
 
2337
  callback = (GMarshalFunc_VOID__STRING_STRING) (marshal_data ? marshal_data : cc->callback);
 
2338
 
 
2339
  callback (data1,
 
2340
            g_marshal_value_peek_string (param_values + 1),
 
2341
            g_marshal_value_peek_string (param_values + 2),
 
2342
            data2);
 
2343
}
 
2344
 
 
2345
/* VOID:STRING,STRING,OBJECT (./rb-marshal.list:52) */
 
2346
extern void rb_marshal_VOID__STRING_STRING_OBJECT (GClosure     *closure,
 
2347
                                                   GValue       *return_value,
 
2348
                                                   guint         n_param_values,
 
2349
                                                   const GValue *param_values,
 
2350
                                                   gpointer      invocation_hint,
 
2351
                                                   gpointer      marshal_data);
 
2352
void
 
2353
rb_marshal_VOID__STRING_STRING_OBJECT (GClosure     *closure,
 
2354
                                       GValue       *return_value G_GNUC_UNUSED,
 
2355
                                       guint         n_param_values,
 
2356
                                       const GValue *param_values,
 
2357
                                       gpointer      invocation_hint G_GNUC_UNUSED,
 
2358
                                       gpointer      marshal_data)
 
2359
{
 
2360
  typedef void (*GMarshalFunc_VOID__STRING_STRING_OBJECT) (gpointer     data1,
 
2361
                                                           gpointer     arg_1,
 
2362
                                                           gpointer     arg_2,
 
2363
                                                           gpointer     arg_3,
 
2364
                                                           gpointer     data2);
 
2365
  register GMarshalFunc_VOID__STRING_STRING_OBJECT callback;
 
2366
  register GCClosure *cc = (GCClosure*) closure;
 
2367
  register gpointer data1, data2;
 
2368
 
 
2369
  g_return_if_fail (n_param_values == 4);
 
2370
 
 
2371
  if (G_CCLOSURE_SWAP_DATA (closure))
 
2372
    {
 
2373
      data1 = closure->data;
 
2374
      data2 = g_value_peek_pointer (param_values + 0);
 
2375
    }
 
2376
  else
 
2377
    {
 
2378
      data1 = g_value_peek_pointer (param_values + 0);
 
2379
      data2 = closure->data;
 
2380
    }
 
2381
  callback = (GMarshalFunc_VOID__STRING_STRING_OBJECT) (marshal_data ? marshal_data : cc->callback);
 
2382
 
 
2383
  callback (data1,
 
2384
            g_marshal_value_peek_string (param_values + 1),
 
2385
            g_marshal_value_peek_string (param_values + 2),
 
2386
            g_marshal_value_peek_object (param_values + 3),
 
2387
            data2);
 
2388
}
 
2389
 
 
2390
/* VOID:STRING,STRING,STRING (./rb-marshal.list:53) */
 
2391
extern void rb_marshal_VOID__STRING_STRING_STRING (GClosure     *closure,
 
2392
                                                   GValue       *return_value,
 
2393
                                                   guint         n_param_values,
 
2394
                                                   const GValue *param_values,
 
2395
                                                   gpointer      invocation_hint,
 
2396
                                                   gpointer      marshal_data);
 
2397
void
 
2398
rb_marshal_VOID__STRING_STRING_STRING (GClosure     *closure,
 
2399
                                       GValue       *return_value G_GNUC_UNUSED,
 
2400
                                       guint         n_param_values,
 
2401
                                       const GValue *param_values,
 
2402
                                       gpointer      invocation_hint G_GNUC_UNUSED,
 
2403
                                       gpointer      marshal_data)
 
2404
{
 
2405
  typedef void (*GMarshalFunc_VOID__STRING_STRING_STRING) (gpointer     data1,
 
2406
                                                           gpointer     arg_1,
 
2407
                                                           gpointer     arg_2,
 
2408
                                                           gpointer     arg_3,
 
2409
                                                           gpointer     data2);
 
2410
  register GMarshalFunc_VOID__STRING_STRING_STRING callback;
 
2411
  register GCClosure *cc = (GCClosure*) closure;
 
2412
  register gpointer data1, data2;
 
2413
 
 
2414
  g_return_if_fail (n_param_values == 4);
 
2415
 
 
2416
  if (G_CCLOSURE_SWAP_DATA (closure))
 
2417
    {
 
2418
      data1 = closure->data;
 
2419
      data2 = g_value_peek_pointer (param_values + 0);
 
2420
    }
 
2421
  else
 
2422
    {
 
2423
      data1 = g_value_peek_pointer (param_values + 0);
 
2424
      data2 = closure->data;
 
2425
    }
 
2426
  callback = (GMarshalFunc_VOID__STRING_STRING_STRING) (marshal_data ? marshal_data : cc->callback);
 
2427
 
 
2428
  callback (data1,
 
2429
            g_marshal_value_peek_string (param_values + 1),
 
2430
            g_marshal_value_peek_string (param_values + 2),
 
2431
            g_marshal_value_peek_string (param_values + 3),
 
2432
            data2);
 
2433
}
 
2434
 
 
2435
/* VOID:STRING,STRING,STRING,UINT,BOOLEAN (./rb-marshal.list:54) */
 
2436
extern void rb_marshal_VOID__STRING_STRING_STRING_UINT_BOOLEAN (GClosure     *closure,
 
2437
                                                                GValue       *return_value,
 
2438
                                                                guint         n_param_values,
 
2439
                                                                const GValue *param_values,
 
2440
                                                                gpointer      invocation_hint,
 
2441
                                                                gpointer      marshal_data);
 
2442
void
 
2443
rb_marshal_VOID__STRING_STRING_STRING_UINT_BOOLEAN (GClosure     *closure,
 
2444
                                                    GValue       *return_value G_GNUC_UNUSED,
 
2445
                                                    guint         n_param_values,
 
2446
                                                    const GValue *param_values,
 
2447
                                                    gpointer      invocation_hint G_GNUC_UNUSED,
 
2448
                                                    gpointer      marshal_data)
 
2449
{
 
2450
  typedef void (*GMarshalFunc_VOID__STRING_STRING_STRING_UINT_BOOLEAN) (gpointer     data1,
 
2451
                                                                        gpointer     arg_1,
 
2452
                                                                        gpointer     arg_2,
 
2453
                                                                        gpointer     arg_3,
 
2454
                                                                        guint        arg_4,
 
2455
                                                                        gboolean     arg_5,
 
2456
                                                                        gpointer     data2);
 
2457
  register GMarshalFunc_VOID__STRING_STRING_STRING_UINT_BOOLEAN callback;
 
2458
  register GCClosure *cc = (GCClosure*) closure;
 
2459
  register gpointer data1, data2;
 
2460
 
 
2461
  g_return_if_fail (n_param_values == 6);
 
2462
 
 
2463
  if (G_CCLOSURE_SWAP_DATA (closure))
 
2464
    {
 
2465
      data1 = closure->data;
 
2466
      data2 = g_value_peek_pointer (param_values + 0);
 
2467
    }
 
2468
  else
 
2469
    {
 
2470
      data1 = g_value_peek_pointer (param_values + 0);
 
2471
      data2 = closure->data;
 
2472
    }
 
2473
  callback = (GMarshalFunc_VOID__STRING_STRING_STRING_UINT_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
 
2474
 
 
2475
  callback (data1,
 
2476
            g_marshal_value_peek_string (param_values + 1),
 
2477
            g_marshal_value_peek_string (param_values + 2),
 
2478
            g_marshal_value_peek_string (param_values + 3),
 
2479
            g_marshal_value_peek_uint (param_values + 4),
 
2480
            g_marshal_value_peek_boolean (param_values + 5),
 
2481
            data2);
 
2482
}
 
2483
 
 
2484
/* VOID:UINT,STRING,STRING,STRING,BOOLEAN (./rb-marshal.list:55) */
 
2485
extern void rb_marshal_VOID__UINT_STRING_STRING_STRING_BOOLEAN (GClosure     *closure,
 
2486
                                                                GValue       *return_value,
 
2487
                                                                guint         n_param_values,
 
2488
                                                                const GValue *param_values,
 
2489
                                                                gpointer      invocation_hint,
 
2490
                                                                gpointer      marshal_data);
 
2491
void
 
2492
rb_marshal_VOID__UINT_STRING_STRING_STRING_BOOLEAN (GClosure     *closure,
 
2493
                                                    GValue       *return_value G_GNUC_UNUSED,
 
2494
                                                    guint         n_param_values,
 
2495
                                                    const GValue *param_values,
 
2496
                                                    gpointer      invocation_hint G_GNUC_UNUSED,
 
2497
                                                    gpointer      marshal_data)
 
2498
{
 
2499
  typedef void (*GMarshalFunc_VOID__UINT_STRING_STRING_STRING_BOOLEAN) (gpointer     data1,
 
2500
                                                                        guint        arg_1,
 
2501
                                                                        gpointer     arg_2,
 
2502
                                                                        gpointer     arg_3,
 
2503
                                                                        gpointer     arg_4,
 
2504
                                                                        gboolean     arg_5,
 
2505
                                                                        gpointer     data2);
 
2506
  register GMarshalFunc_VOID__UINT_STRING_STRING_STRING_BOOLEAN callback;
 
2507
  register GCClosure *cc = (GCClosure*) closure;
 
2508
  register gpointer data1, data2;
 
2509
 
 
2510
  g_return_if_fail (n_param_values == 6);
 
2511
 
 
2512
  if (G_CCLOSURE_SWAP_DATA (closure))
 
2513
    {
 
2514
      data1 = closure->data;
 
2515
      data2 = g_value_peek_pointer (param_values + 0);
 
2516
    }
 
2517
  else
 
2518
    {
 
2519
      data1 = g_value_peek_pointer (param_values + 0);
 
2520
      data2 = closure->data;
 
2521
    }
 
2522
  callback = (GMarshalFunc_VOID__UINT_STRING_STRING_STRING_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
 
2523
 
 
2524
  callback (data1,
 
2525
            g_marshal_value_peek_uint (param_values + 1),
 
2526
            g_marshal_value_peek_string (param_values + 2),
 
2527
            g_marshal_value_peek_string (param_values + 3),
 
2528
            g_marshal_value_peek_string (param_values + 4),
 
2529
            g_marshal_value_peek_boolean (param_values + 5),
 
2530
            data2);
 
2531
}
 
2532
 
 
2533
/* VOID:UINT64 (./rb-marshal.list:56) */
 
2534
extern void rb_marshal_VOID__UINT64 (GClosure     *closure,
 
2535
                                     GValue       *return_value,
 
2536
                                     guint         n_param_values,
 
2537
                                     const GValue *param_values,
 
2538
                                     gpointer      invocation_hint,
 
2539
                                     gpointer      marshal_data);
 
2540
void
 
2541
rb_marshal_VOID__UINT64 (GClosure     *closure,
 
2542
                         GValue       *return_value G_GNUC_UNUSED,
 
2543
                         guint         n_param_values,
 
2544
                         const GValue *param_values,
 
2545
                         gpointer      invocation_hint G_GNUC_UNUSED,
 
2546
                         gpointer      marshal_data)
 
2547
{
 
2548
  typedef void (*GMarshalFunc_VOID__UINT64) (gpointer     data1,
 
2549
                                             guint64      arg_1,
 
2550
                                             gpointer     data2);
 
2551
  register GMarshalFunc_VOID__UINT64 callback;
 
2552
  register GCClosure *cc = (GCClosure*) closure;
 
2553
  register gpointer data1, data2;
 
2554
 
 
2555
  g_return_if_fail (n_param_values == 2);
 
2556
 
 
2557
  if (G_CCLOSURE_SWAP_DATA (closure))
 
2558
    {
 
2559
      data1 = closure->data;
 
2560
      data2 = g_value_peek_pointer (param_values + 0);
 
2561
    }
 
2562
  else
 
2563
    {
 
2564
      data1 = g_value_peek_pointer (param_values + 0);
 
2565
      data2 = closure->data;
 
2566
    }
 
2567
  callback = (GMarshalFunc_VOID__UINT64) (marshal_data ? marshal_data : cc->callback);
 
2568
 
 
2569
  callback (data1,
 
2570
            g_marshal_value_peek_uint64 (param_values + 1),
 
2571
            data2);
 
2572
}
 
2573
 
 
2574
/* VOID:UINT64,STRING,POINTER (./rb-marshal.list:57) */
 
2575
extern void rb_marshal_VOID__UINT64_STRING_POINTER (GClosure     *closure,
 
2576
                                                    GValue       *return_value,
 
2577
                                                    guint         n_param_values,
 
2578
                                                    const GValue *param_values,
 
2579
                                                    gpointer      invocation_hint,
 
2580
                                                    gpointer      marshal_data);
 
2581
void
 
2582
rb_marshal_VOID__UINT64_STRING_POINTER (GClosure     *closure,
 
2583
                                        GValue       *return_value G_GNUC_UNUSED,
 
2584
                                        guint         n_param_values,
 
2585
                                        const GValue *param_values,
 
2586
                                        gpointer      invocation_hint G_GNUC_UNUSED,
 
2587
                                        gpointer      marshal_data)
 
2588
{
 
2589
  typedef void (*GMarshalFunc_VOID__UINT64_STRING_POINTER) (gpointer     data1,
 
2590
                                                            guint64      arg_1,
 
2591
                                                            gpointer     arg_2,
 
2592
                                                            gpointer     arg_3,
 
2593
                                                            gpointer     data2);
 
2594
  register GMarshalFunc_VOID__UINT64_STRING_POINTER callback;
 
2595
  register GCClosure *cc = (GCClosure*) closure;
 
2596
  register gpointer data1, data2;
 
2597
 
 
2598
  g_return_if_fail (n_param_values == 4);
 
2599
 
 
2600
  if (G_CCLOSURE_SWAP_DATA (closure))
 
2601
    {
 
2602
      data1 = closure->data;
 
2603
      data2 = g_value_peek_pointer (param_values + 0);
 
2604
    }
 
2605
  else
 
2606
    {
 
2607
      data1 = g_value_peek_pointer (param_values + 0);
 
2608
      data2 = closure->data;
 
2609
    }
 
2610
  callback = (GMarshalFunc_VOID__UINT64_STRING_POINTER) (marshal_data ? marshal_data : cc->callback);
 
2611
 
 
2612
  callback (data1,
 
2613
            g_marshal_value_peek_uint64 (param_values + 1),
 
2614
            g_marshal_value_peek_string (param_values + 2),
 
2615
            g_marshal_value_peek_pointer (param_values + 3),
 
2616
            data2);
 
2617
}
 
2618
 
 
2619
/* VOID:ULONG,FLOAT (./rb-marshal.list:58) */
 
2620
extern void rb_marshal_VOID__ULONG_FLOAT (GClosure     *closure,
 
2621
                                          GValue       *return_value,
 
2622
                                          guint         n_param_values,
 
2623
                                          const GValue *param_values,
 
2624
                                          gpointer      invocation_hint,
 
2625
                                          gpointer      marshal_data);
 
2626
void
 
2627
rb_marshal_VOID__ULONG_FLOAT (GClosure     *closure,
 
2628
                              GValue       *return_value G_GNUC_UNUSED,
 
2629
                              guint         n_param_values,
 
2630
                              const GValue *param_values,
 
2631
                              gpointer      invocation_hint G_GNUC_UNUSED,
 
2632
                              gpointer      marshal_data)
 
2633
{
 
2634
  typedef void (*GMarshalFunc_VOID__ULONG_FLOAT) (gpointer     data1,
 
2635
                                                  gulong       arg_1,
 
2636
                                                  gfloat       arg_2,
 
2637
                                                  gpointer     data2);
 
2638
  register GMarshalFunc_VOID__ULONG_FLOAT callback;
 
2639
  register GCClosure *cc = (GCClosure*) closure;
 
2640
  register gpointer data1, data2;
 
2641
 
 
2642
  g_return_if_fail (n_param_values == 3);
 
2643
 
 
2644
  if (G_CCLOSURE_SWAP_DATA (closure))
 
2645
    {
 
2646
      data1 = closure->data;
 
2647
      data2 = g_value_peek_pointer (param_values + 0);
 
2648
    }
 
2649
  else
 
2650
    {
 
2651
      data1 = g_value_peek_pointer (param_values + 0);
 
2652
      data2 = closure->data;
 
2653
    }
 
2654
  callback = (GMarshalFunc_VOID__ULONG_FLOAT) (marshal_data ? marshal_data : cc->callback);
 
2655
 
 
2656
  callback (data1,
 
2657
            g_marshal_value_peek_ulong (param_values + 1),
 
2658
            g_marshal_value_peek_float (param_values + 2),
 
2659
            data2);
 
2660
}
 
2661
 
 
2662
/* VOID:OBJECT,BOOLEAN (./rb-marshal.list:59) */
 
2663
extern void rb_marshal_VOID__OBJECT_BOOLEAN (GClosure     *closure,
 
2664
                                             GValue       *return_value,
 
2665
                                             guint         n_param_values,
 
2666
                                             const GValue *param_values,
 
2667
                                             gpointer      invocation_hint,
 
2668
                                             gpointer      marshal_data);
 
2669
void
 
2670
rb_marshal_VOID__OBJECT_BOOLEAN (GClosure     *closure,
 
2671
                                 GValue       *return_value G_GNUC_UNUSED,
 
2672
                                 guint         n_param_values,
 
2673
                                 const GValue *param_values,
 
2674
                                 gpointer      invocation_hint G_GNUC_UNUSED,
 
2675
                                 gpointer      marshal_data)
 
2676
{
 
2677
  typedef void (*GMarshalFunc_VOID__OBJECT_BOOLEAN) (gpointer     data1,
 
2678
                                                     gpointer     arg_1,
 
2679
                                                     gboolean     arg_2,
 
2680
                                                     gpointer     data2);
 
2681
  register GMarshalFunc_VOID__OBJECT_BOOLEAN callback;
 
2682
  register GCClosure *cc = (GCClosure*) closure;
 
2683
  register gpointer data1, data2;
 
2684
 
 
2685
  g_return_if_fail (n_param_values == 3);
 
2686
 
 
2687
  if (G_CCLOSURE_SWAP_DATA (closure))
 
2688
    {
 
2689
      data1 = closure->data;
 
2690
      data2 = g_value_peek_pointer (param_values + 0);
 
2691
    }
 
2692
  else
 
2693
    {
 
2694
      data1 = g_value_peek_pointer (param_values + 0);
 
2695
      data2 = closure->data;
 
2696
    }
 
2697
  callback = (GMarshalFunc_VOID__OBJECT_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
 
2698
 
 
2699
  callback (data1,
 
2700
            g_marshal_value_peek_object (param_values + 1),
 
2701
            g_marshal_value_peek_boolean (param_values + 2),
 
2702
            data2);
 
2703
}
 
2704
 
 
2705
/* VOID:STRING,STRING,POINTER,POINTER (./rb-marshal.list:60) */
 
2706
extern void rb_marshal_VOID__STRING_STRING_POINTER_POINTER (GClosure     *closure,
 
2707
                                                            GValue       *return_value,
 
2708
                                                            guint         n_param_values,
 
2709
                                                            const GValue *param_values,
 
2710
                                                            gpointer      invocation_hint,
 
2711
                                                            gpointer      marshal_data);
 
2712
void
 
2713
rb_marshal_VOID__STRING_STRING_POINTER_POINTER (GClosure     *closure,
 
2714
                                                GValue       *return_value G_GNUC_UNUSED,
 
2715
                                                guint         n_param_values,
 
2716
                                                const GValue *param_values,
 
2717
                                                gpointer      invocation_hint G_GNUC_UNUSED,
 
2718
                                                gpointer      marshal_data)
 
2719
{
 
2720
  typedef void (*GMarshalFunc_VOID__STRING_STRING_POINTER_POINTER) (gpointer     data1,
 
2721
                                                                    gpointer     arg_1,
 
2722
                                                                    gpointer     arg_2,
 
2723
                                                                    gpointer     arg_3,
 
2724
                                                                    gpointer     arg_4,
 
2725
                                                                    gpointer     data2);
 
2726
  register GMarshalFunc_VOID__STRING_STRING_POINTER_POINTER callback;
 
2727
  register GCClosure *cc = (GCClosure*) closure;
 
2728
  register gpointer data1, data2;
 
2729
 
 
2730
  g_return_if_fail (n_param_values == 5);
 
2731
 
 
2732
  if (G_CCLOSURE_SWAP_DATA (closure))
 
2733
    {
 
2734
      data1 = closure->data;
 
2735
      data2 = g_value_peek_pointer (param_values + 0);
 
2736
    }
 
2737
  else
 
2738
    {
 
2739
      data1 = g_value_peek_pointer (param_values + 0);
 
2740
      data2 = closure->data;
 
2741
    }
 
2742
  callback = (GMarshalFunc_VOID__STRING_STRING_POINTER_POINTER) (marshal_data ? marshal_data : cc->callback);
 
2743
 
 
2744
  callback (data1,
 
2745
            g_marshal_value_peek_string (param_values + 1),
 
2746
            g_marshal_value_peek_string (param_values + 2),
 
2747
            g_marshal_value_peek_pointer (param_values + 3),
 
2748
            g_marshal_value_peek_pointer (param_values + 4),
 
2749
            data2);
 
2750
}
 
2751
 
 
2752
/* VOID:STRING,UINT,UINT,STRING (./rb-marshal.list:61) */
 
2753
extern void rb_marshal_VOID__STRING_UINT_UINT_STRING (GClosure     *closure,
 
2754
                                                      GValue       *return_value,
 
2755
                                                      guint         n_param_values,
 
2756
                                                      const GValue *param_values,
 
2757
                                                      gpointer      invocation_hint,
 
2758
                                                      gpointer      marshal_data);
 
2759
void
 
2760
rb_marshal_VOID__STRING_UINT_UINT_STRING (GClosure     *closure,
 
2761
                                          GValue       *return_value G_GNUC_UNUSED,
 
2762
                                          guint         n_param_values,
 
2763
                                          const GValue *param_values,
 
2764
                                          gpointer      invocation_hint G_GNUC_UNUSED,
 
2765
                                          gpointer      marshal_data)
 
2766
{
 
2767
  typedef void (*GMarshalFunc_VOID__STRING_UINT_UINT_STRING) (gpointer     data1,
 
2768
                                                              gpointer     arg_1,
 
2769
                                                              guint        arg_2,
 
2770
                                                              guint        arg_3,
 
2771
                                                              gpointer     arg_4,
 
2772
                                                              gpointer     data2);
 
2773
  register GMarshalFunc_VOID__STRING_UINT_UINT_STRING callback;
 
2774
  register GCClosure *cc = (GCClosure*) closure;
 
2775
  register gpointer data1, data2;
 
2776
 
 
2777
  g_return_if_fail (n_param_values == 5);
 
2778
 
 
2779
  if (G_CCLOSURE_SWAP_DATA (closure))
 
2780
    {
 
2781
      data1 = closure->data;
 
2782
      data2 = g_value_peek_pointer (param_values + 0);
 
2783
    }
 
2784
  else
 
2785
    {
 
2786
      data1 = g_value_peek_pointer (param_values + 0);
 
2787
      data2 = closure->data;
 
2788
    }
 
2789
  callback = (GMarshalFunc_VOID__STRING_UINT_UINT_STRING) (marshal_data ? marshal_data : cc->callback);
 
2790
 
 
2791
  callback (data1,
 
2792
            g_marshal_value_peek_string (param_values + 1),
 
2793
            g_marshal_value_peek_uint (param_values + 2),
 
2794
            g_marshal_value_peek_uint (param_values + 3),
 
2795
            g_marshal_value_peek_string (param_values + 4),
 
2796
            data2);
 
2797
}
 
2798
 
 
2799
G_END_DECLS
 
2800
 
 
2801
#endif /* __rb_marshal_MARSHAL_H__ */
 
2802