← Back to branch summary

~elementary-apps/pantheon-files/trunk

« back to all changes in this revision

Viewing changes to src/nautilus-marshal-guts.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/nautilus-marshal-guts.c
 
1
 
 
2
#include        "nautilus-marshal.h"
 
3
 
 
4
#ifdef G_ENABLE_DEBUG
 
5
#define g_marshal_value_peek_boolean(v)  g_value_get_boolean (v)
 
6
#define g_marshal_value_peek_char(v)     g_value_get_char (v)
 
7
#define g_marshal_value_peek_uchar(v)    g_value_get_uchar (v)
 
8
#define g_marshal_value_peek_int(v)      g_value_get_int (v)
 
9
#define g_marshal_value_peek_uint(v)     g_value_get_uint (v)
 
10
#define g_marshal_value_peek_long(v)     g_value_get_long (v)
 
11
#define g_marshal_value_peek_ulong(v)    g_value_get_ulong (v)
 
12
#define g_marshal_value_peek_int64(v)    g_value_get_int64 (v)
 
13
#define g_marshal_value_peek_uint64(v)   g_value_get_uint64 (v)
 
14
#define g_marshal_value_peek_enum(v)     g_value_get_enum (v)
 
15
#define g_marshal_value_peek_flags(v)    g_value_get_flags (v)
 
16
#define g_marshal_value_peek_float(v)    g_value_get_float (v)
 
17
#define g_marshal_value_peek_double(v)   g_value_get_double (v)
 
18
#define g_marshal_value_peek_string(v)   (char*) g_value_get_string (v)
 
19
#define g_marshal_value_peek_param(v)    g_value_get_param (v)
 
20
#define g_marshal_value_peek_boxed(v)    g_value_get_boxed (v)
 
21
#define g_marshal_value_peek_pointer(v)  g_value_get_pointer (v)
 
22
#define g_marshal_value_peek_object(v)   g_value_get_object (v)
 
23
#define g_marshal_value_peek_variant(v)  g_value_get_variant (v)
 
24
#else /* !G_ENABLE_DEBUG */
 
25
/* WARNING: This code accesses GValues directly, which is UNSUPPORTED API.
 
26
 *          Do not access GValues directly in your code. Instead, use the
 
27
 *          g_value_get_*() functions
 
28
 */
 
29
#define g_marshal_value_peek_boolean(v)  (v)->data[0].v_int
 
30
#define g_marshal_value_peek_char(v)     (v)->data[0].v_int
 
31
#define g_marshal_value_peek_uchar(v)    (v)->data[0].v_uint
 
32
#define g_marshal_value_peek_int(v)      (v)->data[0].v_int
 
33
#define g_marshal_value_peek_uint(v)     (v)->data[0].v_uint
 
34
#define g_marshal_value_peek_long(v)     (v)->data[0].v_long
 
35
#define g_marshal_value_peek_ulong(v)    (v)->data[0].v_ulong
 
36
#define g_marshal_value_peek_int64(v)    (v)->data[0].v_int64
 
37
#define g_marshal_value_peek_uint64(v)   (v)->data[0].v_uint64
 
38
#define g_marshal_value_peek_enum(v)     (v)->data[0].v_long
 
39
#define g_marshal_value_peek_flags(v)    (v)->data[0].v_ulong
 
40
#define g_marshal_value_peek_float(v)    (v)->data[0].v_float
 
41
#define g_marshal_value_peek_double(v)   (v)->data[0].v_double
 
42
#define g_marshal_value_peek_string(v)   (v)->data[0].v_pointer
 
43
#define g_marshal_value_peek_param(v)    (v)->data[0].v_pointer
 
44
#define g_marshal_value_peek_boxed(v)    (v)->data[0].v_pointer
 
45
#define g_marshal_value_peek_pointer(v)  (v)->data[0].v_pointer
 
46
#define g_marshal_value_peek_object(v)   (v)->data[0].v_pointer
 
47
#define g_marshal_value_peek_variant(v)  (v)->data[0].v_pointer
 
48
#endif /* !G_ENABLE_DEBUG */
 
49
 
 
50
 
 
51
/* BOOLEAN:POINTER (nautilus-marshal.list:1) */
 
52
void
 
53
nautilus_marshal_BOOLEAN__POINTER (GClosure     *closure,
 
54
                                   GValue       *return_value G_GNUC_UNUSED,
 
55
                                   guint         n_param_values,
 
56
                                   const GValue *param_values,
 
57
                                   gpointer      invocation_hint G_GNUC_UNUSED,
 
58
                                   gpointer      marshal_data)
 
59
{
 
60
  typedef gboolean (*GMarshalFunc_BOOLEAN__POINTER) (gpointer     data1,
 
61
                                                     gpointer     arg_1,
 
62
                                                     gpointer     data2);
 
63
  register GMarshalFunc_BOOLEAN__POINTER callback;
 
64
  register GCClosure *cc = (GCClosure*) closure;
 
65
  register gpointer data1, data2;
 
66
  gboolean v_return;
 
67
 
 
68
  g_return_if_fail (return_value != NULL);
 
69
  g_return_if_fail (n_param_values == 2);
 
70
 
 
71
  if (G_CCLOSURE_SWAP_DATA (closure))
 
72
    {
 
73
      data1 = closure->data;
 
74
      data2 = g_value_peek_pointer (param_values + 0);
 
75
    }
 
76
  else
 
77
    {
 
78
      data1 = g_value_peek_pointer (param_values + 0);
 
79
      data2 = closure->data;
 
80
    }
 
81
  callback = (GMarshalFunc_BOOLEAN__POINTER) (marshal_data ? marshal_data : cc->callback);
 
82
 
 
83
  v_return = callback (data1,
 
84
                       g_marshal_value_peek_pointer (param_values + 1),
 
85
                       data2);
 
86
 
 
87
  g_value_set_boolean (return_value, v_return);
 
88
}
 
