← Back to branch summary

~ubuntu-branches/debian/sid/libindicate/sid

« back to all changes in this revision

Viewing changes to libindicate/listener-marshal.c

  • Committer: Bazaar Package Importer
  • Author(s): Evgeni Golov
  • Date: 2010-06-20 14:01:00 UTC
  • mfrom: (4.1.14 maverick)
  • Revision ID: james.westby@ubuntu.com-20100620140100-59y3fqqmp9nfp8gr
Tags: 0.4.1-1
http://bugs.debian.org/560122
* Merge from Ubuntu.
  Closes: #560122
* debian/control:
  - Set Maintainer to pkg-ayatana.
  - Add myself as Uploader.
  - Update Vcs-* fields.
  - Standards-Version: 3.8.4
  - Update package descriptions.
  - -doc package is Arch:all
  - -doc package does not need to depend on the lib.
* debian/copyright:
  - Convert to DEP5 format.
  - Add Ken and Sebastien, according to changelog.
  - Add bindings/ and examples/ copyrights.
* debian/{control,rules}:
  - Force python2.6.

Show diffs side-by-side

added added

removed removed

Lines of Context:
libindicate/listener-marshal.c
1
 
 
2
 
#include        <glib-object.h>
3
 
 
4
 
 
5
 
#ifdef G_ENABLE_DEBUG
6
 
#define g_marshal_value_peek_boolean(v)  g_value_get_boolean (v)
7
 
#define g_marshal_value_peek_char(v)     g_value_get_char (v)
8
 
#define g_marshal_value_peek_uchar(v)    g_value_get_uchar (v)
9
 
#define g_marshal_value_peek_int(v)      g_value_get_int (v)
10
 
#define g_marshal_value_peek_uint(v)     g_value_get_uint (v)
11
 
#define g_marshal_value_peek_long(v)     g_value_get_long (v)
12
 
#define g_marshal_value_peek_ulong(v)    g_value_get_ulong (v)
13
 
#define g_marshal_value_peek_int64(v)    g_value_get_int64 (v)
14
 
#define g_marshal_value_peek_uint64(v)   g_value_get_uint64 (v)
15
 
#define g_marshal_value_peek_enum(v)     g_value_get_enum (v)
16
 
#define g_marshal_value_peek_flags(v)    g_value_get_flags (v)
17
 
#define g_marshal_value_peek_float(v)    g_value_get_float (v)
18
 
#define g_marshal_value_peek_double(v)   g_value_get_double (v)
19
 
#define g_marshal_value_peek_string(v)   (char*) g_value_get_string (v)
20
 
#define g_marshal_value_peek_param(v)    g_value_get_param (v)
21
 
#define g_marshal_value_peek_boxed(v)    g_value_get_boxed (v)
22
 
#define g_marshal_value_peek_pointer(v)  g_value_get_pointer (v)
23
 
#define g_marshal_value_peek_object(v)   g_value_get_object (v)
24
 
#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
 
#endif /* !G_ENABLE_DEBUG */
48
 
 
49
 
 
50
 
/* VOID:UINT,STRING (./listener-marshal.list:29) */
51
 
void
52
 
_indicate_listener_marshal_VOID__UINT_STRING (GClosure     *closure,
53
 
                                              GValue       *return_value G_GNUC_UNUSED,
54
 
                                              guint         n_param_values,
55
 
                                              const GValue *param_values,
56
 
                                              gpointer      invocation_hint G_GNUC_UNUSED,
57
 
                                              gpointer      marshal_data)
58
 
