← Back to branch summary

~ubuntu-branches/ubuntu/natty/bamf/natty-proposed

« back to all changes in this revision

Viewing changes to lib/libbamf/bamf-tab-source-glue.h

  • Committer: Bazaar Package Importer
  • Author(s): Didier Roche
  • Date: 2011-01-14 17:30:12 UTC
  • mfrom: (1.1.23 upstream)
  • Revision ID: james.westby@ubuntu.com-20110114173012-peyiti78zlxz6fy0
Tags: 0.2.70-0ubuntu1
* New upstream release.
* debian/control:
  bamf dbus protocol changed. Breaks: on old unity

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/libbamf/bamf-tab-source-glue.h
55
55
#endif /* !G_ENABLE_DEBUG */
56
56
 
57
57
 
58
 
/* UINT:STRING */
59
 
extern void dbus_glib_marshal_bamf_tab_source_UINT__STRING (GClosure     *closure,
60
 
                                                            GValue       *return_value,
61
 
                                                            guint         n_param_values,
62
 
                                                            const GValue *param_values,
63
 
                                                            gpointer      invocation_hint,
64
 
                                                            gpointer      marshal_data);
65
 
void
66
 
dbus_glib_marshal_bamf_tab_source_UINT__STRING (GClosure     *closure,
67
 
                                                GValue       *return_value G_GNUC_UNUSED,
68
 
                                                guint         n_param_values,
69
 
                                                const GValue *param_values,
70
 
                                                gpointer      invocation_hint G_GNUC_UNUSED,
71
 
                                                gpointer      marshal_data)
72
 
{
73
 
  typedef guint (*GMarshalFunc_UINT__STRING) (gpointer     data1,
74
 
                                              gpointer     arg_1,
75
 
                                              gpointer     data2);
76
 
  register GMarshalFunc_UINT__STRING callback;
77
 
  register GCClosure *cc = (GCClosure*) closure;
78
 
  register gpointer data1, data2;
79
 
  guint v_return;
80
 
 
81
 
  g_return_if_fail (return_value != NULL);
82
 
  g_return_if_fail (n_param_values == 2);
83
 
 
84
 
  if (G_CCLOSURE_SWAP_DATA (closure))
85
 
    {
86
 
      data1 = closure->data;
87
 
      data2 = g_value_peek_pointer (param_values + 0);
88
 
    }
89
 
  else
90
 
    {
91
 
      data1 = g_value_peek_pointer (param_values + 0);
92
 
      data2 = closure->data;
93
 
    }
94
 
  callback = (GMarshalFunc_UINT__STRING) (marshal_data ? marshal_data : cc->callback);
95
 
 
96
 
  v_return = callback (data1,
97
 
                       g_marshal_value_peek_string (param_values + 1),
98
 
                       data2);
99
 
 
100
 
  g_value_set_uint (return_value, v_return);
101
 
}
102
 
 
103
58
/* BOXED:STRING */
104
59
extern void dbus_glib_marshal_bamf_tab_source_BOXED__STRING (GClosure     *closure,
105
60
                                                             GValue       *return_value,
145
100
  g_value_take_boxed (return_value, v_return);
146
101
}
147
102
 
148
 
/* STRING:STRING */
149
 
extern void dbus_glib_marshal_bamf_tab_source_STRING__STRING (GClosure     *closure,
150
 
                                                              GValue       *return_value,
151
 
                                                              guint         n_param_values,
152
 
                                                              const GValue *param_values,
153
 
                                                              gpointer      invocation_hint,
154
 
                                                              gpointer      marshal_data);
155
 
void
156
 
dbus_glib_marshal_bamf_tab_source_STRING__STRING (GClosure     *closure,
157
 
                                                  GValue       *return_value G_GNUC_UNUSED,
158
 
                                                  guint         n_param_values,
159
 
                                                  const GValue *param_values,
160
 
                                                  gpointer      invocation_hint G_GNUC_UNUSED,
161
 
                                                  gpointer      marshal_data)
162
 
{
163
 
  typedef gchar* (*GMarshalFunc_STRING__STRING) (gpointer     data1,
164
 
                                                 gpointer     arg_1,
165
 
                                                 gpointer     data2);
166
 
  register GMarshalFunc_STRING__STRING callback;
167
 
  register GCClosure *cc = (GCClosure*) closure;
168
 
  register gpointer data1, data2;
169
 
  gchar* v_return;
170
 
 
171
 
  g_return_if_fail (return_value != NULL);
172
 
  g_return_if_fail (n_param_values == 2);
173
 
 
174
 
  if (G_CCLOSURE_SWAP_DATA (closure))
175
 
    {
176
 
      data1 = closure->data;
177
 
      data2 = g_value_peek_pointer (param_values + 0);
178
 
    }
179
 
  else
180
 
    {
181
 
      data1 = g_value_peek_pointer (param_values + 0);
182
 
      data2 = closure->data;
183
 
    }
184
 
  callback = (GMarshalFunc_STRING__STRING) (marshal_data ? marshal_data : cc->callback);
185
 
 
186
 
  v_return = callback (data1,
187
 
                       g_marshal_value_peek_string (param_values + 1),
188
 
                       data2);
189
 
 
190
 
  g_value_take_string (return_value, v_return);
191
 
}
192
 
 
193
103
/* BOOLEAN:STRING,POINTER */
194
104
extern void dbus_glib_marshal_bamf_tab_source_BOOLEAN__STRING_POINTER (GClosure     *closure,
195
105
                                                                       GValue       *return_value,
237
147
  g_value_set_boolean (return_value, v_return);
238
148
}
239
149
 
 
150
/* UINT:STRING */
 