89
 
 
90
/* BOOLEAN:VOID (nautilus-marshal.list:2) */
 
91
void
 
92
nautilus_marshal_BOOLEAN__VOID (GClosure     *closure,
 
93
                                GValue       *return_value G_GNUC_UNUSED,
 
94
                                guint         n_param_values,
 
95
                                const GValue *param_values,
 
96
                                gpointer      invocation_hint G_GNUC_UNUSED,
 
97
                                gpointer      marshal_data)
 
98
{
 
99
  typedef gboolean (*GMarshalFunc_BOOLEAN__VOID) (gpointer     data1,
 
100
                                                  gpointer     data2);
 
101
  register GMarshalFunc_BOOLEAN__VOID callback;
 
102
  register GCClosure *cc = (GCClosure*) closure;
 
103
  register gpointer data1, data2;
 
104
  gboolean v_return;
 
105
 
 
106
  g_return_if_fail (return_value != NULL);
 
107
  g_return_if_fail (n_param_values == 1);
 
108
 
 
109
  if (G_CCLOSURE_SWAP_DATA (closure))
 
110
    {
 
111
      data1 = closure->data;
 
112
      data2 = g_value_peek_pointer (param_values + 0);
 
113
    }
 
114
  else
 
115
    {
 
116
      data1 = g_value_peek_pointer (param_values + 0);
 
117
      data2 = closure->data;
 
118
    }
 
119
  callback = (GMarshalFunc_BOOLEAN__VOID) (marshal_data ? marshal_data : cc->callback);
 
120
 
 
121
  v_return = callback (data1,
 
122
                       data2);
 
123
 
 
124
  g_value_set_boolean (return_value, v_return);
 
125
}
 
126
 
 
127
/* INT:POINTER,BOOLEAN (nautilus-marshal.list:3) */
 
128
void
 
129
nautilus_marshal_INT__POINTER_BOOLEAN (GClosure     *closure,
 
130
                                       GValue       *return_value G_GNUC_UNUSED,
 
131
                                       guint         n_param_values,
 
132
                                       const GValue *param_values,
 
133
                                       gpointer      invocation_hint G_GNUC_UNUSED,
 
134
                                       gpointer      marshal_data)
 
