← Back to branch summary

~jeremywootten/pantheon-files/fix-sidebar-dragging

« back to all changes in this revision

Viewing changes to src/eel-marshal.c

  • Committer: am.monkeyd at gmail
  • Date: 2010-11-08 13:17:02 UTC
  • Revision ID: am.monkeyd@gmail.com-20101108131702-rqeywh4r5pyx2ycz
let's roll

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/eel-marshal.c
 
1
//#include      <glib-object.h>
 
2
#include "eel-marshal.h"
 
3
 
 
4
 
 
5
#ifdef G_ENABLE_DEBUG
 
6
#define g_marshal_value_peek_boolean(v)  g_value_get_boolean (v)
 
7
#define g_marshal_value_peek_char(v)     g_value_get_char (v)
 
8
#define g_marshal_value_peek_uchar(v)    g_value_get_uchar (v)
 
9
#define g_marshal_value_peek_int(v)      g_value_get_int (v)
 
10
#define g_marshal_value_peek_uint(v)     g_value_get_uint (v)
 
11
#define g_marshal_value_peek_long(v)     g_value_get_long (v)
 
12
#define g_marshal_value_peek_ulong(v)    g_value_get_ulong (v)
 
13
#define g_marshal_value_peek_int64(v)    g_value_get_int64 (v)
 
14
#define g_marshal_value_peek_uint64(v)   g_value_get_uint64 (v)
 
15
#define g_marshal_value_peek_enum(v)     g_value_get_enum (v)
 
16
#define g_marshal_value_peek_flags(v)    g_value_get_flags (v)
 
17
#define g_marshal_value_peek_float(v)    g_value_get_float (v)
 
18
#define g_marshal_value_peek_double(v)   g_value_get_double (v)
 
19
#define g_marshal_value_peek_string(v)   (char*) g_value_get_string (v)
 
20
#define g_marshal_value_peek_param(v)    g_value_get_param (v)
 
21
#define g_marshal_value_peek_boxed(v)    g_value_get_boxed (v)
 
22
#define g_marshal_value_peek_pointer(v)  g_value_get_pointer (v)
 
23
#define g_marshal_value_peek_object(v)   g_value_get_object (v)
 
24
#define g_marshal_value_peek_variant(v)  g_value_get_variant (v)
 
25
#else /* !G_ENABLE_DEBUG */
 
26
/* WARNING: This code accesses GValues directly, which is UNSUPPORTED API.
 
27
 *          Do not access GValues directly in your code. Instead, use the
 
28
 *          g_value_get_*() functions
 
29
 */
 
30
#define g_marshal_value_peek_boolean(v)  (v)->data[0].v_int
 
31
#define g_marshal_value_peek_char(v)     (v)->data[0].v_int
 
32
#define g_marshal_value_peek_uchar(v)    (v)->data[0].v_uint
 
33
#define g_marshal_value_peek_int(v)      (v)->data[0].v_int
 
34
#define g_marshal_value_peek_uint(v)     (v)->data[0].v_uint
 
35
#define g_marshal_value_peek_long(v)     (v)->data[0].v_long
 
36
#define g_marshal_value_peek_ulong(v)    (v)->data[0].v_ulong
 
37
#define g_marshal_value_peek_int64(v)    (v)->data[0].v_int64
 
38
#define g_marshal_value_peek_uint64(v)   (v)->data[0].v_uint64
 
39
#define g_marshal_value_peek_enum(v)     (v)->data[0].v_long
 
40
#define g_marshal_value_peek_flags(v)    (v)->data[0].v_ulong
 
41
#define g_marshal_value_peek_float(v)    (v)->data[0].v_float
 
42
#define g_marshal_value_peek_double(v)   (v)->data[0].v_double
 
43
#define g_marshal_value_peek_string(v)   (v)->data[0].v_pointer
 
44
#define g_marshal_value_peek_param(v)    (v)->data[0].v_pointer
 
45
#define g_marshal_value_peek_boxed(v)    (v)->data[0].v_pointer
 
