← Back to branch summary

~wongchiachen/ubuntu/precise/totem/hey_about_dialog

« back to all changes in this revision

Viewing changes to browser-plugin/totem-plugin-viewer-interface.h

  • Committer: Bazaar Package Importer
  • Author(s): Sebastien Bacher
  • Date: 2011-05-20 16:38:02 UTC
  • mfrom: (1.11.13 upstream) (2.1.17 experimental)
  • Revision ID: james.westby@ubuntu.com-20110520163802-p3lohdmfvws2jqeo
Tags: 3.0.1-0ubuntu1
* Resynchronize on Debian, remaining diffs:
* debian/control.in:
  - use suggests rather than recommends for universe gstreamer components
  - add totem-plugins-extra for the components which have depends in universe
  - add build-depends on gnome-common, dh-autoreconf, 
    liblaunchpad-intrgration-3.0-dev, hardening-wrapper
  - drop build-depends on libepc-ui-dev, python-feedparser, xulrunner-dev,
    libtracker-sparql-0.10-dev
  - add XB-Npp-Description and XB-Npp-Filename header to the 
    totem-mozilla package to improve ubufox/ubuntu plugin db integration 
  - change refences from Iceweasel to Firefox
  - recommends gnome-icon-theme-symbolic rather than depending on it
  - list firefox as a totem-mozilla recommends before epiphany-browser
  - libtotem replaces totem (<< 3.0.1-1) for ppa upgrades
* debian/totem-common.install:
  - Install apport hook
* debian/totem-plugins-extra.install:
  - Plugins split out ouf totem-plugins
* debian/totem-plugins.install:    
  - Move some plugins to totem-plugins-extra
* debian/totem.preinst:
  - No longer required as Lucid has been released
* debian/patches/01_fake_keypresses.patch:
  - dropped it's an old workaround and should not be required
* debian/patches/02_lpi.patch:
  - Launchpad integration
* debian/patches/03_default_options.patch: 
  - enable the youtube option by default
* debian/patches/70_bbc_plugin.patch:
  - bbc content viewer, needs to be fixed for the new version
* debian/source_totem.py:
  - ubuntu apport debugging
* debian/rules:
  - run autoreconf on build
* debian/watch:
  - Watch for unstable versions

Show diffs side-by-side

added added

removed removed

Lines of Context:
browser-plugin/totem-plugin-viewer-interface.h
55
55
#endif /* !G_ENABLE_DEBUG */
56
56
 
57
57
 
58
 
/* BOOLEAN:STRING,STRING,STRING,POINTER */
59
 