135
{
 
136
  typedef gint (*GMarshalFunc_INT__POINTER_BOOLEAN) (gpointer     data1,
 
137
                                                     gpointer     arg_1,
 
138
                                                     gboolean     arg_2,
 
139
                                                     gpointer     data2);
 
140
  register GMarshalFunc_INT__POINTER_BOOLEAN callback;
 
141
  register GCClosure *cc = (GCClosure*) closure;
 
142
  register gpointer data1, data2;
 
143
  gint v_return;
 
144
 
 
145
  g_return_if_fail (return_value != NULL);
 
146
  g_return_if_fail (n_param_values == 3);
 
147
 
 
148
  if (G_CCLOSURE_SWAP_DATA (closure))
 
149
    {
 
150
      data1 = closure->data;
 
151
      data2 = g_value_peek_pointer (param_values + 0);
 
152
    }
 
153
  else
 
154
    {
 
155
      data1 = g_value_peek_pointer (param_values + 0);
 
156
      data2 = closure->data;
 
157
    }
 
158
  callback = (GMarshalFunc_INT__POINTER_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
 
159
 
 
160
  v_return = callback (data1,
 
161
                       g_marshal_value_peek_pointer (param_values + 1),
 
162
                       g_marshal_value_peek_boolean (param_values + 2),
 
163
                       data2);
 
164
 
 
165
  g_value_set_int (return_value, v_return);
 
166
}
 
167
 
 
168
/* INT:POINTER,INT (nautilus-marshal.list:4) */
 
169
void
 
170
nautilus_marshal_INT__POINTER_INT (GClosure     *closure,
 
171
                                   GValue       *return_value G_GNUC_UNUSED,
 
172
                                   guint         n_param_values,
 
173
                                   const GValue *param_values,
 
174
                                   gpointer      invocation_hint G_GNUC_UNUSED,
 
175
                                   gpointer      marshal_data)
 
176
{
 
177
  typedef gint (*GMarshalFunc_INT__POINTER_INT) (gpointer     data1,
 
178
                                                 gpointer     arg_1,
 
179
                                                 gint         arg_2,
 
180
                                                 gpointer     data2);
 
181
  register GMarshalFunc_INT__POINTER_INT callback;
 
182
  register GCClosure *cc = (GCClosure*) closure;
 
183
  register gpointer data1, data2;
 
184
  gint v_return;
 
185
 
 
186
  g_return_if_fail (return_value != NULL);
 
187
  g_return_if_fail (n_param_values == 3);
 
188
 
 
189
  if (G_CCLOSURE_SWAP_DATA (closure))
 
190
    {
 
191
      data1 = closure->data;
 
192
      data2 = g_value_peek_pointer (param_values + 0);
 
193
    }
 
194
  else
 
195
    {
 
196
      data1 = g_value_peek_pointer (param_values + 0);
 
197
      data2 = closure->data;
 
198
    }
 
199
  callback = (GMarshalFunc_INT__POINTER_INT) (marshal_data ? marshal_data : cc->callback);
 
200
 
 
201
  v_return = callback (data1,
 
202
                       g_marshal_value_peek_pointer (param_values + 1),
 
203
                       g_marshal_value_peek_int (param_values + 2),
 
204
                       data2);
 
205
 
 
206
  g_value_set_int (return_value, v_return);
 
207
}
 
208
 
 
209
/* INT:POINTER,POINTER (nautilus-marshal.list:5) */
 
210
void
 
211
nautilus_marshal_INT__POINTER_POINTER (GClosure     *closure,
 
212
                                       GValue       *return_value G_GNUC_UNUSED,
 
213
                                       guint         n_param_values,
 
214
                                       const GValue *param_values,
 
215
                                       gpointer      invocation_hint G_GNUC_UNUSED,
 
216
                                       gpointer      marshal_data)
 
217
{
 
218
  typedef gint (*GMarshalFunc_INT__POINTER_POINTER) (gpointer     data1,
 
219
                                                     gpointer     arg_1,
 
220
                                                     gpointer     arg_2,
 
221
                                                     gpointer     data2);
 
222
  register GMarshalFunc_INT__POINTER_POINTER callback;
 
223
  register GCClosure *cc = (GCClosure*) closure;
 
224
  register gpointer data1, data2;
 
225
  gint v_return;
 
226
 
 
227
  g_return_if_fail (return_value != NULL);
 
228
  g_return_if_fail (n_param_values == 3);
 
229
 
 
230
  if (G_CCLOSURE_SWAP_DATA (closure))
 
231
    {
 
232
      data1 = closure->data;
 
233
      data2 = g_value_peek_pointer (param_values + 0);
 
234
    }
 
235
  else
 
236
    {
 
237
      data1 = g_value_peek_pointer (param_values + 0);
 
238
      data2 = closure->data;
 
239
    }
 
240
  callback = (GMarshalFunc_INT__POINTER_POINTER) (marshal_data ? marshal_data : cc->callback);
 
241
 
 
242
  v_return = callback (data1,
 
243
                       g_marshal_value_peek_pointer (param_values + 1),
 
244
                       g_marshal_value_peek_pointer (param_values + 2),
 
245
                       data2);
 
246
 
 
247
  g_value_set_int (return_value, v_return);
 
248
}
 
249
 
 
250
/* OBJECT:BOXED (nautilus-marshal.list:6) */
 
251
void
 
252
nautilus_marshal_OBJECT__BOXED (GClosure     *closure,
 
253
                                GValue       *return_value G_GNUC_UNUSED,
 
254
                                guint         n_param_values,
 
255
                                const GValue *param_values,
 
256
                                gpointer      invocation_hint G_GNUC_UNUSED,
 
257
                                gpointer      marshal_data)
 
258
{
 
259
  typedef GObject* (*GMarshalFunc_OBJECT__BOXED) (gpointer     data1,
 
260
                                                  gpointer     arg_1,
 
261
                                                  gpointer     data2);
 
262
  register GMarshalFunc_OBJECT__BOXED callback;
 
263
  register GCClosure *cc = (GCClosure*) closure;
 
264
  register gpointer data1, data2;
 
265
  GObject* v_return;
 
266
 
 
267
  g_return_if_fail (return_value != NULL);
 
268
  g_return_if_fail (n_param_values == 2);
 
269
 
 
270
  if (G_CCLOSURE_SWAP_DATA (closure))
 
271
    {
 
272
      data1 = closure->data;
 
273
      data2 = g_value_peek_pointer (param_values + 0);
 
274
    }
 
275
  else
 
276
    {
 
277
      data1 = g_value_peek_pointer (param_values + 0);
 
278
      data2 = closure->data;
 
279
    }
 
280
  callback = (GMarshalFunc_OBJECT__BOXED) (marshal_data ? marshal_data : cc->callback);
 
281
 
 
282
  v_return = callback (data1,
 
283
                       g_marshal_value_peek_boxed (param_values + 1),
 
284
                       data2);
 
285
 
 
286
  g_value_take_object (return_value, v_return);
 
287
}
 
288
 
 
289
/* POINTER:VOID (nautilus-marshal.list:7) */
 
290
void
 
291
nautilus_marshal_POINTER__VOID (GClosure     *closure,
 
292
                                GValue       *return_value G_GNUC_UNUSED,
 
293
                                guint         n_param_values,
 
294
                                const GValue *param_values,
 
295
                                gpointer      invocation_hint G_GNUC_UNUSED,
 
296
                                gpointer      marshal_data)
 
297
{
 
298
  typedef gpointer (*GMarshalFunc_POINTER__VOID) (gpointer     data1,
 
299
                                                  gpointer     data2);
 
300
  register GMarshalFunc_POINTER__VOID callback;
 
301
  register GCClosure *cc = (GCClosure*) closure;
 
302
  register gpointer data1, data2;
 
303
  gpointer v_return;
 
304
 
 
305
  g_return_if_fail (return_value != NULL);
 
306
  g_return_if_fail (n_param_values == 1);
 
307
 
 
308
  if (G_CCLOSURE_SWAP_DATA (closure))
 
309
    {
 
310
      data1 = closure->data;
 
311
      data2 = g_value_peek_pointer (param_values + 0);
 
312
    }
 
313
  else
 
314
    {
 
315
      data1 = g_value_peek_pointer (param_values + 0);
 
316
      data2 = closure->data;
 
317
    }
 
318
  callback = (GMarshalFunc_POINTER__VOID) (marshal_data ? marshal_data : cc->callback);
 
319
 
 
320
  v_return = callback (data1,
 
321
                       data2);
 
322
 
 
323
  g_value_set_pointer (return_value, v_return);
 
324
}
 
325
 
 
326
/* STRING:VOID (nautilus-marshal.list:8) */
 
327
void
 
328
nautilus_marshal_STRING__VOID (GClosure     *closure,
 
329
                               GValue       *return_value G_GNUC_UNUSED,
 
330
                               guint         n_param_values,
 
331
                               const GValue *param_values,
 
332
                               gpointer      invocation_hint G_GNUC_UNUSED,
 
333
                               gpointer      marshal_data)
 
334
{
 
335
  typedef gchar* (*GMarshalFunc_STRING__VOID) (gpointer     data1,
 
336
                                               gpointer     data2);
 
337
  register GMarshalFunc_STRING__VOID callback;
 
338
  register GCClosure *cc = (GCClosure*) closure;
 
339
  register gpointer data1, data2;
 
340
  gchar* v_return;
 
341
 
 
342
  g_return_if_fail (return_value != NULL);
 
343
  g_return_if_fail (n_param_values == 1);
 
344
 
 
345
  if (G_CCLOSURE_SWAP_DATA (closure))
 
346
    {
 
347
      data1 = closure->data;
 
348
      data2 = g_value_peek_pointer (param_values + 0);
 
349
    }
 
350
  else
 
351
    {
 
352
      data1 = g_value_peek_pointer (param_values + 0);
 
353
      data2 = closure->data;
 
354
    }
 
355
  callback = (GMarshalFunc_STRING__VOID) (marshal_data ? marshal_data : cc->callback);
 
356
 
 
357
  v_return = callback (data1,
 
358
                       data2);
 
359
 
 
360
  g_value_take_string (return_value, v_return);
 
361
}
 
362
 
 
363
/* VOID:DOUBLE (nautilus-marshal.list:9) */
 
364
 
 
365
/* VOID:INT,BOOLEAN,BOOLEAN,BOOLEAN,BOOLEAN (nautilus-marshal.list:10) */
 
366
void
 
367
nautilus_marshal_VOID__INT_BOOLEAN_BOOLEAN_BOOLEAN_BOOLEAN (GClosure     *closure,
 
368
                                                            GValue       *return_value G_GNUC_UNUSED,
 
369
                                                            guint         n_param_values,
 
370
                                                            const GValue *param_values,
 
371
                                                            gpointer      invocation_hint G_GNUC_UNUSED,
 
372
                                                            gpointer      marshal_data)
 
373
{
 
374
  typedef void (*GMarshalFunc_VOID__INT_BOOLEAN_BOOLEAN_BOOLEAN_BOOLEAN) (gpointer     data1,
 
375
                                                                          gint         arg_1,
 
376
                                                                          gboolean     arg_2,
 
377
                                                                          gboolean     arg_3,
 
378
                                                                          gboolean     arg_4,
 
379
                                                                          gboolean     arg_5,
 
380
                                                                          gpointer     data2);
 
381
  register GMarshalFunc_VOID__INT_BOOLEAN_BOOLEAN_BOOLEAN_BOOLEAN callback;
 
382
  register GCClosure *cc = (GCClosure*) closure;
 
383
  register gpointer data1, data2;
 
384
 
 
385
  g_return_if_fail (n_param_values == 6);
 
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_VOID__INT_BOOLEAN_BOOLEAN_BOOLEAN_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
 
398
 
 
399
  callback (data1,
 
400
            g_marshal_value_peek_int (param_values + 1),
 
401
            g_marshal_value_peek_boolean (param_values + 2),
 
402
            g_marshal_value_peek_boolean (param_values + 3),
 
403
            g_marshal_value_peek_boolean (param_values + 4),
 
404
            g_marshal_value_peek_boolean (param_values + 5),
 
405
            data2);
 
406
}
 
407
 
 
408
/* VOID:INT,STRING (nautilus-marshal.list:11) */
 
409
void
 
410
nautilus_marshal_VOID__INT_STRING (GClosure     *closure,
 
411
                                   GValue       *return_value G_GNUC_UNUSED,
 
412
                                   guint         n_param_values,
 
413
                                   const GValue *param_values,
 
414
                                   gpointer      invocation_hint G_GNUC_UNUSED,
 
415
                                   gpointer      marshal_data)
 
416
{
 
417
  typedef void (*GMarshalFunc_VOID__INT_STRING) (gpointer     data1,
 
418
                                                 gint         arg_1,
 
419
                                                 gpointer     arg_2,
 
420
                                                 gpointer     data2);
 
421
  register GMarshalFunc_VOID__INT_STRING callback;
 
422
  register GCClosure *cc = (GCClosure*) closure;
 
423
  register gpointer data1, data2;
 
424
 
 
425
  g_return_if_fail (n_param_values == 3);
 
426
 
 
427
  if (G_CCLOSURE_SWAP_DATA (closure))
 
428
    {
 
429
      data1 = closure->data;
 
430
      data2 = g_value_peek_pointer (param_values + 0);
 
431
    }
 
432
  else
 
433
    {
 
434
      data1 = g_value_peek_pointer (param_values + 0);
 
435
      data2 = closure->data;
 
436
    }
 
437
  callback = (GMarshalFunc_VOID__INT_STRING) (marshal_data ? marshal_data : cc->callback);
 
438
 
 
439
  callback (data1,
 
440
            g_marshal_value_peek_int (param_values + 1),
 
441
            g_marshal_value_peek_string (param_values + 2),
 
442
            data2);
 
443
}
 
444
 
 
445
/* VOID:OBJECT,BOOLEAN (nautilus-marshal.list:12) */
 
446
void
 
447
nautilus_marshal_VOID__OBJECT_BOOLEAN (GClosure     *closure,
 
448
                                       GValue       *return_value G_GNUC_UNUSED,
 
449
                                       guint         n_param_values,
 
450
                                       const GValue *param_values,
 
451
                                       gpointer      invocation_hint G_GNUC_UNUSED,
 
452
                                       gpointer      marshal_data)
 
453
{
 
454
  typedef void (*GMarshalFunc_VOID__OBJECT_BOOLEAN) (gpointer     data1,
 
455
                                                     gpointer     arg_1,
 
456
                                                     gboolean     arg_2,
 
457
                                                     gpointer     data2);
 
458
  register GMarshalFunc_VOID__OBJECT_BOOLEAN callback;
 
459
  register GCClosure *cc = (GCClosure*) closure;
 
460
  register gpointer data1, data2;
 
461
 
 
462
  g_return_if_fail (n_param_values == 3);
 
463
 
 
464
  if (G_CCLOSURE_SWAP_DATA (closure))
 
465
    {
 
466
      data1 = closure->data;
 
467
      data2 = g_value_peek_pointer (param_values + 0);
 
468
    }
 
469
  else
 
470
    {
 
471
      data1 = g_value_peek_pointer (param_values + 0);
 
472
      data2 = closure->data;
 
473
    }
 
474
  callback = (GMarshalFunc_VOID__OBJECT_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
 
475
 
 
476
  callback (data1,
 
477
            g_marshal_value_peek_object (param_values + 1),
 
478
            g_marshal_value_peek_boolean (param_values + 2),
 
479
            data2);
 
480
}
 
481
 
 
482
/* VOID:OBJECT,OBJECT (nautilus-marshal.list:13) */
 
483
void
 
484
nautilus_marshal_VOID__OBJECT_OBJECT (GClosure     *closure,
 
485
                                      GValue       *return_value G_GNUC_UNUSED,
 
486
                                      guint         n_param_values,
 
487
                                      const GValue *param_values,
 
488
                                      gpointer      invocation_hint G_GNUC_UNUSED,
 
489
                                      gpointer      marshal_data)
 
490
{
 
491
  typedef void (*GMarshalFunc_VOID__OBJECT_OBJECT) (gpointer     data1,
 
492
                                                    gpointer     arg_1,
 
493
                                                    gpointer     arg_2,
 
494
                                                    gpointer     data2);
 
495
  register GMarshalFunc_VOID__OBJECT_OBJECT callback;
 
496
  register GCClosure *cc = (GCClosure*) closure;
 
497
  register gpointer data1, data2;
 
498
 
 
499
  g_return_if_fail (n_param_values == 3);
 
500
 
 
501
  if (G_CCLOSURE_SWAP_DATA (closure))
 
502
    {
 
503
      data1 = closure->data;
 
504
      data2 = g_value_peek_pointer (param_values + 0);
 
505
    }
 
506
  else
 
507
    {
 
508
      data1 = g_value_peek_pointer (param_values + 0);
 
509
      data2 = closure->data;
 
510
    }
 
511
  callback = (GMarshalFunc_VOID__OBJECT_OBJECT) (marshal_data ? marshal_data : cc->callback);
 
512
 
 
513
  callback (data1,
 
514
            g_marshal_value_peek_object (param_values + 1),
 
515
            g_marshal_value_peek_object (param_values + 2),
 
516
            data2);
 
517
}
 
518
 
 
519
/* VOID:POINTER,ENUM (nautilus-marshal.list:14) */
 
520
void
 
521
nautilus_marshal_VOID__POINTER_ENUM (GClosure     *closure,
 
522
                                     GValue       *return_value G_GNUC_UNUSED,
 
523
                                     guint         n_param_values,
 
524
                                     const GValue *param_values,
 
525
                                     gpointer      invocation_hint G_GNUC_UNUSED,
 
526
                                     gpointer      marshal_data)
 
527
{
 
528
  typedef void (*GMarshalFunc_VOID__POINTER_ENUM) (gpointer     data1,
 
529
                                                   gpointer     arg_1,
 
530
                                                   gint         arg_2,
 
531
                                                   gpointer     data2);
 
532
  register GMarshalFunc_VOID__POINTER_ENUM callback;
 
533
  register GCClosure *cc = (GCClosure*) closure;
 
534
  register gpointer data1, data2;
 
535
 
 
536
  g_return_if_fail (n_param_values == 3);
 
537
 
 
538
  if (G_CCLOSURE_SWAP_DATA (closure))
 
539
    {
 
540
      data1 = closure->data;
 
541
      data2 = g_value_peek_pointer (param_values + 0);
 
542
    }
 
543
  else
 
544
    {
 
545
      data1 = g_value_peek_pointer (param_values + 0);
 
546
      data2 = closure->data;
 
547
    }
 
548
  callback = (GMarshalFunc_VOID__POINTER_ENUM) (marshal_data ? marshal_data : cc->callback);
 
549
 
 
550
  callback (data1,
 
551
            g_marshal_value_peek_pointer (param_values + 1),
 
552
            g_marshal_value_peek_enum (param_values + 2),
 
553
            data2);
 
554
}
 
555
 
 
556
/* VOID:POINTER,POINTER (nautilus-marshal.list:15) */
 
557
void
 
558
nautilus_marshal_VOID__POINTER_POINTER (GClosure     *closure,
 
559
                                        GValue       *return_value G_GNUC_UNUSED,
 
560
                                        guint         n_param_values,
 
561
                                        const GValue *param_values,
 
562
                                        gpointer      invocation_hint G_GNUC_UNUSED,
 
563
                                        gpointer      marshal_data)
 
564
{
 
565
  typedef void (*GMarshalFunc_VOID__POINTER_POINTER) (gpointer     data1,
 
566
                                                      gpointer     arg_1,
 
567
                                                      gpointer     arg_2,
 
568
                                                      gpointer     data2);
 
569
  register GMarshalFunc_VOID__POINTER_POINTER callback;
 
570
  register GCClosure *cc = (GCClosure*) closure;
 
571
  register gpointer data1, data2;
 
572
 
 
573
  g_return_if_fail (n_param_values == 3);
 
574
 
 
575
  if (G_CCLOSURE_SWAP_DATA (closure))
 
576
    {
 
577
      data1 = closure->data;
 
578
      data2 = g_value_peek_pointer (param_values + 0);
 
579
    }
 
580
  else
 
581
    {
 
582
      data1 = g_value_peek_pointer (param_values + 0);
 
583
      data2 = closure->data;
 
584
    }
 
585
  callback = (GMarshalFunc_VOID__POINTER_POINTER) (marshal_data ? marshal_data : cc->callback);
 
586
 
 
587
  callback (data1,
 
588
            g_marshal_value_peek_pointer (param_values + 1),
 
589
            g_marshal_value_peek_pointer (param_values + 2),
 
590
            data2);
 
591
}
 
592
 
 
593
/* VOID:POINTER,POINTER (nautilus-marshal.list:16) */
 
594
 
 
595
/* VOID:POINTER,POINTER,POINTER,ENUM,INT,INT (nautilus-marshal.list:17) */
 
596
void
 
597
nautilus_marshal_VOID__POINTER_POINTER_POINTER_ENUM_INT_INT (GClosure     *closure,
 
598
                                                             GValue       *return_value G_GNUC_UNUSED,
 
599
                                                             guint         n_param_values,
 
600
                                                             const GValue *param_values,
 
601
                                                             gpointer      invocation_hint G_GNUC_UNUSED,
 
602
                                                             gpointer      marshal_data)
 
603
{
 
604
  typedef void (*GMarshalFunc_VOID__POINTER_POINTER_POINTER_ENUM_INT_INT) (gpointer     data1,
 
605
                                                                           gpointer     arg_1,
 
606
                                                                           gpointer     arg_2,
 
607
                                                                           gpointer     arg_3,
 
608
                                                                           gint         arg_4,
 
609
                                                                           gint         arg_5,
 
610
                                                                           gint         arg_6,
 
611
                                                                           gpointer     data2);
 
612
  register GMarshalFunc_VOID__POINTER_POINTER_POINTER_ENUM_INT_INT callback;
 
613
  register GCClosure *cc = (GCClosure*) closure;
 
614
  register gpointer data1, data2;
 
615
 
 
616
  g_return_if_fail (n_param_values == 7);
 
617
 
 
618
  if (G_CCLOSURE_SWAP_DATA (closure))
 
619
    {
 
620
      data1 = closure->data;
 
621
      data2 = g_value_peek_pointer (param_values + 0);
 
622
    }
 
623
  else
 
624
    {
 
625
      data1 = g_value_peek_pointer (param_values + 0);
 
626
      data2 = closure->data;
 
627
    }
 
628
  callback = (GMarshalFunc_VOID__POINTER_POINTER_POINTER_ENUM_INT_INT) (marshal_data ? marshal_data : cc->callback);
 
629
 
 
630
  callback (data1,
 
631
            g_marshal_value_peek_pointer (param_values + 1),
 
632
            g_marshal_value_peek_pointer (param_values + 2),
 
633
            g_marshal_value_peek_pointer (param_values + 3),
 
634
            g_marshal_value_peek_enum (param_values + 4),
 
635
            g_marshal_value_peek_int (param_values + 5),
 
636
            g_marshal_value_peek_int (param_values + 6),
 
637
            data2);
 
638
}
 
639
 
 
640
/* VOID:POINTER,STRING (nautilus-marshal.list:18) */
 
641
void
 
642
nautilus_marshal_VOID__POINTER_STRING (GClosure     *closure,
 
643
                                       GValue       *return_value G_GNUC_UNUSED,
 
644
                                       guint         n_param_values,
 
645
                                       const GValue *param_values,
 
646
                                       gpointer      invocation_hint G_GNUC_UNUSED,
 
647
                                       gpointer      marshal_data)
 
648
{
 
649
  typedef void (*GMarshalFunc_VOID__POINTER_STRING) (gpointer     data1,
 
650
                                                     gpointer     arg_1,
 
651
                                                     gpointer     arg_2,
 
652
                                                     gpointer     data2);
 
653
  register GMarshalFunc_VOID__POINTER_STRING callback;
 
654
  register GCClosure *cc = (GCClosure*) closure;
 
655
  register gpointer data1, data2;
 
656
 
 
657
  g_return_if_fail (n_param_values == 3);
 
658
 
 
659
  if (G_CCLOSURE_SWAP_DATA (closure))
 
660
    {
 
661
      data1 = closure->data;
 
662
      data2 = g_value_peek_pointer (param_values + 0);
 
663
    }
 
664
  else
 
665
    {
 
666
      data1 = g_value_peek_pointer (param_values + 0);
 
667
      data2 = closure->data;
 
668
    }
 
669
  callback = (GMarshalFunc_VOID__POINTER_STRING) (marshal_data ? marshal_data : cc->callback);
 
670
 
 
671
  callback (data1,
 
672
            g_marshal_value_peek_pointer (param_values + 1),
 
673
            g_marshal_value_peek_string (param_values + 2),
 
674
            data2);
 
675
}
 
676
 
 
677
/* VOID:POINTER,STRING,ENUM,INT,INT (nautilus-marshal.list:19) */
 
678
void
 
679
nautilus_marshal_VOID__POINTER_STRING_ENUM_INT_INT (GClosure     *closure,
 
680
                                                    GValue       *return_value G_GNUC_UNUSED,
 
681
                                                    guint         n_param_values,
 
682
                                                    const GValue *param_values,
 
683
                                                    gpointer      invocation_hint G_GNUC_UNUSED,
 
684
                                                    gpointer      marshal_data)
 
685
{
 
686
  typedef void (*GMarshalFunc_VOID__POINTER_STRING_ENUM_INT_INT) (gpointer     data1,
 
687
                                                                  gpointer     arg_1,
 
688
                                                                  gpointer     arg_2,
 
689
                                                                  gint         arg_3,
 
690
                                                                  gint         arg_4,
 
691
                                                                  gint         arg_5,
 
692
                                                                  gpointer     data2);
 
693
  register GMarshalFunc_VOID__POINTER_STRING_ENUM_INT_INT callback;
 
694
  register GCClosure *cc = (GCClosure*) closure;
 
695
  register gpointer data1, data2;
 
696
 
 
697
  g_return_if_fail (n_param_values == 6);
 
698
 
 
699
  if (G_CCLOSURE_SWAP_DATA (closure))
 
700
    {
 
701
      data1 = closure->data;
 
702
      data2 = g_value_peek_pointer (param_values + 0);
 
703
    }
 
704
  else
 
705
    {
 
706
      data1 = g_value_peek_pointer (param_values + 0);
 
707
      data2 = closure->data;
 
708
    }
 
709
  callback = (GMarshalFunc_VOID__POINTER_STRING_ENUM_INT_INT) (marshal_data ? marshal_data : cc->callback);
 
710
 
 
711
  callback (data1,
 
712
            g_marshal_value_peek_pointer (param_values + 1),
 
713
            g_marshal_value_peek_string (param_values + 2),
 
714
            g_marshal_value_peek_enum (param_values + 3),
 
715
            g_marshal_value_peek_int (param_values + 4),
 
716
            g_marshal_value_peek_int (param_values + 5),
 
717
            data2);
 
718
}
 
719
 
 
720
/* VOID:STRING,STRING,ENUM,INT,INT (nautilus-marshal.list:20) */
 
721
void
 
722
nautilus_marshal_VOID__STRING_STRING_ENUM_INT_INT (GClosure     *closure,
 
723
                                                   GValue       *return_value G_GNUC_UNUSED,
 
724
                                                   guint         n_param_values,
 
725
                                                   const GValue *param_values,
 
726
                                                   gpointer      invocation_hint G_GNUC_UNUSED,
 
727
                                                   gpointer      marshal_data)
 
728
{
 
729
  typedef void (*GMarshalFunc_VOID__STRING_STRING_ENUM_INT_INT) (gpointer     data1,
 
730
                                                                 gpointer     arg_1,
 
731
                                                                 gpointer     arg_2,
 
732
                                                                 gint         arg_3,
 
733
                                                                 gint         arg_4,
 
734
                                                                 gint         arg_5,
 
735
                                                                 gpointer     data2);
 
736
  register GMarshalFunc_VOID__STRING_STRING_ENUM_INT_INT callback;
 
737
  register GCClosure *cc = (GCClosure*) closure;
 
738
  register gpointer data1, data2;
 
739
 
 
740
  g_return_if_fail (n_param_values == 6);
 
741
 
 
742
  if (G_CCLOSURE_SWAP_DATA (closure))
 
743
    {
 
744
      data1 = closure->data;
 
745
      data2 = g_value_peek_pointer (param_values + 0);
 
746
    }
 
747
  else
 
748
    {
 
749
      data1 = g_value_peek_pointer (param_values + 0);
 
750
      data2 = closure->data;
 
751
    }
 
752
  callback = (GMarshalFunc_VOID__STRING_STRING_ENUM_INT_INT) (marshal_data ? marshal_data : cc->callback);
 
753
 
 
754
  callback (data1,
 
755
            g_marshal_value_peek_string (param_values + 1),
 
756
            g_marshal_value_peek_string (param_values + 2),
 
757
            g_marshal_value_peek_enum (param_values + 3),
 
758
            g_marshal_value_peek_int (param_values + 4),
 
759
            g_marshal_value_peek_int (param_values + 5),
 
760
            data2);
 
761
}
 
762
 
 
763
/* VOID:STRING,ENUM,INT,INT (nautilus-marshal.list:21) */
 
764
void
 
765
nautilus_marshal_VOID__STRING_ENUM_INT_INT (GClosure     *closure,
 
766
                                            GValue       *return_value G_GNUC_UNUSED,
 
767
                                            guint         n_param_values,
 
768
                                            const GValue *param_values,
 
769
                                            gpointer      invocation_hint G_GNUC_UNUSED,
 
770
                                            gpointer      marshal_data)
 
771
{
 
772
  typedef void (*GMarshalFunc_VOID__STRING_ENUM_INT_INT) (gpointer     data1,
 
773
                                                          gpointer     arg_1,
 
774
                                                          gint         arg_2,
 
775
                                                          gint         arg_3,
 
776
                                                          gint         arg_4,
 
777
                                                          gpointer     data2);
 
778
  register GMarshalFunc_VOID__STRING_ENUM_INT_INT callback;
 
779
  register GCClosure *cc = (GCClosure*) closure;
 
780
  register gpointer data1, data2;
 
781
 
 
782
  g_return_if_fail (n_param_values == 5);
 
783
 
 
784
  if (G_CCLOSURE_SWAP_DATA (closure))
 
785
    {
 
786
      data1 = closure->data;
 
787
      data2 = g_value_peek_pointer (param_values + 0);
 
788
    }
 
789
  else
 
790
    {
 
791
      data1 = g_value_peek_pointer (param_values + 0);
 
792
      data2 = closure->data;
 
793
    }
 
794
  callback = (GMarshalFunc_VOID__STRING_ENUM_INT_INT) (marshal_data ? marshal_data : cc->callback);
 
795
 
 
796
  callback (data1,
 
797
            g_marshal_value_peek_string (param_values + 1),
 
798
            g_marshal_value_peek_enum (param_values + 2),
 
799
            g_marshal_value_peek_int (param_values + 3),
 
800
            g_marshal_value_peek_int (param_values + 4),
 
801
            data2);
 
802
}
 
803
 
 
804
/* VOID:STRING,STRING (nautilus-marshal.list:22) */
 
805
void
 
806
nautilus_marshal_VOID__STRING_STRING (GClosure     *closure,
 
807
                                      GValue       *return_value G_GNUC_UNUSED,
 
808
                                      guint         n_param_values,
 
809
                                      const GValue *param_values,
 
810
                                      gpointer      invocation_hint G_GNUC_UNUSED,
 
811
                                      gpointer      marshal_data)
 
812
{
 
813
  typedef void (*GMarshalFunc_VOID__STRING_STRING) (gpointer     data1,
 
814
                                                    gpointer     arg_1,
 
815
                                                    gpointer     arg_2,
 
816
                                                    gpointer     data2);
 
817
  register GMarshalFunc_VOID__STRING_STRING callback;
 
818
  register GCClosure *cc = (GCClosure*) closure;
 
819
  register gpointer data1, data2;
 
820
 
 
821
  g_return_if_fail (n_param_values == 3);
 
822
 
 
823
  if (G_CCLOSURE_SWAP_DATA (closure))
 
824
    {
 
825
      data1 = closure->data;
 
826
      data2 = g_value_peek_pointer (param_values + 0);
 
827
    }
 
828
  else
 
829
    {
 
830
      data1 = g_value_peek_pointer (param_values + 0);
 
831
      data2 = closure->data;
 
832
    }
 
833
  callback = (GMarshalFunc_VOID__STRING_STRING) (marshal_data ? marshal_data : cc->callback);
 
834
 
 
835
  callback (data1,
 
836
            g_marshal_value_peek_string (param_values + 1),
 
837
            g_marshal_value_peek_string (param_values + 2),
 
838
            data2);
 
839
}
 
840
 
 
841
/* VOID:POINTER,INT,STRING,STRING,ENUM,INT,INT (nautilus-marshal.list:23) */
 
842
void
 
843
nautilus_marshal_VOID__POINTER_INT_STRING_STRING_ENUM_INT_INT (GClosure     *closure,
 
844
                                                               GValue       *return_value G_GNUC_UNUSED,
 
845
                                                               guint         n_param_values,
 
846
                                                               const GValue *param_values,
 
847
                                                               gpointer      invocation_hint G_GNUC_UNUSED,
 
848
                                                               gpointer      marshal_data)
 
849
{
 
850
  typedef void (*GMarshalFunc_VOID__POINTER_INT_STRING_STRING_ENUM_INT_INT) (gpointer     data1,
 
851
                                                                             gpointer     arg_1,
 
852
                                                                             gint         arg_2,
 
853
                                                                             gpointer     arg_3,
 
854
                                                                             gpointer     arg_4,
 
855
                                                                             gint         arg_5,
 
856
                                                                             gint         arg_6,
 
857
                                                                             gint         arg_7,
 
858
                                                                             gpointer     data2);
 
859
  register GMarshalFunc_VOID__POINTER_INT_STRING_STRING_ENUM_INT_INT callback;
 
860
  register GCClosure *cc = (GCClosure*) closure;
 
861
  register gpointer data1, data2;
 
862
 
 
863
  g_return_if_fail (n_param_values == 8);
 
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_VOID__POINTER_INT_STRING_STRING_ENUM_INT_INT) (marshal_data ? marshal_data : cc->callback);
 
876
 
 
877
  callback (data1,
 
878
            g_marshal_value_peek_pointer (param_values + 1),
 
879
            g_marshal_value_peek_int (param_values + 2),
 
880
            g_marshal_value_peek_string (param_values + 3),
 
881
            g_marshal_value_peek_string (param_values + 4),
 
882
            g_marshal_value_peek_enum (param_values + 5),
 
883
            g_marshal_value_peek_int (param_values + 6),
 
884
            g_marshal_value_peek_int (param_values + 7),
 
885
            data2);
 
886
}
 
887