151
extern void dbus_glib_marshal_bamf_tab_source_UINT__STRING (GClosure     *closure,
 
152
                                                            GValue       *return_value,
 
153
                                                            guint         n_param_values,
 
154
                                                            const GValue *param_values,
 
155
                                                            gpointer      invocation_hint,
 
156
                                                            gpointer      marshal_data);
 
157
void
 
158
dbus_glib_marshal_bamf_tab_source_UINT__STRING (GClosure     *closure,
 
159
                                                GValue       *return_value G_GNUC_UNUSED,
 
160
                                                guint         n_param_values,
 
161
                                                const GValue *param_values,
 
162
                                                gpointer      invocation_hint G_GNUC_UNUSED,
 
163
                                                gpointer      marshal_data)
 
164
{
 
165
  typedef guint (*GMarshalFunc_UINT__STRING) (gpointer     data1,
 
166
                                              gpointer     arg_1,
 
167
                                              gpointer     data2);
 
168
  register GMarshalFunc_UINT__STRING callback;
 
169
  register GCClosure *cc = (GCClosure*) closure;
 
170
  register gpointer data1, data2;
 
171
  guint v_return;
 
172
 
 
173
  g_return_if_fail (return_value != NULL);
 
174
  g_return_if_fail (n_param_values == 2);
 
175
 
 
176
  if (G_CCLOSURE_SWAP_DATA (closure))
 
177
    {
 
178
      data1 = closure->data;
 
179
      data2 = g_value_peek_pointer (param_values + 0);
 
180
    }
 
181
  else
 
182
    {
 
183
      data1 = g_value_peek_pointer (param_values + 0);
 
184
      data2 = closure->data;
 
185
    }
 
186
  callback = (GMarshalFunc_UINT__STRING) (marshal_data ? marshal_data : cc->callback);
 
187
 
 
188
  v_return = callback (data1,
 
189
                       g_marshal_value_peek_string (param_values + 1),
 
190
                       data2);
 
191
 
 
192
  g_value_set_uint (return_value, v_return);
 
193
}
 
194
 
240
195
/* BOXED:NONE */
241
196
extern void dbus_glib_marshal_bamf_tab_source_BOXED__VOID (GClosure     *closure,
242
197
                                                           GValue       *return_value,
281
236
}
282
237
#define dbus_glib_marshal_bamf_tab_source_BOXED__NONE   dbus_glib_marshal_bamf_tab_source_BOXED__VOID
283
238
 
 
239
/* STRING:STRING */
 
240
extern void dbus_glib_marshal_bamf_tab_source_STRING__STRING (GClosure     *closure,
 
241
                                                              GValue       *return_value,
 
242
                                                              guint         n_param_values,
 
243
                                                              const GValue *param_values,
 
244
                                                              gpointer      invocation_hint,
 
245
                                                              gpointer      marshal_data);
 
246
void
 
247
dbus_glib_marshal_bamf_tab_source_STRING__STRING (GClosure     *closure,
 
248
                                                  GValue       *return_value G_GNUC_UNUSED,
 
249
                                                  guint         n_param_values,
 
250
                                                  const GValue *param_values,
 
251
                                                  gpointer      invocation_hint G_GNUC_UNUSED,
 
252
                                                  gpointer      marshal_data)
 
253
{
 
254
  typedef gchar* (*GMarshalFunc_STRING__STRING) (gpointer     data1,
 
255
                                                 gpointer     arg_1,
 
256
                                                 gpointer     data2);
 
257
  register GMarshalFunc_STRING__STRING callback;
 
258
  register GCClosure *cc = (GCClosure*) closure;
 
259
  register gpointer data1, data2;
 
260
  gchar* v_return;
 
261
 
 
262
  g_return_if_fail (return_value != NULL);
 
263
  g_return_if_fail (n_param_values == 2);
 
264
 
 
265
  if (G_CCLOSURE_SWAP_DATA (closure))
 
266
    {
 
267
      data1 = closure->data;
 
268
      data2 = g_value_peek_pointer (param_values + 0);
 
269
    }
 
270
  else
 
271
    {
 
272
      data1 = g_value_peek_pointer (param_values + 0);
 
273
      data2 = closure->data;
 
274
    }
 
275
  callback = (GMarshalFunc_STRING__STRING) (marshal_data ? marshal_data : cc->callback);
 
276
 
 
277
  v_return = callback (data1,
 
278
                       g_marshal_value_peek_string (param_values + 1),
 
279
                       data2);
 
280
 
 
281
  g_value_take_string (return_value, v_return);
 
282
}
 
283
 
284
284
G_END_DECLS
285
285
 
286
286
#endif /* __dbus_glib_marshal_bamf_tab_source_MARSHAL_H__ */