extern void dbus_glib_marshal_totem_embedded_BOOLEAN__STRING_STRING_STRING_POINTER (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_totem_embedded_BOOLEAN__STRING_STRING_STRING_POINTER (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 gboolean (*GMarshalFunc_BOOLEAN__STRING_STRING_STRING_POINTER) (gpointer     data1,
74
 
                                                                          gpointer     arg_1,
75
 
                                                                          gpointer     arg_2,
76
 
                                                                          gpointer     arg_3,
77
 
                                                                          gpointer     arg_4,
78
 
                                                                          gpointer     data2);
79
 
  register GMarshalFunc_BOOLEAN__STRING_STRING_STRING_POINTER callback;
80
 
  register GCClosure *cc = (GCClosure*) closure;
81
 
  register gpointer data1, data2;
82
 
  gboolean v_return;
83
 
 
84
 
  g_return_if_fail (return_value != NULL);
85
 
  g_return_if_fail (n_param_values == 5);
86
 
 
87
 
  if (G_CCLOSURE_SWAP_DATA (closure))
88
 
    {
89
 
      data1 = closure->data;
90
 
      data2 = g_value_peek_pointer (param_values + 0);
91
 
    }
92
 
  else
93
 
    {
94
 
      data1 = g_value_peek_pointer (param_values + 0);
95
 
      data2 = closure->data;
96
 
    }
97
 
  callback = (GMarshalFunc_BOOLEAN__STRING_STRING_STRING_POINTER) (marshal_data ? marshal_data : cc->callback);
98
 
 
99
 
  v_return = callback (data1,
100
 
                       g_marshal_value_peek_string (param_values + 1),
101
 
                       g_marshal_value_peek_string (param_values + 2),
102
 
                       g_marshal_value_peek_string (param_values + 3),
103
 
                       g_marshal_value_peek_pointer (param_values + 4),
104
 
                       data2);
105
 
 
106
 
  g_value_set_boolean (return_value, v_return);
107
 
}
108
 
 
109
 
/* BOOLEAN:DOUBLE,POINTER */
110
 
extern void dbus_glib_marshal_totem_embedded_BOOLEAN__DOUBLE_POINTER (GClosure     *closure,
111
 
                                                                      GValue       *return_value,
112
 
                                                                      guint         n_param_values,
113
 
                                                                      const GValue *param_values,
114
 
                                                                      gpointer      invocation_hint,
115
 
                                                                      gpointer      marshal_data);
116
 
void
117
 
dbus_glib_marshal_totem_embedded_BOOLEAN__DOUBLE_POINTER (GClosure     *closure,
118
 
                                                          GValue       *return_value G_GNUC_UNUSED,
119
 
                                                          guint         n_param_values,
120
 
                                                          const GValue *param_values,
121
 
                                                          gpointer      invocation_hint G_GNUC_UNUSED,
122
 
                                                          gpointer      marshal_data)
123
 
{
124
 
  typedef gboolean (*GMarshalFunc_BOOLEAN__DOUBLE_POINTER) (gpointer     data1,
125
 
                                                            gdouble      arg_1,
126
 
                                                            gpointer     arg_2,
127
 
                                                            gpointer     data2);
128
 
  register GMarshalFunc_BOOLEAN__DOUBLE_POINTER callback;
129
 
  register GCClosure *cc = (GCClosure*) closure;
130
 
  register gpointer data1, data2;
131
 
  gboolean v_return;
132
 
 
133
 
  g_return_if_fail (return_value != NULL);
134
 
  g_return_if_fail (n_param_values == 3);
135
 
 
136
 
  if (G_CCLOSURE_SWAP_DATA (closure))
137
 
    {
138
 
      data1 = closure->data;
139
 
      data2 = g_value_peek_pointer (param_values + 0);
140
 
    }
141
 
  else
142
 
    {
143
 
      data1 = g_value_peek_pointer (param_values + 0);
144
 
      data2 = closure->data;
145
 
    }
146
 
  callback = (GMarshalFunc_BOOLEAN__DOUBLE_POINTER) (marshal_data ? marshal_data : cc->callback);
147
 
 
148
 
  v_return = callback (data1,
149
 
                       g_marshal_value_peek_double (param_values + 1),
150
 
                       g_marshal_value_peek_pointer (param_values + 2),
151
 
                       data2);
152
 
 
153
 
  g_value_set_boolean (return_value, v_return);
154
 
}
155
 
 
156
 
/* BOOLEAN:STRING,UINT,INT,INT,POINTER */
157
 
extern void dbus_glib_marshal_totem_embedded_BOOLEAN__STRING_UINT_INT_INT_POINTER (GClosure     *closure,
158
 
                                                                                   GValue       *return_value,
159
 
                                                                                   guint         n_param_values,
160
 
                                                                                   const GValue *param_values,
161
 
                                                                                   gpointer      invocation_hint,
162
 
                                                                                   gpointer      marshal_data);
163
 
void
164
 
dbus_glib_marshal_totem_embedded_BOOLEAN__STRING_UINT_INT_INT_POINTER (GClosure     *closure,
165
 
                                                                       GValue       *return_value G_GNUC_UNUSED,
166
 
                                                                       guint         n_param_values,
167
 
                                                                       const GValue *param_values,
168
 
                                                                       gpointer      invocation_hint G_GNUC_UNUSED,
169
 
                                                                       gpointer      marshal_data)
170
 
{
171
 
  typedef gboolean (*GMarshalFunc_BOOLEAN__STRING_UINT_INT_INT_POINTER) (gpointer     data1,
172
 
                                                                         gpointer     arg_1,
173
 
                                                                         guint        arg_2,
174
 
                                                                         gint         arg_3,
175
 
                                                                         gint         arg_4,
176
 
                                                                         gpointer     arg_5,
177
 
                                                                         gpointer     data2);
178
 
  register GMarshalFunc_BOOLEAN__STRING_UINT_INT_INT_POINTER callback;
179
 
  register GCClosure *cc = (GCClosure*) closure;
180
 
  register gpointer data1, data2;
181
 
  gboolean v_return;
182
 
 
183
 
  g_return_if_fail (return_value != NULL);
184
 
  g_return_if_fail (n_param_values == 6);
185
 
 
186
 
  if (G_CCLOSURE_SWAP_DATA (closure))
187
 
    {
188
 
      data1 = closure->data;
189
 
      data2 = g_value_peek_pointer (param_values + 0);
190
 
    }
191
 
  else
192
 
    {
193
 
      data1 = g_value_peek_pointer (param_values + 0);
194
 
      data2 = closure->data;
195
 
    }
196
 
  callback = (GMarshalFunc_BOOLEAN__STRING_UINT_INT_INT_POINTER) (marshal_data ? marshal_data : cc->callback);
197
 
 
198
 
  v_return = callback (data1,
199
 
                       g_marshal_value_peek_string (param_values + 1),
200
 
                       g_marshal_value_peek_uint (param_values + 2),
201
 
                       g_marshal_value_peek_int (param_values + 3),
202
 
                       g_marshal_value_peek_int (param_values + 4),
203
 
                       g_marshal_value_peek_pointer (param_values + 5),
204
 
                       data2);
205
 
 
206
 
  g_value_set_boolean (return_value, v_return);
207
 
}
208
 
 
209
58
/* BOOLEAN:STRING,STRING,STRING,STRING,POINTER */
210
59
extern void dbus_glib_marshal_totem_embedded_BOOLEAN__STRING_STRING_STRING_STRING_POINTER (GClosure     *closure,
211
60
                                                                                           GValue       *return_value,
259
108
  g_value_set_boolean (return_value, v_return);
260
109
}
261
110
 
262
 
/* BOOLEAN:BOOLEAN,POINTER */
263
 
extern void dbus_glib_marshal_totem_embedded_BOOLEAN__BOOLEAN_POINTER (GClosure     *closure,
264
 
                                                                       GValue       *return_value,
 
111
/* BOOLEAN:INT64,POINTER */
 
112
extern void dbus_glib_marshal_totem_embedded_BOOLEAN__INT64_POINTER (GClosure     *closure,
 
113
                                                                     GValue       *return_value,
 
114
                                                                     guint         n_param_values,
 
115
                                                                     const GValue *param_values,
 
116
                                                                     gpointer      invocation_hint,
 
117
                                                                     gpointer      marshal_data);
 
118
void
 
119
dbus_glib_marshal_totem_embedded_BOOLEAN__INT64_POINTER (GClosure     *closure,
 
120
                                                         GValue       *return_value G_GNUC_UNUSED,
 
121
                                                         guint         n_param_values,
 
122
                                                         const GValue *param_values,
 
123
                                                         gpointer      invocation_hint G_GNUC_UNUSED,
 
124
                                                         gpointer      marshal_data)
 
125
{
 
126
  typedef gboolean (*GMarshalFunc_BOOLEAN__INT64_POINTER) (gpointer     data1,
 
127
                                                           gint64       arg_1,
 
128
                                                           gpointer     arg_2,
 
129
                                                           gpointer     data2);
 
130
  register GMarshalFunc_BOOLEAN__INT64_POINTER callback;
 
131
  register GCClosure *cc = (GCClosure*) closure;
 
132
  register gpointer data1, data2;
 
133
  gboolean v_return;
 
134
 
 
135
  g_return_if_fail (return_value != NULL);
 
136
  g_return_if_fail (n_param_values == 3);
 
137
 
 
138
  if (G_CCLOSURE_SWAP_DATA (closure))
 
139
    {
 
140
      data1 = closure->data;
 
141
      data2 = g_value_peek_pointer (param_values + 0);
 
142
    }
 
143
  else
 
144
    {
 
145
      data1 = g_value_peek_pointer (param_values + 0);
 
146
      data2 = closure->data;
 
147
    }
 
148
  callback = (GMarshalFunc_BOOLEAN__INT64_POINTER) (marshal_data ? marshal_data : cc->callback);
 
149
 
 
150
  v_return = callback (data1,
 
151
                       g_marshal_value_peek_int64 (param_values + 1),
 
152
                       g_marshal_value_peek_pointer (param_values + 2),
 
153
                       data2);
 
154
 
 
155
  g_value_set_boolean (return_value, v_return);
 
156
}
 
157
 
 
158
/* BOOLEAN:STRING,UINT,INT,INT,POINTER */
 
159
extern void dbus_glib_marshal_totem_embedded_BOOLEAN__STRING_UINT_INT_INT_POINTER (GClosure     *closure,
 
160
                                                                                   GValue       *return_value,
 
161
                                                                                   guint         n_param_values,
 
162
                                                                                   const GValue *param_values,
 
163
                                                                                   gpointer      invocation_hint,
 
164
                                                                                   gpointer      marshal_data);
 
165
void
 
166
dbus_glib_marshal_totem_embedded_BOOLEAN__STRING_UINT_INT_INT_POINTER (GClosure     *closure,
 
167
                                                                       GValue       *return_value G_GNUC_UNUSED,
265
168
                                                                       guint         n_param_values,
266
169
                                                                       const GValue *param_values,
267
 
                                                                       gpointer      invocation_hint,
268
 
                                                                       gpointer      marshal_data);
269
 
void
270
 
dbus_glib_marshal_totem_embedded_BOOLEAN__BOOLEAN_POINTER (GClosure     *closure,
271
 
                                                           GValue       *return_value G_GNUC_UNUSED,
272
 
                                                           guint         n_param_values,
273
 
                                                           const GValue *param_values,
274
 
                                                           gpointer      invocation_hint G_GNUC_UNUSED,
275
 
                                                           gpointer      marshal_data)
 
170
                                                                       gpointer      invocation_hint G_GNUC_UNUSED,
 
171
                                                                       gpointer      marshal_data)
276
172
{
277
 
  typedef gboolean (*GMarshalFunc_BOOLEAN__BOOLEAN_POINTER) (gpointer     data1,
278
 
                                                             gboolean     arg_1,
279
 
                                                             gpointer     arg_2,
280
 
                                                             gpointer     data2);
281
 
  register GMarshalFunc_BOOLEAN__BOOLEAN_POINTER callback;
 
173
  typedef gboolean (*GMarshalFunc_BOOLEAN__STRING_UINT_INT_INT_POINTER) (gpointer     data1,
 
174
                                                                         gpointer     arg_1,
 
175
                                                                         guint        arg_2,
 
176
                                                                         gint         arg_3,
 
177
                                                                         gint         arg_4,
 
178
                                                                         gpointer     arg_5,
 
179
                                                                         gpointer     data2);
 
180
  register GMarshalFunc_BOOLEAN__STRING_UINT_INT_INT_POINTER callback;
282
181
  register GCClosure *cc = (GCClosure*) closure;
283
182
  register gpointer data1, data2;
284
183
  gboolean v_return;
285
184
 
286
185
  g_return_if_fail (return_value != NULL);
287
 
  g_return_if_fail (n_param_values == 3);
 
186
  g_return_if_fail (n_param_values == 6);
288
187
 
289
188
  if (G_CCLOSURE_SWAP_DATA (closure))
290
189
    {
296
195
      data1 = g_value_peek_pointer (param_values + 0);
297
196
      data2 = closure->data;
298
197
    }
299
 
  callback = (GMarshalFunc_BOOLEAN__BOOLEAN_POINTER) (marshal_data ? marshal_data : cc->callback);
 
198
  callback = (GMarshalFunc_BOOLEAN__STRING_UINT_INT_INT_POINTER) (marshal_data ? marshal_data : cc->callback);
300
199
 
301
200
  v_return = callback (data1,
302
 
                       g_marshal_value_peek_boolean (param_values + 1),
303
 
                       g_marshal_value_peek_pointer (param_values + 2),
 
201
                       g_marshal_value_peek_string (param_values + 1),
 
202
                       g_marshal_value_peek_uint (param_values + 2),
 
203
                       g_marshal_value_peek_int (param_values + 3),
 
204
                       g_marshal_value_peek_int (param_values + 4),
 
205
                       g_marshal_value_peek_pointer (param_values + 5),
304
206
                       data2);
305
207
 
306
208
  g_value_set_boolean (return_value, v_return);
351
253
  g_value_set_boolean (return_value, v_return);
352
254
}
353
255
 
 
256
/* BOOLEAN:DOUBLE,POINTER */
 
257
extern void dbus_glib_marshal_totem_embedded_BOOLEAN__DOUBLE_POINTER (GClosure     *closure,
 
258
                                                                      GValue       *return_value,
 
259
                                                                      guint         n_param_values,
 
260
                                                                      const GValue *param_values,
 
261
                                                                      gpointer      invocation_hint,
 
262
                                                                      gpointer      marshal_data);
 
263
void
 
264
dbus_glib_marshal_totem_embedded_BOOLEAN__DOUBLE_POINTER (GClosure     *closure,
 
265
                                                          GValue       *return_value G_GNUC_UNUSED,
 
266
                                                          guint         n_param_values,
 
267
                                                          const GValue *param_values,
 
268
                                                          gpointer      invocation_hint G_GNUC_UNUSED,
 
269
                                                          gpointer      marshal_data)
 
270
{
 
271
  typedef gboolean (*GMarshalFunc_BOOLEAN__DOUBLE_POINTER) (gpointer     data1,
 
272
                                                            gdouble      arg_1,
 
273
                                                            gpointer     arg_2,
 
274
                                                            gpointer     data2);
 
275
  register GMarshalFunc_BOOLEAN__DOUBLE_POINTER callback;
 
276
  register GCClosure *cc = (GCClosure*) closure;
 
277
  register gpointer data1, data2;
 
278
  gboolean v_return;
 
279
 
 
280
  g_return_if_fail (return_value != NULL);
 
281
  g_return_if_fail (n_param_values == 3);
 
282
 
 
283
  if (G_CCLOSURE_SWAP_DATA (closure))
 
284
    {
 
285
      data1 = closure->data;
 
286
      data2 = g_value_peek_pointer (param_values + 0);
 
287
    }
 
288
  else
 
289
    {
 
290
      data1 = g_value_peek_pointer (param_values + 0);
 
291
      data2 = closure->data;
 
292
    }
 
293
  callback = (GMarshalFunc_BOOLEAN__DOUBLE_POINTER) (marshal_data ? marshal_data : cc->callback);
 
294
 
 
295
  v_return = callback (data1,
 
296
                       g_marshal_value_peek_double (param_values + 1),
 
297
                       g_marshal_value_peek_pointer (param_values + 2),
 
298
                       data2);
 
299
 
 
300
  g_value_set_boolean (return_value, v_return);
 
301
}
 
302
 
 
303
/* BOOLEAN:STRING,STRING,STRING,POINTER */
 
304
extern void dbus_glib_marshal_totem_embedded_BOOLEAN__STRING_STRING_STRING_POINTER (GClosure     *closure,
 
305
                                                                                    GValue       *return_value,
 
306
                                                                                    guint         n_param_values,
 
307
                                                                                    const GValue *param_values,
 
308
                                                                                    gpointer      invocation_hint,
 
309
                                                                                    gpointer      marshal_data);
 
310
void
 
311
dbus_glib_marshal_totem_embedded_BOOLEAN__STRING_STRING_STRING_POINTER (GClosure     *closure,
 
312
                                                                        GValue       *return_value G_GNUC_UNUSED,
 
313
                                                                        guint         n_param_values,
 
314
                                                                        const GValue *param_values,
 
315
                                                                        gpointer      invocation_hint G_GNUC_UNUSED,
 
316
                                                                        gpointer      marshal_data)
 
317
{
 
318
  typedef gboolean (*GMarshalFunc_BOOLEAN__STRING_STRING_STRING_POINTER) (gpointer     data1,
 
319
                                                                          gpointer     arg_1,
 
320
                                                                          gpointer     arg_2,
 
321
                                                                          gpointer     arg_3,
 
322
                                                                          gpointer     arg_4,
 
323
                                                                          gpointer     data2);
 
324
  register GMarshalFunc_BOOLEAN__STRING_STRING_STRING_POINTER callback;
 
325
  register GCClosure *cc = (GCClosure*) closure;
 
326
  register gpointer data1, data2;
 
327
  gboolean v_return;
 
328
 
 
329
  g_return_if_fail (return_value != NULL);
 
330
  g_return_if_fail (n_param_values == 5);
 
331
 
 
332
  if (G_CCLOSURE_SWAP_DATA (closure))
 
333
    {
 
334
      data1 = closure->data;
 
335
      data2 = g_value_peek_pointer (param_values + 0);
 
336
    }
 
337
  else
 
338
    {
 
339
      data1 = g_value_peek_pointer (param_values + 0);
 
340
      data2 = closure->data;
 
341
    }
 
342
  callback = (GMarshalFunc_BOOLEAN__STRING_STRING_STRING_POINTER) (marshal_data ? marshal_data : cc->callback);
 
343
 
 
344
  v_return = callback (data1,
 
345
                       g_marshal_value_peek_string (param_values + 1),
 
346
                       g_marshal_value_peek_string (param_values + 2),
 
347
                       g_marshal_value_peek_string (param_values + 3),
 
348
                       g_marshal_value_peek_pointer (param_values + 4),
 
349
                       data2);
 
350
 
 
351
  g_value_set_boolean (return_value, v_return);
 
352
}
 
353
 
354
354
/* BOOLEAN:STRING,UINT,POINTER */
355
355
extern void dbus_glib_marshal_totem_embedded_BOOLEAN__STRING_UINT_POINTER (GClosure     *closure,
356
356
                                                                           GValue       *return_value,
400
400
  g_value_set_boolean (return_value, v_return);
401
401
}
402
402
 
 
403
/* BOOLEAN:UINT64,POINTER */
 
404
extern void dbus_glib_marshal_totem_embedded_BOOLEAN__UINT64_POINTER (GClosure     *closure,
 
405
                                                                      GValue       *return_value,
 
406
                                                                      guint         n_param_values,
 
407
                                                                      const GValue *param_values,
 
408
                                                                      gpointer      invocation_hint,
 
409
                                                                      gpointer      marshal_data);
 
410
void
 
411
dbus_glib_marshal_totem_embedded_BOOLEAN__UINT64_POINTER (GClosure     *closure,
 
412
                                                          GValue       *return_value G_GNUC_UNUSED,
 
413
                                                          guint         n_param_values,
 
414
                                                          const GValue *param_values,
 
415
                                                          gpointer      invocation_hint G_GNUC_UNUSED,
 
416
                                                          gpointer      marshal_data)
 
417
{
 
418
  typedef gboolean (*GMarshalFunc_BOOLEAN__UINT64_POINTER) (gpointer     data1,
 
419
                                                            guint64      arg_1,
 
420
                                                            gpointer     arg_2,
 
421
                                                            gpointer     data2);
 
422
  register GMarshalFunc_BOOLEAN__UINT64_POINTER callback;
 
423
  register GCClosure *cc = (GCClosure*) closure;
 
424
  register gpointer data1, data2;
 
425
  gboolean v_return;
 
426
 
 
427
  g_return_if_fail (return_value != NULL);
 
428
  g_return_if_fail (n_param_values == 3);
 
429
 
 
430
  if (G_CCLOSURE_SWAP_DATA (closure))
 
431
    {
 
432
      data1 = closure->data;
 
433
      data2 = g_value_peek_pointer (param_values + 0);
 
434
    }
 
435
  else
 
436
    {
 
437
      data1 = g_value_peek_pointer (param_values + 0);
 
438
      data2 = closure->data;
 
439
    }
 
440
  callback = (GMarshalFunc_BOOLEAN__UINT64_POINTER) (marshal_data ? marshal_data : cc->callback);
 
441
 
 
442
  v_return = callback (data1,
 
443
                       g_marshal_value_peek_uint64 (param_values + 1),
 
444
                       g_marshal_value_peek_pointer (param_values + 2),
 
445
                       data2);
 
446
 
 
447
  g_value_set_boolean (return_value, v_return);
 
448
}
 
449
 
 
450
/* BOOLEAN:UINT,POINTER */
 
451
extern void dbus_glib_marshal_totem_embedded_BOOLEAN__UINT_POINTER (GClosure     *closure,
 
452
                                                                    GValue       *return_value,
 
453
                                                                    guint         n_param_values,
 
454
                                                                    const GValue *param_values,
 
455
                                                                    gpointer      invocation_hint,
 
456
                                                                    gpointer      marshal_data);
 
457
void
 
458
dbus_glib_marshal_totem_embedded_BOOLEAN__UINT_POINTER (GClosure     *closure,
 
459
                                                        GValue       *return_value G_GNUC_UNUSED,
 
460
                                                        guint         n_param_values,
 
461
                                                        const GValue *param_values,
 
462
                                                        gpointer      invocation_hint G_GNUC_UNUSED,
 
463
                                                        gpointer      marshal_data)
 
464
{
 
465
  typedef gboolean (*GMarshalFunc_BOOLEAN__UINT_POINTER) (gpointer     data1,
 
466
                                                          guint        arg_1,
 
467
                                                          gpointer     arg_2,
 
468
                                                          gpointer     data2);
 
469
  register GMarshalFunc_BOOLEAN__UINT_POINTER callback;
 
470
  register GCClosure *cc = (GCClosure*) closure;
 
471
  register gpointer data1, data2;
 
472
  gboolean v_return;
 
473
 
 
474
  g_return_if_fail (return_value != NULL);
 
475
  g_return_if_fail (n_param_values == 3);
 
476
 
 
477
  if (G_CCLOSURE_SWAP_DATA (closure))
 
478
    {
 
479
      data1 = closure->data;
 
480
      data2 = g_value_peek_pointer (param_values + 0);
 
481
    }
 
482
  else
 
483
    {
 
484
      data1 = g_value_peek_pointer (param_values + 0);
 
485
      data2 = closure->data;
 
486
    }
 
487
  callback = (GMarshalFunc_BOOLEAN__UINT_POINTER) (marshal_data ? marshal_data : cc->callback);
 
488
 
 
489
  v_return = callback (data1,
 
490
                       g_marshal_value_peek_uint (param_values + 1),
 
491
                       g_marshal_value_peek_pointer (param_values + 2),
 
492
                       data2);
 
493
 
 
494
  g_value_set_boolean (return_value, v_return);
 
495
}
 
496
 
403
497
/* BOOLEAN:STRING,STRING,POINTER */
404
498
extern void dbus_glib_marshal_totem_embedded_BOOLEAN__STRING_STRING_POINTER (GClosure     *closure,
405
499
                                                                             GValue       *return_value,
449
543
  g_value_set_boolean (return_value, v_return);
450
544
}
451
545
 
452
 
/* BOOLEAN:UINT,POINTER */
453
 
extern void dbus_glib_marshal_totem_embedded_BOOLEAN__UINT_POINTER (GClosure     *closure,
454
 
                                                                    GValue       *return_value,
455
 
                                                                    guint         n_param_values,
456
 
                                                                    const GValue *param_values,
457
 
                                                                    gpointer      invocation_hint,
458
 
                                                                    gpointer      marshal_data);
459
 
void
460
 
dbus_glib_marshal_totem_embedded_BOOLEAN__UINT_POINTER (GClosure     *closure,
461
 
                                                        GValue       *return_value G_GNUC_UNUSED,
462
 
                                                        guint         n_param_values,
463
 
                                                        const GValue *param_values,
464
 
                                                        gpointer      invocation_hint G_GNUC_UNUSED,
465
 
                                                        gpointer      marshal_data)
466
 
{
467
 
  typedef gboolean (*GMarshalFunc_BOOLEAN__UINT_POINTER) (gpointer     data1,
468
 
                                                          guint        arg_1,
469
 
                                                          gpointer     arg_2,
470
 
                                                          gpointer     data2);
471
 
  register GMarshalFunc_BOOLEAN__UINT_POINTER callback;
472
 
  register GCClosure *cc = (GCClosure*) closure;
473
 
  register gpointer data1, data2;
474
 
  gboolean v_return;
475
 
 
476
 
  g_return_if_fail (return_value != NULL);
477
 
  g_return_if_fail (n_param_values == 3);
478
 
 
479
 
  if (G_CCLOSURE_SWAP_DATA (closure))
480
 
    {
481
 
      data1 = closure->data;
482
 
      data2 = g_value_peek_pointer (param_values + 0);
483
 
    }
484
 
  else
485
 
    {
486
 
      data1 = g_value_peek_pointer (param_values + 0);
487
 
      data2 = closure->data;
488
 
    }
489
 
  callback = (GMarshalFunc_BOOLEAN__UINT_POINTER) (marshal_data ? marshal_data : cc->callback);
490
 
 
491
 
  v_return = callback (data1,
492
 
                       g_marshal_value_peek_uint (param_values + 1),
493
 
                       g_marshal_value_peek_pointer (param_values + 2),
494
 
                       data2);
495
 
 
496
 
  g_value_set_boolean (return_value, v_return);
497
 
}
498
 
 
499
 
/* BOOLEAN:UINT64,POINTER */
500
 
extern void dbus_glib_marshal_totem_embedded_BOOLEAN__UINT64_POINTER (GClosure     *closure,
501
 
                                                                      GValue       *return_value,
502
 
                                                                      guint         n_param_values,
503
 
                                                                      const GValue *param_values,
504
 
                                                                      gpointer      invocation_hint,
505
 
                                                                      gpointer      marshal_data);
506
 
void
507
 
dbus_glib_marshal_totem_embedded_BOOLEAN__UINT64_POINTER (GClosure     *closure,
508
 
                                                          GValue       *return_value G_GNUC_UNUSED,
509
 
                                                          guint         n_param_values,
510
 
                                                          const GValue *param_values,
511
 
                                                          gpointer      invocation_hint G_GNUC_UNUSED,
512
 
                                                          gpointer      marshal_data)
513
 
{
514
 
  typedef gboolean (*GMarshalFunc_BOOLEAN__UINT64_POINTER) (gpointer     data1,
515
 
                                                            guint64      arg_1,
516
 
                                                            gpointer     arg_2,
517
 
                                                            gpointer     data2);
518
 
  register GMarshalFunc_BOOLEAN__UINT64_POINTER callback;
519
 
  register GCClosure *cc = (GCClosure*) closure;
520
 
  register gpointer data1, data2;
521
 
  gboolean v_return;
522
 
 
523
 
  g_return_if_fail (return_value != NULL);
524
 
  g_return_if_fail (n_param_values == 3);
525
 
 
526
 
  if (G_CCLOSURE_SWAP_DATA (closure))
527
 
    {
528
 
      data1 = closure->data;
529
 
      data2 = g_value_peek_pointer (param_values + 0);
530
 
    }
531
 
  else
532
 
    {
533
 
      data1 = g_value_peek_pointer (param_values + 0);
534
 
      data2 = closure->data;
535
 
    }
536
 
  callback = (GMarshalFunc_BOOLEAN__UINT64_POINTER) (marshal_data ? marshal_data : cc->callback);
537
 
 
538
 
  v_return = callback (data1,
539
 
                       g_marshal_value_peek_uint64 (param_values + 1),
540
 
                       g_marshal_value_peek_pointer (param_values + 2),
541
 
                       data2);
542
 
 
543
 
  g_value_set_boolean (return_value, v_return);
544
 
}
545
 
 
546
 
/* BOOLEAN:INT64,POINTER */
547
 
extern void dbus_glib_marshal_totem_embedded_BOOLEAN__INT64_POINTER (GClosure     *closure,
548
 
                                                                     GValue       *return_value,
549
 
                                                                     guint         n_param_values,
550
 
                                                                     const GValue *param_values,
551
 
                                                                     gpointer      invocation_hint,
552
 
                                                                     gpointer      marshal_data);
553
 
void
554
 
dbus_glib_marshal_totem_embedded_BOOLEAN__INT64_POINTER (GClosure     *closure,
555
 
                                                         GValue       *return_value G_GNUC_UNUSED,
556
 
                                                         guint         n_param_values,
557
 
                                                         const GValue *param_values,
558
 
                                                         gpointer      invocation_hint G_GNUC_UNUSED,
559
 
                                                         gpointer      marshal_data)
560
 
{
561
 
  typedef gboolean (*GMarshalFunc_BOOLEAN__INT64_POINTER) (gpointer     data1,
562
 
                                                           gint64       arg_1,
563
 
                                                           gpointer     arg_2,
564
 
                                                           gpointer     data2);
565
 
  register GMarshalFunc_BOOLEAN__INT64_POINTER callback;
566
 
  register GCClosure *cc = (GCClosure*) closure;
567
 
  register gpointer data1, data2;
568
 
  gboolean v_return;
569
 
 
570
 
  g_return_if_fail (return_value != NULL);
571
 
  g_return_if_fail (n_param_values == 3);
572
 
 
573
 
  if (G_CCLOSURE_SWAP_DATA (closure))
574
 
    {
575
 
      data1 = closure->data;
576
 
      data2 = g_value_peek_pointer (param_values + 0);
577
 
    }
578
 
  else
579
 
    {
580
 
      data1 = g_value_peek_pointer (param_values + 0);
581
 
      data2 = closure->data;
582
 
    }
583
 
  callback = (GMarshalFunc_BOOLEAN__INT64_POINTER) (marshal_data ? marshal_data : cc->callback);
584
 
 
585
 
  v_return = callback (data1,
586
 
                       g_marshal_value_peek_int64 (param_values + 1),
587
 
                       g_marshal_value_peek_pointer (param_values + 2),
588
 
                       data2);
589
 
 
590
 
  g_value_set_boolean (return_value, v_return);
591
 
}
592
 
 
593
546
/* BOOLEAN:STRING,POINTER */
594
547
extern void dbus_glib_marshal_totem_embedded_BOOLEAN__STRING_POINTER (GClosure     *closure,
595
548
                                                                      GValue       *return_value,
637
590
  g_value_set_boolean (return_value, v_return);
638
591
}
639
592
 
 
593
/* BOOLEAN:BOOLEAN,POINTER */
 
594
extern void dbus_glib_marshal_totem_embedded_BOOLEAN__BOOLEAN_POINTER (GClosure     *closure,
 
595
                                                                       GValue       *return_value,
 
596
                                                                       guint         n_param_values,
 
597
                                                                       const GValue *param_values,
 
598
                                                                       gpointer      invocation_hint,
 
599
                                                                       gpointer      marshal_data);
 
600
void
 
601
dbus_glib_marshal_totem_embedded_BOOLEAN__BOOLEAN_POINTER (GClosure     *closure,
 
602
                                                           GValue       *return_value G_GNUC_UNUSED,
 
603
                                                           guint         n_param_values,
 
604
                                                           const GValue *param_values,
 
605
                                                           gpointer      invocation_hint G_GNUC_UNUSED,
 
606
                                                           gpointer      marshal_data)
 
607
{
 
608
  typedef gboolean (*GMarshalFunc_BOOLEAN__BOOLEAN_POINTER) (gpointer     data1,
 
609
                                                             gboolean     arg_1,
 
610
                                                             gpointer     arg_2,
 
611
                                                             gpointer     data2);
 
612
  register GMarshalFunc_BOOLEAN__BOOLEAN_POINTER callback;
 
613
  register GCClosure *cc = (GCClosure*) closure;
 
614
  register gpointer data1, data2;
 
615
  gboolean v_return;
 
616
 
 
617
  g_return_if_fail (return_value != NULL);
 
618
  g_return_if_fail (n_param_values == 3);
 
619
 
 
620
  if (G_CCLOSURE_SWAP_DATA (closure))
 
621
    {
 
622
      data1 = closure->data;
 
623
      data2 = g_value_peek_pointer (param_values + 0);
 
624
    }
 
625
  else
 
626
    {
 
627
      data1 = g_value_peek_pointer (param_values + 0);
 
628
      data2 = closure->data;
 
629
    }
 
630
  callback = (GMarshalFunc_BOOLEAN__BOOLEAN_POINTER) (marshal_data ? marshal_data : cc->callback);
 
631
 
 
632
  v_return = callback (data1,
 
633
                       g_marshal_value_peek_boolean (param_values + 1),
 
634
                       g_marshal_value_peek_pointer (param_values + 2),
 
635
                       data2);
 
636
 
 
637
  g_value_set_boolean (return_value, v_return);
 
638
}
 
639
 
640
640
G_END_DECLS
641
641
 
642
642
#endif /* __dbus_glib_marshal_totem_embedded_MARSHAL_H__ */
663
663
  { (GCallback) totem_embedded_set_time, dbus_glib_marshal_totem_embedded_BOOLEAN__UINT64_POINTER, 1032 },
664
664
};
665
665
 
