← Back to branch summary

~ubuntu-branches/ubuntu/trusty/gnome-shell/trusty-proposed

« back to all changes in this revision

Viewing changes to src/shell-marshal.c

  • Committer: Package Import Robot
  • Author(s): Jeremy Bicha
  • Date: 2012-03-14 13:47:20 UTC
  • mfrom: (1.1.36) (18.1.8 sid)
  • Revision ID: package-import@ubuntu.com-20120314134720-202sbjbu4a3z1fru
Tags: 3.3.90-0ubuntu1
https://launchpad.net/bugs/941755
https://launchpad.net/bugs/937709
* Sync with Debian experimental svn packaging (LP: #941755, #937709).
  Remaining changes:
  - debian/gnome-shell.gsettings-override: Update for Ubuntu defaults
  - debian/control.in: Recommend cups-pk-helper
  - debian/patches/10-make-NetworkManager-optional.patch: Disabled
  - Don't run dh-autoreconf

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/shell-marshal.c
1
 
#include "shell-marshal.h"
2
 
 
3
 
#include        <glib-object.h>
4
 
 
5
 
 
6
 
#ifdef G_ENABLE_DEBUG
7
 
#define g_marshal_value_peek_boolean(v)  g_value_get_boolean (v)
8
 
#define g_marshal_value_peek_char(v)     g_value_get_char (v)
9
 
#define g_marshal_value_peek_uchar(v)    g_value_get_uchar (v)
10
 
#define g_marshal_value_peek_int(v)      g_value_get_int (v)
11
 
#define g_marshal_value_peek_uint(v)     g_value_get_uint (v)
12
 
#define g_marshal_value_peek_long(v)     g_value_get_long (v)
13
 
#define g_marshal_value_peek_ulong(v)    g_value_get_ulong (v)
14
 
#define g_marshal_value_peek_int64(v)    g_value_get_int64 (v)
15
 
#define g_marshal_value_peek_uint64(v)   g_value_get_uint64 (v)
16
 
#define g_marshal_value_peek_enum(v)     g_value_get_enum (v)
17
 
#define g_marshal_value_peek_flags(v)    g_value_get_flags (v)
18
 
#define g_marshal_value_peek_float(v)    g_value_get_float (v)
19
 
#define g_marshal_value_peek_double(v)   g_value_get_double (v)
20
 
#define g_marshal_value_peek_string(v)   (char*) g_value_get_string (v)
21
 
#define g_marshal_value_peek_param(v)    g_value_get_param (v)
22
 
#define g_marshal_value_peek_boxed(v)    g_value_get_boxed (v)
23
 
#define g_marshal_value_peek_pointer(v)  g_value_get_pointer (v)
24
 
#define g_marshal_value_peek_object(v)   g_value_get_object (v)
25
 
#define g_marshal_value_peek_variant(v)  g_value_get_variant (v)
26
 
#else /* !G_ENABLE_DEBUG */
27
 
/* WARNING: This code accesses GValues directly, which is UNSUPPORTED API.
28
 
 *          Do not access GValues directly in your code. Instead, use the
29
 
 *          g_value_get_*() functions
30
 
 */
31
 
#define g_marshal_value_peek_boolean(v)  (v)->data[0].v_int
32
 
#define g_marshal_value_peek_char(v)     (v)->data[0].v_int
33
 
#define g_marshal_value_peek_uchar(v)    (v)->data[0].v_uint
34
 
#define g_marshal_value_peek_int(v)      (v)->data[0].v_int
35
 
#define g_marshal_value_peek_uint(v)     (v)->data[0].v_uint
36
 
#define g_marshal_value_peek_long(v)     (v)->data[0].v_long
37
 
#define g_marshal_value_peek_ulong(v)    (v)->data[0].v_ulong
38
 
#define g_marshal_value_peek_int64(v)    (v)->data[0].v_int64
39
 
#define g_marshal_value_peek_uint64(v)   (v)->data[0].v_uint64
40
 
#define g_marshal_value_peek_enum(v)     (v)->data[0].v_long
41
 
#define g_marshal_value_peek_flags(v)    (v)->data[0].v_ulong
42
 
#define g_marshal_value_peek_float(v)    (v)->data[0].v_float
43
 
#define g_marshal_value_peek_double(v)   (v)->data[0].v_double
44
 
#define g_marshal_value_peek_string(v)   (v)->data[0].v_pointer
45
 
#define g_marshal_value_peek_param(v)    (v)->data[0].v_pointer
46
 
#define g_marshal_value_peek_boxed(v)    (v)->data[0].v_pointer
47
 
#define g_marshal_value_peek_pointer(v)  (v)->data[0].v_pointer
48
 
#define g_marshal_value_peek_object(v)   (v)->data[0].v_pointer
49
 
#define g_marshal_value_peek_variant(v)  (v)->data[0].v_pointer
50
 
#endif /* !G_ENABLE_DEBUG */
51
 
 
52
 
 
53
 
/* VOID:INT,INT,INT (./shell-marshal.list:1) */
54
 
void
55
 
_shell_marshal_VOID__INT_INT_INT (GClosure     *closure,
56
 
                                  GValue       *return_value G_GNUC_UNUSED,
57
 
                                  guint         n_param_values,
58
 
                                  const GValue *param_values,
59
 
                                  gpointer      invocation_hint G_GNUC_UNUSED,
60
 
                                  gpointer      marshal_data)
61
 
{
62
 
  typedef void (*GMarshalFunc_VOID__INT_INT_INT) (gpointer     data1,
63
 
                                                  gint         arg_1,
64
 
                                                  gint         arg_2,
65
 
                                                  gint         arg_3,
66
 
                                                  gpointer     data2);
67
 
  register GMarshalFunc_VOID__INT_INT_INT callback;
68
 
  register GCClosure *cc = (GCClosure*) closure;
69
 
  register gpointer data1, data2;
70
 
 
71
 
  g_return_if_fail (n_param_values == 4);
72
 
 
73
 
  if (G_CCLOSURE_SWAP_DATA (closure))
74
 
    {
75
 
      data1 = closure->data;
76
 
      data2 = g_value_peek_pointer (param_values + 0);
77
 
    }
78
 
  else
79
 
    {
80
 
      data1 = g_value_peek_pointer (param_values + 0);
81
 
      data2 = closure->data;
82
 
    }
83
 
  callback = (GMarshalFunc_VOID__INT_INT_INT) (marshal_data ? marshal_data : cc->callback);
84
 
 
85
 
  callback (data1,
86
 
            g_marshal_value_peek_int (param_values + 1),
87
 
            g_marshal_value_peek_int (param_values + 2),
88
 
            g_marshal_value_peek_int (param_values + 3),
89
 
            data2);
90
 
}
91
 
 
92
 
/* VOID:OBJECT,INT,INT,INT,INT (./shell-marshal.list:2) */
93
 
void
94
 
_shell_marshal_VOID__OBJECT_INT_INT_INT_INT (GClosure     *closure,
95
 
                                             GValue       *return_value G_GNUC_UNUSED,
96
 
                                             guint         n_param_values,
97
 
                                             const GValue *param_values,
98
 
                                             gpointer      invocation_hint G_GNUC_UNUSED,
99
 
                                             gpointer      marshal_data)
100
 
{
101
 
  typedef void (*GMarshalFunc_VOID__OBJECT_INT_INT_INT_INT) (gpointer     data1,
102
 
                                                             gpointer     arg_1,
103
 
                                                             gint         arg_2,
104
 
                                                             gint         arg_3,
105
 
                                                             gint         arg_4,
106
 
                                                             gint         arg_5,
107
 
                                                             gpointer     data2);
108
 
  register GMarshalFunc_VOID__OBJECT_INT_INT_INT_INT callback;
109
 
  register GCClosure *cc = (GCClosure*) closure;
110
 
  register gpointer data1, data2;
111
 
 
112
 
  g_return_if_fail (n_param_values == 6);
113
 
 
114
 
  if (G_CCLOSURE_SWAP_DATA (closure))
115
 
    {
116
 
      data1 = closure->data;
117
 
      data2 = g_value_peek_pointer (param_values + 0);
118
 
    }
119
 
  else
120
 
    {
121
 
      data1 = g_value_peek_pointer (param_values + 0);
122
 
      data2 = closure->data;
123
 
    }
124
 
  callback = (GMarshalFunc_VOID__OBJECT_INT_INT_INT_INT) (marshal_data ? marshal_data : cc->callback);
125
 
 
126
 
  callback (data1,
127
 
            g_marshal_value_peek_object (param_values + 1),
128
 
            g_marshal_value_peek_int (param_values + 2),
129
 
            g_marshal_value_peek_int (param_values + 3),
130
 
            g_marshal_value_peek_int (param_values + 4),
131
 
            g_marshal_value_peek_int (param_values + 5),
132
 
            data2);
133
 
}
134
 
 
135
 
/* VOID:BOXED (./shell-marshal.list:3) */
136
 
 
137
 
/* VOID:BOXED,OBJECT (./shell-marshal.list:4) */
138
 
void
139
 
_shell_marshal_VOID__BOXED_OBJECT (GClosure     *closure,
140
 
                                   GValue       *return_value G_GNUC_UNUSED,
141
 
                                   guint         n_param_values,
142
 
                                   const GValue *param_values,
143
 
                                   gpointer      invocation_hint G_GNUC_UNUSED,
144
 
                                   gpointer      marshal_data)
145
 
{
146
 
  typedef void (*GMarshalFunc_VOID__BOXED_OBJECT) (gpointer     data1,
147
 
                                                   gpointer     arg_1,
148
 
                                                   gpointer     arg_2,
149
 
                                                   gpointer     data2);
150
 
  register GMarshalFunc_VOID__BOXED_OBJECT callback;
151
 
  register GCClosure *cc = (GCClosure*) closure;
152
 
  register gpointer data1, data2;
153
 
 
154
 
  g_return_if_fail (n_param_values == 3);
155
 
 
156
 
  if (G_CCLOSURE_SWAP_DATA (closure))
157
 
    {
158
 
      data1 = closure->data;
159
 
      data2 = g_value_peek_pointer (param_values + 0);
160
 
    }
161
 
  else
162
 
    {
163
 
      data1 = g_value_peek_pointer (param_values + 0);
164
 
      data2 = closure->data;
165
 
    }
166
 
  callback = (GMarshalFunc_VOID__BOXED_OBJECT) (marshal_data ? marshal_data : cc->callback);
167
 
 
168
 
  callback (data1,
169
 
            g_marshal_value_peek_boxed (param_values + 1),
170
 
            g_marshal_value_peek_object (param_values + 2),
171
 
            data2);
172
 
}
173
 
 
174
 
/* VOID:OBJECT,OBJECT (./shell-marshal.list:5) */
175
 
void
176
 
_shell_marshal_VOID__OBJECT_OBJECT (GClosure     *closure,
177
 
                                    GValue       *return_value G_GNUC_UNUSED,
178
 
                                    guint         n_param_values,
179
 
                                    const GValue *param_values,
180
 
                                    gpointer      invocation_hint G_GNUC_UNUSED,
181
 
                                    gpointer      marshal_data)
182
 
{
183
 
  typedef void (*GMarshalFunc_VOID__OBJECT_OBJECT) (gpointer     data1,
184
 
                                                    gpointer     arg_1,
185
 
                                                    gpointer     arg_2,
186
 
                                                    gpointer     data2);
187
 
  register GMarshalFunc_VOID__OBJECT_OBJECT callback;
188
 
  register GCClosure *cc = (GCClosure*) closure;
189
 
  register gpointer data1, data2;
190
 
 
191
 
  g_return_if_fail (n_param_values == 3);
192
 
 
193
 
  if (G_CCLOSURE_SWAP_DATA (closure))
194
 
    {
195
 
      data1 = closure->data;
196
 
      data2 = g_value_peek_pointer (param_values + 0);
197
 
    }
198
 
  else
199
 
    {
200
 
      data1 = g_value_peek_pointer (param_values + 0);
201
 
      data2 = closure->data;
202
 
    }
203
 
  callback = (GMarshalFunc_VOID__OBJECT_OBJECT) (marshal_data ? marshal_data : cc->callback);
204
 
 
205
 
  callback (data1,
206
 
            g_marshal_value_peek_object (param_values + 1),
207
 
            g_marshal_value_peek_object (param_values + 2),
208
 
            data2);
209
 
}
210
 
 
211
 
/* VOID:STRING,UINT,OBJECT,BOOLEAN (./shell-marshal.list:6) */
212
 
void
213
 
_shell_marshal_VOID__STRING_UINT_OBJECT_BOOLEAN (GClosure     *closure,
214
 
                                                 GValue       *return_value G_GNUC_UNUSED,
215
 
                                                 guint         n_param_values,
216
 
                                                 const GValue *param_values,
217
 
                                                 gpointer      invocation_hint G_GNUC_UNUSED,
218
 
                                                 gpointer      marshal_data)
219
 
{
220
 
  typedef void (*GMarshalFunc_VOID__STRING_UINT_OBJECT_BOOLEAN) (gpointer     data1,
221
 
                                                                 gpointer     arg_1,
222
 
                                                                 guint        arg_2,
223
 
                                                                 gpointer     arg_3,
224
 
                                                                 gboolean     arg_4,
225
 
                                                                 gpointer     data2);
226
 
  register GMarshalFunc_VOID__STRING_UINT_OBJECT_BOOLEAN callback;
227
 
  register GCClosure *cc = (GCClosure*) closure;
228
 
  register gpointer data1, data2;
229
 
 
230
 
  g_return_if_fail (n_param_values == 5);
231
 
 
232
 
  if (G_CCLOSURE_SWAP_DATA (closure))
233
 
    {
234
 
      data1 = closure->data;
235
 
      data2 = g_value_peek_pointer (param_values + 0);
236
 
    }
237
 
  else
238
 
    {
239
 
      data1 = g_value_peek_pointer (param_values + 0);
240
 
      data2 = closure->data;
241
 
    }
242
 
  callback = (GMarshalFunc_VOID__STRING_UINT_OBJECT_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
243
 
 
244
 
  callback (data1,
245
 
            g_marshal_value_peek_string (param_values + 1),
246
 
            g_marshal_value_peek_uint (param_values + 2),
247
 
            g_marshal_value_peek_object (param_values + 3),
248
 
            g_marshal_value_peek_boolean (param_values + 4),
249
 
            data2);
250
 
}
251
 
 
252
 
/* VOID:INT,INT (./shell-marshal.list:7) */
253
 
void
254
 
_shell_marshal_VOID__INT_INT (GClosure     *closure,
255
 
                              GValue       *return_value G_GNUC_UNUSED,
256
 
                              guint         n_param_values,
257
 
                              const GValue *param_values,
258
 
                              gpointer      invocation_hint G_GNUC_UNUSED,
259
 
                              gpointer      marshal_data)
260
 
{
261
 
  typedef void (*GMarshalFunc_VOID__INT_INT) (gpointer     data1,
262
 
                                              gint         arg_1,
263
 
                                              gint         arg_2,
264
 
                                              gpointer     data2);
265
 
  register GMarshalFunc_VOID__INT_INT callback;
266
 
  register GCClosure *cc = (GCClosure*) closure;
267
 
  register gpointer data1, data2;
268
 
 
269
 
  g_return_if_fail (n_param_values == 3);
270
 
 
271
 
  if (G_CCLOSURE_SWAP_DATA (closure))
272
 
    {
273
 
      data1 = closure->data;
274
 
      data2 = g_value_peek_pointer (param_values + 0);
275
 
    }
276
 
  else
277
 
    {
278
 
      data1 = g_value_peek_pointer (param_values + 0);
279
 
      data2 = closure->data;
280
 
    }
281
 
  callback = (GMarshalFunc_VOID__INT_INT) (marshal_data ? marshal_data : cc->callback);
282
 
 
283
 
  callback (data1,
284
 
            g_marshal_value_peek_int (param_values + 1),
285
 
            g_marshal_value_peek_int (param_values + 2),
286
 
            data2);
287
 
}
288
 
 
289
 
/* VOID:STRING,STRING,STRING,STRING,BOXED (./shell-marshal.list:8) */
290
 
void
291
 
_shell_marshal_VOID__STRING_STRING_STRING_STRING_BOXED (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 void (*GMarshalFunc_VOID__STRING_STRING_STRING_STRING_BOXED) (gpointer     data1,
299
 
                                                                        gpointer     arg_1,
300
 
                                                                        gpointer     arg_2,
301
 
                                                                        gpointer     arg_3,
302
 
                                                                        gpointer     arg_4,
303
 
                                                                        gpointer     arg_5,
304
 
                                                                        gpointer     data2);
305
 
  register GMarshalFunc_VOID__STRING_STRING_STRING_STRING_BOXED callback;
306
 
  register GCClosure *cc = (GCClosure*) closure;
307
 
  register gpointer data1, data2;
308
 
 
309
 
  g_return_if_fail (n_param_values == 6);
310
 
 
311
 
  if (G_CCLOSURE_SWAP_DATA (closure))
312
 
    {
313
 
      data1 = closure->data;
314
 
      data2 = g_value_peek_pointer (param_values + 0);
315
 
    }
316
 
  else
317
 
    {
318
 
      data1 = g_value_peek_pointer (param_values + 0);
319
 
      data2 = closure->data;
320
 
    }
321
 
  callback = (GMarshalFunc_VOID__STRING_STRING_STRING_STRING_BOXED) (marshal_data ? marshal_data : cc->callback);
322
 
 
323
 
  callback (data1,
324
 
            g_marshal_value_peek_string (param_values + 1),
325
 
            g_marshal_value_peek_string (param_values + 2),
326
 
            g_marshal_value_peek_string (param_values + 3),
327
 
            g_marshal_value_peek_string (param_values + 4),
328
 
            g_marshal_value_peek_boxed (param_values + 5),
329
 
            data2);
330
 
}
331
 
 
332
 
/* VOID:STRING,OBJECT,STRING,BOXED (./shell-marshal.list:9) */
333
 
void
334
 
_shell_marshal_VOID__STRING_OBJECT_STRING_BOXED (GClosure     *closure,
335
 
                                                 GValue       *return_value G_GNUC_UNUSED,
336
 
                                                 guint         n_param_values,
337
 
                                                 const GValue *param_values,
338
 
                                                 gpointer      invocation_hint G_GNUC_UNUSED,
339
 
                                                 gpointer      marshal_data)
340
 
{
341
 
  typedef void (*GMarshalFunc_VOID__STRING_OBJECT_STRING_BOXED) (gpointer     data1,
342
 
                                                                 gpointer     arg_1,
343
 
                                                                 gpointer     arg_2,
344
 
                                                                 gpointer     arg_3,
345
 
                                                                 gpointer     arg_4,
346
 
                                                                 gpointer     data2);
347
 
  register GMarshalFunc_VOID__STRING_OBJECT_STRING_BOXED callback;
348
 
  register GCClosure *cc = (GCClosure*) closure;
349
 
  register gpointer data1, data2;
350
 
 
351
 
  g_return_if_fail (n_param_values == 5);
352
 
 
353
 
  if (G_CCLOSURE_SWAP_DATA (closure))
354
 
    {
355
 
      data1 = closure->data;
356
 
      data2 = g_value_peek_pointer (param_values + 0);
357
 
    }
358
 
  else
359
 
    {
360
 
      data1 = g_value_peek_pointer (param_values + 0);
361
 
      data2 = closure->data;
362
 
    }
363
 
  callback = (GMarshalFunc_VOID__STRING_OBJECT_STRING_BOXED) (marshal_data ? marshal_data : cc->callback);
364
 
 
365
 
  callback (data1,
366
 
            g_marshal_value_peek_string (param_values + 1),
367
 
            g_marshal_value_peek_object (param_values + 2),
368
 
            g_marshal_value_peek_string (param_values + 3),
369
 
            g_marshal_value_peek_boxed (param_values + 4),
370
 
            data2);
371
 
}
372