{
59
 
  typedef void (*GMarshalFunc_VOID__UINT_STRING) (gpointer     data1,
60
 
                                                  guint        arg_1,
61
 
                                                  gpointer     arg_2,
62
 
                                                  gpointer     data2);
63
 
  register GMarshalFunc_VOID__UINT_STRING callback;
64
 
  register GCClosure *cc = (GCClosure*) closure;
65
 
  register gpointer data1, data2;
66
 
 
67
 
  g_return_if_fail (n_param_values == 3);
68
 
 
69
 
  if (G_CCLOSURE_SWAP_DATA (closure))
70
 
    {
71
 
      data1 = closure->data;
72
 
      data2 = g_value_peek_pointer (param_values + 0);
73
 
    }
74
 
  else
75
 
    {
76
 
      data1 = g_value_peek_pointer (param_values + 0);
77
 
      data2 = closure->data;
78
 
    }
79
 
  callback = (GMarshalFunc_VOID__UINT_STRING) (marshal_data ? marshal_data : cc->callback);
80
 
 
81
 
  callback (data1,
82
 
            g_marshal_value_peek_uint (param_values + 1),
83
 
            g_marshal_value_peek_string (param_values + 2),
84
 
            data2);
85
 
}
86
 
 
87
 
/* VOID:POINTER,POINTER (./listener-marshal.list:31) */
88
 
void
89
 
_indicate_listener_marshal_VOID__POINTER_POINTER (GClosure     *closure,
90
 
                                                  GValue       *return_value G_GNUC_UNUSED,
91
 
                                                  guint         n_param_values,
92
 
                                                  const GValue *param_values,
93
 
                                                  gpointer      invocation_hint G_GNUC_UNUSED,
94
 
                                                  gpointer      marshal_data)
95
 
{
96
 
  typedef void (*GMarshalFunc_VOID__POINTER_POINTER) (gpointer     data1,
97
 
                                                      gpointer     arg_1,
98
 
                                                      gpointer     arg_2,
99
 
                                                      gpointer     data2);
100
 
  register GMarshalFunc_VOID__POINTER_POINTER callback;
101
 
  register GCClosure *cc = (GCClosure*) closure;
102
 
  register gpointer data1, data2;
103
 
 
104
 
  g_return_if_fail (n_param_values == 3);
105
 
 
106
 
  if (G_CCLOSURE_SWAP_DATA (closure))
107
 
    {
108
 
      data1 = closure->data;
109
 
      data2 = g_value_peek_pointer (param_values + 0);
110
 
    }
111
 
  else
112
 
    {
113
 
      data1 = g_value_peek_pointer (param_values + 0);
114
 
      data2 = closure->data;
115
 
    }
116
 
  callback = (GMarshalFunc_VOID__POINTER_POINTER) (marshal_data ? marshal_data : cc->callback);
117
 
 
118
 
  callback (data1,
119
 
            g_marshal_value_peek_pointer (param_values + 1),
120
 
            g_marshal_value_peek_pointer (param_values + 2),
121
 
            data2);
122
 
}
123
 
 
124
 
/* VOID:POINTER,POINTER,STRING (./listener-marshal.list:33) */
125
 
void
126
 
_indicate_listener_marshal_VOID__POINTER_POINTER_STRING (GClosure     *closure,
127
 
                                                         GValue       *return_value G_GNUC_UNUSED,
128
 
                                                         guint         n_param_values,
129
 
                                                         const GValue *param_values,
130
 
                                                         gpointer      invocation_hint G_GNUC_UNUSED,
131
 
                                                         gpointer      marshal_data)
132
 
{
133
 
  typedef void (*GMarshalFunc_VOID__POINTER_POINTER_STRING) (gpointer     data1,
134
 
                                                             gpointer     arg_1,
135
 
                                                             gpointer     arg_2,
136
 
                                                             gpointer     arg_3,
137
 
                                                             gpointer     data2);
138
 
  register GMarshalFunc_VOID__POINTER_POINTER_STRING callback;
139
 
  register GCClosure *cc = (GCClosure*) closure;
140
 
  register gpointer data1, data2;
141
 
 
142
 
  g_return_if_fail (n_param_values == 4);
143
 
 
144
 
  if (G_CCLOSURE_SWAP_DATA (closure))
145
 
    {
146
 
      data1 = closure->data;
147
 
      data2 = g_value_peek_pointer (param_values + 0);
148
 
    }
149
 
  else
150
 
    {
151
 
      data1 = g_value_peek_pointer (param_values + 0);
152
 
      data2 = closure->data;
153
 
    }
154
 
  callback = (GMarshalFunc_VOID__POINTER_POINTER_STRING) (marshal_data ? marshal_data : cc->callback);
155
 
 
156
 
  callback (data1,
157
 
            g_marshal_value_peek_pointer (param_values + 1),
158
 
            g_marshal_value_peek_pointer (param_values + 2),
159
 
            g_marshal_value_peek_string (param_values + 3),
160
 
            data2);
161
 
}
162
 
 
163
 