666
 
const DBusGObjectInfo dbus_glib_totem_embedded_object_info = {
667
 
  0,
 
666
const DBusGObjectInfo dbus_glib_totem_embedded_object_info = {  1,
668
667
  dbus_glib_totem_embedded_methods,
669
668
  18,
670
669
"org.gnome.totem.PluginViewer\0DoCommand\0S\0Command\0I\0s\0\0org.gnome.totem.PluginViewer\0SetWindow\0S\0Controls\0I\0s\0XID\0I\0u\0Width\0I\0i\0Height\0I\0i\0\0org.gnome.totem.PluginViewer\0UnsetWindow\0S\0XID\0I\0u\0\0org.gnome.totem.PluginViewer\0SetupStream\0S\0URI\0I\0s\0BaseURI\0I\0s\0\0org.gnome.totem.PluginViewer\0OpenStream\0S\0Size\0I\0x\0\0org.gnome.totem.PluginViewer\0CloseStream\0S\0\0org.gnome.totem.PluginViewer\0OpenURI\0S\0URI\0I\0s\0BaseURI\0I\0s\0\0org.gnome.totem.PluginViewer\0SetPlaylist\0S\0Path\0I\0s\0URI\0I\0s\0BaseURI\0I\0s\0\0org.gnome.totem.PluginViewer\0SetLocalFile\0S\0Path\0I\0s\0URI\0I\0s\0BaseURI\0I\0s\0\0org.gnome.totem.PluginViewer\0SetLocalCache\0S\0Path\0I\0s\0\0org.gnome.totem.PluginViewer\0SetHref\0S\0HrefURI\0I\0s\0Target\0I\0s\0\0org.gnome.totem.PluginViewer\0SetErrorLogo\0S\0\0org.gnome.totem.PluginViewer\0LaunchPlayer\0S\0URI\0I\0s\0Time\0I\0u\0\0org.gnome.totem.PluginViewer\0SetVolume\0S\0Volume\0I\0d\0\0org.gnome.totem.PluginViewer\0ClearPlaylist\0S\0\0org.gnome.totem.PluginViewer\0AddItem\0S\0BaseURI\0I\0s\0URI\0I\0s\0Title\0I\0s\0Subtitle\0I\0s\0\0org.gnome.totem.PluginViewer\0SetFullscreen\0S\0FullscreenEnabled\0I\0b\0\0org.gnome.totem.PluginViewer\0SetTime\0S\0Time\0I\0t\0\0\0",