46
#define g_marshal_value_peek_pointer(v)  (v)->data[0].v_pointer
 
47
#define g_marshal_value_peek_object(v)   (v)->data[0].v_pointer
 
48
#define g_marshal_value_peek_variant(v)  (v)->data[0].v_pointer
 
49
#endif /* !G_ENABLE_DEBUG */
 
50
 
 
51
 
 
52
/* BOOLEAN:BOOLEAN (eelmarshal.list:1) */
 
53
void
 
54
eel_marshal_BOOLEAN__BOOLEAN (GClosure     *closure,
 
55
                              GValue       *return_value G_GNUC_UNUSED,
 
56
                              guint         n_param_values,
 
57
                              const GValue *param_values,
 
58
                              gpointer      invocation_hint G_GNUC_UNUSED,
 
59
                              gpointer      marshal_data)
 
60
{
 
61
  typedef gboolean (*GMarshalFunc_BOOLEAN__BOOLEAN) (gpointer     data1,
 
62
                                                     gboolean     arg_1,
 
63
                                                     gpointer     data2);
 
64
  register GMarshalFunc_BOOLEAN__BOOLEAN callback;
 
65
  register GCClosure *cc = (GCClosure*) closure;
 
66
  register gpointer data1, data2;
 
67
  gboolean v_return;
 
68
 
 
69
  g_return_if_fail (return_value != NULL);
 
70
  g_return_if_fail (n_param_values == 2);
 
71
 
 
72
  if (G_CCLOSURE_SWAP_DATA (closure))
 
73
    {
 
74
      data1 = closure->data;
 
75
      data2 = g_value_peek_pointer (param_values + 0);
 
76
    }
 
77
  else
 
78
    {
 
79
      data1 = g_value_peek_pointer (param_values + 0);
 
80
      data2 = closure->data;
 
81
    }
 
82
  callback = (GMarshalFunc_BOOLEAN__BOOLEAN) (marshal_data ? marshal_data : cc->callback);
 
83
 
 
84
  v_return = callback (data1,
 
85
                       g_marshal_value_peek_boolean (param_values + 1),
 
86
                       data2);
 
87
 
 
88
  g_value_set_boolean (return_value, v_return);
 
89
}
 
90
 
 
91
/* BOOLEAN:BOXED (eelmarshal.list:2) */
 
92
void
 
93
eel_marshal_BOOLEAN__BOXED (GClosure     *closure,
 
94
                            GValue       *return_value G_GNUC_UNUSED,
 
95
                            guint         n_param_values,
 
96
                            const GValue *param_values,
 
97
                            gpointer      invocation_hint G_GNUC_UNUSED,
 
98
                            gpointer      marshal_data)
 
99
{
 
100
  typedef gboolean (*GMarshalFunc_BOOLEAN__BOXED) (gpointer     data1,
 
101
                                                   gpointer     arg_1,
 
102
                                                   gpointer     data2);
 
103
  register GMarshalFunc_BOOLEAN__BOXED callback;
 
104
  register GCClosure *cc = (GCClosure*) closure;
 
105
  register gpointer data1, data2;
 
106
  gboolean v_return;
 
107
 
 
108
  g_return_if_fail (return_value != NULL);
 
109
  g_return_if_fail (n_param_values == 2);
 
110
 
 
111
  if (G_CCLOSURE_SWAP_DATA (closure))
 
112
    {
 
113
      data1 = closure->data;
 
114
      data2 = g_value_peek_pointer (param_values + 0);
 
115
    }
 
116
  else
 
117
    {
 
118
      data1 = g_value_peek_pointer (param_values + 0);
 
119
      data2 = closure->data;
 
120
    }
 
121
  callback = (GMarshalFunc_BOOLEAN__BOXED) (marshal_data ? marshal_data : cc->callback);
 
122
 
 
123
  v_return = callback (data1,
 
124
                       g_marshal_value_peek_boxed (param_values + 1),
 
125
                       data2);
 
126
 
 
127
  g_value_set_boolean (return_value, v_return);
 
128
}
 