/* VOID:POINTER,STRING (./listener-marshal.list:35) */
164
 
void
165
 
_indicate_listener_marshal_VOID__POINTER_STRING (GClosure     *closure,
166
 
                                                 GValue       *return_value G_GNUC_UNUSED,
167
 
                                                 guint         n_param_values,
168
 
                                                 const GValue *param_values,
169
 
                                                 gpointer      invocation_hint G_GNUC_UNUSED,
170
 
                                                 gpointer      marshal_data)
171
 
{
172
 
  typedef void (*GMarshalFunc_VOID__POINTER_STRING) (gpointer     data1,
173
 
                                                     gpointer     arg_1,
174
 
                                                     gpointer     arg_2,
175
 
                                                     gpointer     data2);
176
 
  register GMarshalFunc_VOID__POINTER_STRING callback;
177
 
  register GCClosure *cc = (GCClosure*) closure;
178
 
  register gpointer data1, data2;
179
 
 
180
 
  g_return_if_fail (n_param_values == 3);
181
 
 
182
 
  if (G_CCLOSURE_SWAP_DATA (closure))
183
 
    {
184
 
      data1 = closure->data;
185
 
      data2 = g_value_peek_pointer (param_values + 0);
186
 
    }
187
 
  else
188
 
    {
189
 
      data1 = g_value_peek_pointer (param_values + 0);
190
 
      data2 = closure->data;
191
 
    }
192
 
  callback = (GMarshalFunc_VOID__POINTER_STRING) (marshal_data ? marshal_data : cc->callback);
193
 
 
194
 
  callback (data1,
195
 
            g_marshal_value_peek_pointer (param_values + 1),
196
 
            g_marshal_value_peek_string (param_values + 2),
197
 
            data2);
198
 
}
199
 
 
200
 
/* VOID:POINTER,UINT (./listener-marshal.list:37) */
201
 
void
202
 
_indicate_listener_marshal_VOID__POINTER_UINT (GClosure     *closure,
203
 
                                               GValue       *return_value G_GNUC_UNUSED,
204
 
                                               guint         n_param_values,
205
 
                                               const GValue *param_values,
206
 
                                               gpointer      invocation_hint G_GNUC_UNUSED,
207
 
                                               gpointer      marshal_data)
208
 
{
209
 
  typedef void (*GMarshalFunc_VOID__POINTER_UINT) (gpointer     data1,
210
 
                                                   gpointer     arg_1,
211
 
                                                   guint        arg_2,
212
 
                                                   gpointer     data2);
213
 
  register GMarshalFunc_VOID__POINTER_UINT callback;
214
 
  register GCClosure *cc = (GCClosure*) closure;
215
 
  register gpointer data1, data2;
216
 
 
217
 
  g_return_if_fail (n_param_values == 3);
218
 
 
219
 
  if (G_CCLOSURE_SWAP_DATA (closure))
220
 
    {
221
 
      data1 = closure->data;
222
 
      data2 = g_value_peek_pointer (param_values + 0);
223
 
    }
224
 
  else
225
 
    {
226
 
      data1 = g_value_peek_pointer (param_values + 0);
227
 
      data2 = closure->data;
228
 
    }
229
 
  callback = (GMarshalFunc_VOID__POINTER_UINT) (marshal_data ? marshal_data : cc->callback);
230
 
 
231
 
  callback (data1,
232
 
            g_marshal_value_peek_pointer (param_values + 1),
233
 
            g_marshal_value_peek_uint (param_values + 2),
234
 
            data2);
235
 
}
236