← Back to branch summary

~mfisch/brasero/update-to-3.8.0

« back to all changes in this revision

Viewing changes to src/brasero-marshal.c

  • Committer: Bazaar Package Importer
  • Author(s): Pedro Fragoso
  • Date: 2008-11-18 11:30:50 UTC
  • mto: (1.4.1 experimental)
  • mto: This revision was merged to the branch mainline in revision 29.
  • Revision ID: james.westby@ubuntu.com-20081118113050-yhrskmatlel0gzfm
Tags: upstream-0.8.3
Import upstream version 0.8.3

Show diffs side-by-side

added added

removed removed

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