129
 
 
130
/* BOOLEAN:POINTER,POINTER (eelmarshal.list:3) */
 
131
void
 
132
eel_marshal_BOOLEAN__POINTER_POINTER (GClosure     *closure,
 
133
                                      GValue       *return_value G_GNUC_UNUSED,
 
134
                                      guint         n_param_values,
 
135
                                      const GValue *param_values,
 
136
                                      gpointer      invocation_hint G_GNUC_UNUSED,
 
137
                                      gpointer      marshal_data)
 
138
{
 
139
  typedef gboolean (*GMarshalFunc_BOOLEAN__POINTER_POINTER) (gpointer     data1,
 
140
                                                             gpointer     arg_1,
 
141
                                                             gpointer     arg_2,
 
142
                                                             gpointer     data2);
 
143
  register GMarshalFunc_BOOLEAN__POINTER_POINTER callback;
 
144
  register GCClosure *cc = (GCClosure*) closure;
 
145
  register gpointer data1, data2;
 
146
  gboolean v_return;
 
147
 
 
148
  g_return_if_fail (return_value != NULL);
 
149
  g_return_if_fail (n_param_values == 3);
 
150
 
 
151
  if (G_CCLOSURE_SWAP_DATA (closure))
 
152
    {
 
153
      data1 = closure->data;
 
154
      data2 = g_value_peek_pointer (param_values + 0);
 
155
    }
 
156
  else
 
157
    {
 
158
      data1 = g_value_peek_pointer (param_values + 0);
 
159
      data2 = closure->data;
 
160
    }
 
161
  callback = (GMarshalFunc_BOOLEAN__POINTER_POINTER) (marshal_data ? marshal_data : cc->callback);
 
162
 
 
163
  v_return = callback (data1,
 
164
                       g_marshal_value_peek_pointer (param_values + 1),
 
165
                       g_marshal_value_peek_pointer (param_values + 2),
 
166
                       data2);
 
167
 
 
168
  g_value_set_boolean (return_value, v_return);
 
169
}
 
170
 
 
171
/* BOOLEAN:VOID (eelmarshal.list:4) */
 
172
void
 
173
eel_marshal_BOOLEAN__VOID (GClosure     *closure,
 
174
                           GValue       *return_value G_GNUC_UNUSED,
 
175
                           guint         n_param_values,
 
176
                           const GValue *param_values,
 
177
                           gpointer      invocation_hint G_GNUC_UNUSED,
 
178
                           gpointer      marshal_data)
 
179
{
 
180
  typedef gboolean (*GMarshalFunc_BOOLEAN__VOID) (gpointer     data1,
 
181
                                                  gpointer     data2);
 
182
  register GMarshalFunc_BOOLEAN__VOID callback;
 
183
  register GCClosure *cc = (GCClosure*) closure;
 
184
  register gpointer data1, data2;
 
185
  gboolean v_return;
 
186
 
 
187
  g_return_if_fail (return_value != NULL);
 
188
  g_return_if_fail (n_param_values == 1);
 
189
 
 
190
  if (G_CCLOSURE_SWAP_DATA (closure))
 
191
    {
 
192
      data1 = closure->data;
 
193
      data2 = g_value_peek_pointer (param_values + 0);
 
194
    }
 
195
  else
 
196
    {
 
197
      data1 = g_value_peek_pointer (param_values + 0);
 
198
      data2 = closure->data;
 
199
    }
 
200
  callback = (GMarshalFunc_BOOLEAN__VOID) (marshal_data ? marshal_data : cc->callback);
 
201
 
 
202
  v_return = callback (data1,
 
203
                       data2);
 
204
 
 
205
  g_value_set_boolean (return_value, v_return);
 
206
}
 
207
 
 
208
/* ENUM:INT,INT (eelmarshal.list:5) */
 
209
void
 
210
eel_marshal_ENUM__INT_INT (GClosure     *closure,
 
211
                           GValue       *return_value G_GNUC_UNUSED,
 
212
                           guint         n_param_values,
 
213
                           const GValue *param_values,
 
214
                           gpointer      invocation_hint G_GNUC_UNUSED,
 
215
                           gpointer      marshal_data)
 
216
{
 
217
  typedef gint (*GMarshalFunc_ENUM__INT_INT) (gpointer     data1,
 
218
                                              gint         arg_1,
 
219
                                              gint         arg_2,
 
220
                                              gpointer     data2);
 
221
  register GMarshalFunc_ENUM__INT_INT callback;
 
222
  register GCClosure *cc = (GCClosure*) closure;
 
223
  register gpointer data1, data2;
 
224
  gint v_return;
 
225
 
 
226
  g_return_if_fail (return_value != NULL);
 
227
  g_return_if_fail (n_param_values == 3);
 
228
 
 
229
  if (G_CCLOSURE_SWAP_DATA (closure))
 
230
    {
 
231
      data1 = closure->data;
 
232
      data2 = g_value_peek_pointer (param_values + 0);
 
233
    }
 
234
  else
 
235
    {
 
236
      data1 = g_value_peek_pointer (param_values + 0);
 
237
      data2 = closure->data;
 
238
    }
 
239
  callback = (GMarshalFunc_ENUM__INT_INT) (marshal_data ? marshal_data : cc->callback);
 
240
 
 
241
  v_return = callback (data1,
 
242
                       g_marshal_value_peek_int (param_values + 1),
 
243
                       g_marshal_value_peek_int (param_values + 2),
 
244
                       data2);
 
245
 
 
246
  g_value_set_enum (return_value, v_return);
 
247
}
 
248
 
 
249
/* INT:INT (eelmarshal.list:6) */
 
250
void
 
251
eel_marshal_INT__INT (GClosure     *closure,
 
252
                      GValue       *return_value G_GNUC_UNUSED,
 
253
                      guint         n_param_values,
 
254
                      const GValue *param_values,
 
255
                      gpointer      invocation_hint G_GNUC_UNUSED,
 
256
                      gpointer      marshal_data)
 
257
{
 
258
  typedef gint (*GMarshalFunc_INT__INT) (gpointer     data1,
 
259
                                         gint         arg_1,
 
260
                                         gpointer     data2);
 
261
  register GMarshalFunc_INT__INT callback;
 
262
  register GCClosure *cc = (GCClosure*) closure;
 
263
  register gpointer data1, data2;
 
264
  gint v_return;
 
265
 
 
266
  g_return_if_fail (return_value != NULL);
 
267
  g_return_if_fail (n_param_values == 2);
 
268
 
 
269
  if (G_CCLOSURE_SWAP_DATA (closure))
 
270
    {
 
271
      data1 = closure->data;
 
272
      data2 = g_value_peek_pointer (param_values + 0);
 
273
    }
 
274
  else
 
275
    {
 
276
      data1 = g_value_peek_pointer (param_values + 0);
 
277
      data2 = closure->data;
 
278
    }
 
279
  callback = (GMarshalFunc_INT__INT) (marshal_data ? marshal_data : cc->callback);
 
280
 
 
281
  v_return = callback (data1,
 
282
                       g_marshal_value_peek_int (param_values + 1),
 
283
                       data2);
 
284
 
 
285
  g_value_set_int (return_value, v_return);
 
286
}
 
287
 
 
288
/* INT:POINTER,STRING (eelmarshal.list:7) */
 
289
void
 
290
eel_marshal_INT__POINTER_STRING (GClosure     *closure,
 
291
                                 GValue       *return_value G_GNUC_UNUSED,
 
292
                                 guint         n_param_values,
 
293
                                 const GValue *param_values,
 
294
                                 gpointer      invocation_hint G_GNUC_UNUSED,
 
295
                                 gpointer      marshal_data)
 
296
{
 
297
  typedef gint (*GMarshalFunc_INT__POINTER_STRING) (gpointer     data1,
 
298
                                                    gpointer     arg_1,
 
299
                                                    gpointer     arg_2,
 
300
                                                    gpointer     data2);
 
301
  register GMarshalFunc_INT__POINTER_STRING callback;
 
302
  register GCClosure *cc = (GCClosure*) closure;
 
303
  register gpointer data1, data2;
 
304
  gint v_return;
 
305
 
 
306
  g_return_if_fail (return_value != NULL);
 
307
  g_return_if_fail (n_param_values == 3);
 
308
 
 
309
  if (G_CCLOSURE_SWAP_DATA (closure))
 
310
    {
 
311
      data1 = closure->data;
 
312
      data2 = g_value_peek_pointer (param_values + 0);
 
313
    }
 
314
  else
 
315
    {
 
316
      data1 = g_value_peek_pointer (param_values + 0);
 
317
      data2 = closure->data;
 
318
    }
 
319
  callback = (GMarshalFunc_INT__POINTER_STRING) (marshal_data ? marshal_data : cc->callback);
 
320
 
 
321
  v_return = callback (data1,
 
322
                       g_marshal_value_peek_pointer (param_values + 1),
 
323
                       g_marshal_value_peek_string (param_values + 2),
 
324
                       data2);
 
325
 
 
326
  g_value_set_int (return_value, v_return);
 
327
}
 
328
 
 
329
/* STRING:POINTER (eelmarshal.list:8) */
 
330
void
 
331
eel_marshal_STRING__POINTER (GClosure     *closure,
 
332
                             GValue       *return_value G_GNUC_UNUSED,
 
333
                             guint         n_param_values,
 
334
                             const GValue *param_values,
 
335
                             gpointer      invocation_hint G_GNUC_UNUSED,
 
336
                             gpointer      marshal_data)
 
337
{
 
338
  typedef gchar* (*GMarshalFunc_STRING__POINTER) (gpointer     data1,
 
339
                                                  gpointer     arg_1,
 
340
                                                  gpointer     data2);
 
341
  register GMarshalFunc_STRING__POINTER callback;
 
342
  register GCClosure *cc = (GCClosure*) closure;
 
343
  register gpointer data1, data2;
 
344
  gchar* v_return;
 
345
 
 
346
  g_return_if_fail (return_value != NULL);
 
347
  g_return_if_fail (n_param_values == 2);
 
348
 
 
349
  if (G_CCLOSURE_SWAP_DATA (closure))
 
350
    {
 
351
      data1 = closure->data;
 
352
      data2 = g_value_peek_pointer (param_values + 0);
 
353
    }
 
354
  else
 
355
    {
 
356
      data1 = g_value_peek_pointer (param_values + 0);
 
357
      data2 = closure->data;
 
358
    }
 
359
  callback = (GMarshalFunc_STRING__POINTER) (marshal_data ? marshal_data : cc->callback);
 
360
 
 
361
  v_return = callback (data1,
 
362
                       g_marshal_value_peek_pointer (param_values + 1),
 
363
                       data2);
 
364
 
 
365
  g_value_take_string (return_value, v_return);
 
366
}
 
367
 
 
368
/* STRING:VOID (eelmarshal.list:9) */
 
369
void
 
370
eel_marshal_STRING__VOID (GClosure     *closure,
 
371
                          GValue       *return_value G_GNUC_UNUSED,
 
372
                          guint         n_param_values,
 
373
                          const GValue *param_values,
 
374
                          gpointer      invocation_hint G_GNUC_UNUSED,
 
375
                          gpointer      marshal_data)
 
376
{
 
377
  typedef gchar* (*GMarshalFunc_STRING__VOID) (gpointer     data1,
 
378
                                               gpointer     data2);
 
379
  register GMarshalFunc_STRING__VOID callback;
 
380
  register GCClosure *cc = (GCClosure*) closure;
 
381
  register gpointer data1, data2;
 
382
  gchar* v_return;
 
383
 
 
384
  g_return_if_fail (return_value != NULL);
 
385
  g_return_if_fail (n_param_values == 1);
 
386
 
 
387
  if (G_CCLOSURE_SWAP_DATA (closure))
 
388
    {
 
389
      data1 = closure->data;
 
390
      data2 = g_value_peek_pointer (param_values + 0);
 
391
    }
 
392
  else
 
393
    {
 
394
      data1 = g_value_peek_pointer (param_values + 0);
 
395
      data2 = closure->data;
 
396
    }
 
397
  callback = (GMarshalFunc_STRING__VOID) (marshal_data ? marshal_data : cc->callback);
 
398
 
 
399
  v_return = callback (data1,
 
400
                       data2);
 
401
 
 
402
  g_value_take_string (return_value, v_return);
 
403
}
 
404
 
 
405
/* VOID:ENUM,INT (eelmarshal.list:10) */
 
406
void
 
407
eel_marshal_VOID__ENUM_INT (GClosure     *closure,
 
408
                            GValue       *return_value G_GNUC_UNUSED,
 
409
                            guint         n_param_values,
 
410
                            const GValue *param_values,
 
411
                            gpointer      invocation_hint G_GNUC_UNUSED,
 
412
                            gpointer      marshal_data)
 
413
{
 
414
  typedef void (*GMarshalFunc_VOID__ENUM_INT) (gpointer     data1,
 
415
                                               gint         arg_1,
 
416
                                               gint         arg_2,
 
417
                                               gpointer     data2);
 
418
  register GMarshalFunc_VOID__ENUM_INT callback;
 
419
  register GCClosure *cc = (GCClosure*) closure;
 
420
  register gpointer data1, data2;
 
421
 
 
422
  g_return_if_fail (n_param_values == 3);
 
423
 
 
424
  if (G_CCLOSURE_SWAP_DATA (closure))
 
425
    {
 
426
      data1 = closure->data;
 
427
      data2 = g_value_peek_pointer (param_values + 0);
 
428
    }
 
429
  else
 
430
    {
 
431
      data1 = g_value_peek_pointer (param_values + 0);
 
432
      data2 = closure->data;
 
433
    }
 
434
  callback = (GMarshalFunc_VOID__ENUM_INT) (marshal_data ? marshal_data : cc->callback);
 
435
 
 
436
  callback (data1,
 
437
            g_marshal_value_peek_enum (param_values + 1),
 
438
            g_marshal_value_peek_int (param_values + 2),
 
439
            data2);
 
440
}
 
441
 
 
442
/* VOID:ENUM,INT,BOOLEAN (eelmarshal.list:11) */
 
443
void
 
444
eel_marshal_VOID__ENUM_INT_BOOLEAN (GClosure     *closure,
 
445
                                    GValue       *return_value G_GNUC_UNUSED,
 
446
                                    guint         n_param_values,
 
447
                                    const GValue *param_values,
 
448
                                    gpointer      invocation_hint G_GNUC_UNUSED,
 
449
                                    gpointer      marshal_data)
 
450
{
 
451
  typedef void (*GMarshalFunc_VOID__ENUM_INT_BOOLEAN) (gpointer     data1,
 
452
                                                       gint         arg_1,
 
453
                                                       gint         arg_2,
 
454
                                                       gboolean     arg_3,
 
455
                                                       gpointer     data2);
 
456
  register GMarshalFunc_VOID__ENUM_INT_BOOLEAN callback;
 
457
  register GCClosure *cc = (GCClosure*) closure;
 
458
  register gpointer data1, data2;
 
459
 
 
460
  g_return_if_fail (n_param_values == 4);
 
461
 
 
462
  if (G_CCLOSURE_SWAP_DATA (closure))
 
463
    {
 
464
      data1 = closure->data;
 
465
      data2 = g_value_peek_pointer (param_values + 0);
 
466
    }
 
467
  else
 
468
    {
 
469
      data1 = g_value_peek_pointer (param_values + 0);
 
470
      data2 = closure->data;
 
471
    }
 
472
  callback = (GMarshalFunc_VOID__ENUM_INT_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
 
473
 
 
474
  callback (data1,
 
475
            g_marshal_value_peek_enum (param_values + 1),
 
476
            g_marshal_value_peek_int (param_values + 2),
 
477
            g_marshal_value_peek_boolean (param_values + 3),
 
478
            data2);
 
479
}
 
480
 
 
481
/* VOID:INT,INT,INT,INT (eelmarshal.list:12) */
 
482
void
 
483
eel_marshal_VOID__INT_INT_INT_INT (GClosure     *closure,
 
484
                                   GValue       *return_value G_GNUC_UNUSED,
 
485
                                   guint         n_param_values,
 
486
                                   const GValue *param_values,
 
487
                                   gpointer      invocation_hint G_GNUC_UNUSED,
 
488
                                   gpointer      marshal_data)
 
489
{
 
490
  typedef void (*GMarshalFunc_VOID__INT_INT_INT_INT) (gpointer     data1,
 
491
                                                      gint         arg_1,
 
492
                                                      gint         arg_2,
 
493
                                                      gint         arg_3,
 
494
                                                      gint         arg_4,
 
495
                                                      gpointer     data2);
 
496
  register GMarshalFunc_VOID__INT_INT_INT_INT callback;
 
497
  register GCClosure *cc = (GCClosure*) closure;
 
498
  register gpointer data1, data2;
 
499
 
 
500
  g_return_if_fail (n_param_values == 5);
 
501
 
 
502
  if (G_CCLOSURE_SWAP_DATA (closure))
 
503
    {
 
504
      data1 = closure->data;
 
505
      data2 = g_value_peek_pointer (param_values + 0);
 
506
    }
 
507
  else
 
508
    {
 
509
      data1 = g_value_peek_pointer (param_values + 0);
 
510
      data2 = closure->data;
 
511
    }
 
512
  callback = (GMarshalFunc_VOID__INT_INT_INT_INT) (marshal_data ? marshal_data : cc->callback);
 
513
 
 
514
  callback (data1,
 
515
            g_marshal_value_peek_int (param_values + 1),
 
516
            g_marshal_value_peek_int (param_values + 2),
 
517
            g_marshal_value_peek_int (param_values + 3),
 
518
            g_marshal_value_peek_int (param_values + 4),
 
519
            data2);
 
520
}
 
521
 
 
522
/* VOID:OBJECT,POINTER (eelmarshal.list:13) */
 
523
void
 
524
eel_marshal_VOID__OBJECT_POINTER (GClosure     *closure,
 
525
                                  GValue       *return_value G_GNUC_UNUSED,
 
526
                                  guint         n_param_values,
 
527
                                  const GValue *param_values,
 
528
                                  gpointer      invocation_hint G_GNUC_UNUSED,
 
529
                                  gpointer      marshal_data)
 
530
{
 
531
  typedef void (*GMarshalFunc_VOID__OBJECT_POINTER) (gpointer     data1,
 
532
                                                     gpointer     arg_1,
 
533
                                                     gpointer     arg_2,
 
534
                                                     gpointer     data2);
 
535
  register GMarshalFunc_VOID__OBJECT_POINTER callback;
 
536
  register GCClosure *cc = (GCClosure*) closure;
 
537
  register gpointer data1, data2;
 
538
 
 
539
  g_return_if_fail (n_param_values == 3);
 
540
 
 
541
  if (G_CCLOSURE_SWAP_DATA (closure))
 
542
    {
 
543
      data1 = closure->data;
 
544
      data2 = g_value_peek_pointer (param_values + 0);
 
545
    }
 
546
  else
 
547
    {
 
548
      data1 = g_value_peek_pointer (param_values + 0);
 
549
      data2 = closure->data;
 
550
    }
 
551
  callback = (GMarshalFunc_VOID__OBJECT_POINTER) (marshal_data ? marshal_data : cc->callback);
 
552
 
 
553
  callback (data1,
 
554
            g_marshal_value_peek_object (param_values + 1),
 
555
            g_marshal_value_peek_pointer (param_values + 2),
 
556
            data2);
 
557
}
 
558