Audacious  $Id:Doxyfile42802007-03-2104:39:00Znenolod$
dbus-client-bindings.h
Go to the documentation of this file.
1 /* Generated by dbus-binding-tool; do not edit! */
2 
3 #include <glib.h>
4 #include <dbus/dbus-glib.h>
5 
6 G_BEGIN_DECLS
7 
8 #ifndef _DBUS_GLIB_ASYNC_DATA_FREE
9 #define _DBUS_GLIB_ASYNC_DATA_FREE
10 static
11 #ifdef G_HAVE_INLINE
12 inline
13 #endif
14 void
16 {
17  g_slice_free (DBusGAsyncData, stuff);
18 }
19 #endif
20 
21 #ifndef DBUS_GLIB_CLIENT_WRAPPERS_org_atheme_audacious
22 #define DBUS_GLIB_CLIENT_WRAPPERS_org_atheme_audacious
23 
24 static
25 #ifdef G_HAVE_INLINE
26 inline
27 #endif
28 gboolean
29 org_atheme_audacious_version (DBusGProxy *proxy, char ** OUT_version, GError **error)
30 
31 {
32  return dbus_g_proxy_call (proxy, "Version", error, G_TYPE_INVALID, G_TYPE_STRING, OUT_version, G_TYPE_INVALID);
33 }
34 
35 typedef void (*org_atheme_audacious_version_reply) (DBusGProxy *proxy, char * OUT_version, GError *error, gpointer userdata);
36 
37 static void
38 org_atheme_audacious_version_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
39 {
40  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
41  GError *error = NULL;
42  char * OUT_version;
43  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_STRING, &OUT_version, G_TYPE_INVALID);
44  (*(org_atheme_audacious_version_reply)data->cb) (proxy, OUT_version, error, data->userdata);
45  return;
46 }
47 
48 static
49 #ifdef G_HAVE_INLINE
50 inline
51 #endif
52 DBusGProxyCall*
53 org_atheme_audacious_version_async (DBusGProxy *proxy, org_atheme_audacious_version_reply callback, gpointer userdata)
54 
55 {
56  DBusGAsyncData *stuff;
57  stuff = g_slice_new (DBusGAsyncData);
58  stuff->cb = G_CALLBACK (callback);
59  stuff->userdata = userdata;
60  return dbus_g_proxy_begin_call (proxy, "Version", org_atheme_audacious_version_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
61 }
62 static
63 #ifdef G_HAVE_INLINE
64 inline
65 #endif
66 gboolean
67 org_atheme_audacious_quit (DBusGProxy *proxy, GError **error)
68 
69 {
70  return dbus_g_proxy_call (proxy, "Quit", error, G_TYPE_INVALID, G_TYPE_INVALID);
71 }
72 
73 typedef void (*org_atheme_audacious_quit_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
74 
75 static void
76 org_atheme_audacious_quit_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
77 {
78  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
79  GError *error = NULL;
80  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
81  (*(org_atheme_audacious_quit_reply)data->cb) (proxy, error, data->userdata);
82  return;
83 }
84 
85 static
86 #ifdef G_HAVE_INLINE
87 inline
88 #endif
89 DBusGProxyCall*
90 org_atheme_audacious_quit_async (DBusGProxy *proxy, org_atheme_audacious_quit_reply callback, gpointer userdata)
91 
92 {
93  DBusGAsyncData *stuff;
94  stuff = g_slice_new (DBusGAsyncData);
95  stuff->cb = G_CALLBACK (callback);
96  stuff->userdata = userdata;
97  return dbus_g_proxy_begin_call (proxy, "Quit", org_atheme_audacious_quit_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
98 }
99 static
100 #ifdef G_HAVE_INLINE
101 inline
102 #endif
103 gboolean
104 org_atheme_audacious_eject (DBusGProxy *proxy, GError **error)
105 
106 {
107  return dbus_g_proxy_call (proxy, "Eject", error, G_TYPE_INVALID, G_TYPE_INVALID);
108 }
109 
110 typedef void (*org_atheme_audacious_eject_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
111 
112 static void
113 org_atheme_audacious_eject_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
114 {
115  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
116  GError *error = NULL;
117  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
118  (*(org_atheme_audacious_eject_reply)data->cb) (proxy, error, data->userdata);
119  return;
120 }
121 
122 static
123 #ifdef G_HAVE_INLINE
124 inline
125 #endif
126 DBusGProxyCall*
127 org_atheme_audacious_eject_async (DBusGProxy *proxy, org_atheme_audacious_eject_reply callback, gpointer userdata)
128 
129 {
130  DBusGAsyncData *stuff;
131  stuff = g_slice_new (DBusGAsyncData);
132  stuff->cb = G_CALLBACK (callback);
133  stuff->userdata = userdata;
134  return dbus_g_proxy_begin_call (proxy, "Eject", org_atheme_audacious_eject_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
135 }
136 static
137 #ifdef G_HAVE_INLINE
138 inline
139 #endif
140 gboolean
141 org_atheme_audacious_main_win_visible (DBusGProxy *proxy, gboolean* OUT_is_main_win, GError **error)
142 
143 {
144  return dbus_g_proxy_call (proxy, "MainWinVisible", error, G_TYPE_INVALID, G_TYPE_BOOLEAN, OUT_is_main_win, G_TYPE_INVALID);
145 }
146 
147 typedef void (*org_atheme_audacious_main_win_visible_reply) (DBusGProxy *proxy, gboolean OUT_is_main_win, GError *error, gpointer userdata);
148 
149 static void
150 org_atheme_audacious_main_win_visible_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
151 {
152  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
153  GError *error = NULL;
154  gboolean OUT_is_main_win;
155  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_BOOLEAN, &OUT_is_main_win, G_TYPE_INVALID);
156  (*(org_atheme_audacious_main_win_visible_reply)data->cb) (proxy, OUT_is_main_win, error, data->userdata);
157  return;
158 }
159 
160 static
161 #ifdef G_HAVE_INLINE
162 inline
163 #endif
164 DBusGProxyCall*
166 
167 {
168  DBusGAsyncData *stuff;
169  stuff = g_slice_new (DBusGAsyncData);
170  stuff->cb = G_CALLBACK (callback);
171  stuff->userdata = userdata;
172  return dbus_g_proxy_begin_call (proxy, "MainWinVisible", org_atheme_audacious_main_win_visible_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
173 }
174 static
175 #ifdef G_HAVE_INLINE
176 inline
177 #endif
178 gboolean
179 org_atheme_audacious_show_main_win (DBusGProxy *proxy, const gboolean IN_show, GError **error)
180 
181 {
182  return dbus_g_proxy_call (proxy, "ShowMainWin", error, G_TYPE_BOOLEAN, IN_show, G_TYPE_INVALID, G_TYPE_INVALID);
183 }
184 
185 typedef void (*org_atheme_audacious_show_main_win_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
186 
187 static void
188 org_atheme_audacious_show_main_win_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
189 {
190  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
191  GError *error = NULL;
192  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
193  (*(org_atheme_audacious_show_main_win_reply)data->cb) (proxy, error, data->userdata);
194  return;
195 }
196 
197 static
198 #ifdef G_HAVE_INLINE
199 inline
200 #endif
201 DBusGProxyCall*
202 org_atheme_audacious_show_main_win_async (DBusGProxy *proxy, const gboolean IN_show, org_atheme_audacious_show_main_win_reply callback, gpointer userdata)
203 
204 {
205  DBusGAsyncData *stuff;
206  stuff = g_slice_new (DBusGAsyncData);
207  stuff->cb = G_CALLBACK (callback);
208  stuff->userdata = userdata;
209  return dbus_g_proxy_begin_call (proxy, "ShowMainWin", org_atheme_audacious_show_main_win_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_BOOLEAN, IN_show, G_TYPE_INVALID);
210 }
211 static
212 #ifdef G_HAVE_INLINE
213 inline
214 #endif
215 gboolean
216 org_atheme_audacious_get_tuple_fields (DBusGProxy *proxy, char *** OUT_fields, GError **error)
217 
218 {
219  return dbus_g_proxy_call (proxy, "GetTupleFields", error, G_TYPE_INVALID, G_TYPE_STRV, OUT_fields, G_TYPE_INVALID);
220 }
221 
222 typedef void (*org_atheme_audacious_get_tuple_fields_reply) (DBusGProxy *proxy, char * *OUT_fields, GError *error, gpointer userdata);
223 
224 static void
225 org_atheme_audacious_get_tuple_fields_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
226 {
227  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
228  GError *error = NULL;
229  char ** OUT_fields;
230  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_STRV, &OUT_fields, G_TYPE_INVALID);
231  (*(org_atheme_audacious_get_tuple_fields_reply)data->cb) (proxy, OUT_fields, error, data->userdata);
232  return;
233 }
234 
235 static
236 #ifdef G_HAVE_INLINE
237 inline
238 #endif
239 DBusGProxyCall*
241 
242 {
243  DBusGAsyncData *stuff;
244  stuff = g_slice_new (DBusGAsyncData);
245  stuff->cb = G_CALLBACK (callback);
246  stuff->userdata = userdata;
247  return dbus_g_proxy_begin_call (proxy, "GetTupleFields", org_atheme_audacious_get_tuple_fields_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
248 }
249 static
250 #ifdef G_HAVE_INLINE
251 inline
252 #endif
253 gboolean
254 org_atheme_audacious_play (DBusGProxy *proxy, GError **error)
255 
256 {
257  return dbus_g_proxy_call (proxy, "Play", error, G_TYPE_INVALID, G_TYPE_INVALID);
258 }
259 
260 typedef void (*org_atheme_audacious_play_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
261 
262 static void
263 org_atheme_audacious_play_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
264 {
265  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
266  GError *error = NULL;
267  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
268  (*(org_atheme_audacious_play_reply)data->cb) (proxy, error, data->userdata);
269  return;
270 }
271 
272 static
273 #ifdef G_HAVE_INLINE
274 inline
275 #endif
276 DBusGProxyCall*
277 org_atheme_audacious_play_async (DBusGProxy *proxy, org_atheme_audacious_play_reply callback, gpointer userdata)
278 
279 {
280  DBusGAsyncData *stuff;
281  stuff = g_slice_new (DBusGAsyncData);
282  stuff->cb = G_CALLBACK (callback);
283  stuff->userdata = userdata;
284  return dbus_g_proxy_begin_call (proxy, "Play", org_atheme_audacious_play_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
285 }
286 static
287 #ifdef G_HAVE_INLINE
288 inline
289 #endif
290 gboolean
291 org_atheme_audacious_pause (DBusGProxy *proxy, GError **error)
292 
293 {
294  return dbus_g_proxy_call (proxy, "Pause", error, G_TYPE_INVALID, G_TYPE_INVALID);
295 }
296 
297 typedef void (*org_atheme_audacious_pause_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
298 
299 static void
300 org_atheme_audacious_pause_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
301 {
302  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
303  GError *error = NULL;
304  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
305  (*(org_atheme_audacious_pause_reply)data->cb) (proxy, error, data->userdata);
306  return;
307 }
308 
309 static
310 #ifdef G_HAVE_INLINE
311 inline
312 #endif
313 DBusGProxyCall*
314 org_atheme_audacious_pause_async (DBusGProxy *proxy, org_atheme_audacious_pause_reply callback, gpointer userdata)
315 
316 {
317  DBusGAsyncData *stuff;
318  stuff = g_slice_new (DBusGAsyncData);
319  stuff->cb = G_CALLBACK (callback);
320  stuff->userdata = userdata;
321  return dbus_g_proxy_begin_call (proxy, "Pause", org_atheme_audacious_pause_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
322 }
323 static
324 #ifdef G_HAVE_INLINE
325 inline
326 #endif
327 gboolean
328 org_atheme_audacious_stop (DBusGProxy *proxy, GError **error)
329 
330 {
331  return dbus_g_proxy_call (proxy, "Stop", error, G_TYPE_INVALID, G_TYPE_INVALID);
332 }
333 
334 typedef void (*org_atheme_audacious_stop_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
335 
336 static void
337 org_atheme_audacious_stop_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
338 {
339  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
340  GError *error = NULL;
341  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
342  (*(org_atheme_audacious_stop_reply)data->cb) (proxy, error, data->userdata);
343  return;
344 }
345 
346 static
347 #ifdef G_HAVE_INLINE
348 inline
349 #endif
350 DBusGProxyCall*
351 org_atheme_audacious_stop_async (DBusGProxy *proxy, org_atheme_audacious_stop_reply callback, gpointer userdata)
352 
353 {
354  DBusGAsyncData *stuff;
355  stuff = g_slice_new (DBusGAsyncData);
356  stuff->cb = G_CALLBACK (callback);
357  stuff->userdata = userdata;
358  return dbus_g_proxy_begin_call (proxy, "Stop", org_atheme_audacious_stop_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
359 }
360 static
361 #ifdef G_HAVE_INLINE
362 inline
363 #endif
364 gboolean
365 org_atheme_audacious_playing (DBusGProxy *proxy, gboolean* OUT_is_playing, GError **error)
366 
367 {
368  return dbus_g_proxy_call (proxy, "Playing", error, G_TYPE_INVALID, G_TYPE_BOOLEAN, OUT_is_playing, G_TYPE_INVALID);
369 }
370 
371 typedef void (*org_atheme_audacious_playing_reply) (DBusGProxy *proxy, gboolean OUT_is_playing, GError *error, gpointer userdata);
372 
373 static void
374 org_atheme_audacious_playing_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
375 {
376  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
377  GError *error = NULL;
378  gboolean OUT_is_playing;
379  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_BOOLEAN, &OUT_is_playing, G_TYPE_INVALID);
380  (*(org_atheme_audacious_playing_reply)data->cb) (proxy, OUT_is_playing, error, data->userdata);
381  return;
382 }
383 
384 static
385 #ifdef G_HAVE_INLINE
386 inline
387 #endif
388 DBusGProxyCall*
389 org_atheme_audacious_playing_async (DBusGProxy *proxy, org_atheme_audacious_playing_reply callback, gpointer userdata)
390 
391 {
392  DBusGAsyncData *stuff;
393  stuff = g_slice_new (DBusGAsyncData);
394  stuff->cb = G_CALLBACK (callback);
395  stuff->userdata = userdata;
396  return dbus_g_proxy_begin_call (proxy, "Playing", org_atheme_audacious_playing_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
397 }
398 static
399 #ifdef G_HAVE_INLINE
400 inline
401 #endif
402 gboolean
403 org_atheme_audacious_paused (DBusGProxy *proxy, gboolean* OUT_is_paused, GError **error)
404 
405 {
406  return dbus_g_proxy_call (proxy, "Paused", error, G_TYPE_INVALID, G_TYPE_BOOLEAN, OUT_is_paused, G_TYPE_INVALID);
407 }
408 
409 typedef void (*org_atheme_audacious_paused_reply) (DBusGProxy *proxy, gboolean OUT_is_paused, GError *error, gpointer userdata);
410 
411 static void
412 org_atheme_audacious_paused_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
413 {
414  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
415  GError *error = NULL;
416  gboolean OUT_is_paused;
417  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_BOOLEAN, &OUT_is_paused, G_TYPE_INVALID);
418  (*(org_atheme_audacious_paused_reply)data->cb) (proxy, OUT_is_paused, error, data->userdata);
419  return;
420 }
421 
422 static
423 #ifdef G_HAVE_INLINE
424 inline
425 #endif
426 DBusGProxyCall*
427 org_atheme_audacious_paused_async (DBusGProxy *proxy, org_atheme_audacious_paused_reply callback, gpointer userdata)
428 
429 {
430  DBusGAsyncData *stuff;
431  stuff = g_slice_new (DBusGAsyncData);
432  stuff->cb = G_CALLBACK (callback);
433  stuff->userdata = userdata;
434  return dbus_g_proxy_begin_call (proxy, "Paused", org_atheme_audacious_paused_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
435 }
436 static
437 #ifdef G_HAVE_INLINE
438 inline
439 #endif
440 gboolean
441 org_atheme_audacious_stopped (DBusGProxy *proxy, gboolean* OUT_is_stopped, GError **error)
442 
443 {
444  return dbus_g_proxy_call (proxy, "Stopped", error, G_TYPE_INVALID, G_TYPE_BOOLEAN, OUT_is_stopped, G_TYPE_INVALID);
445 }
446 
447 typedef void (*org_atheme_audacious_stopped_reply) (DBusGProxy *proxy, gboolean OUT_is_stopped, GError *error, gpointer userdata);
448 
449 static void
450 org_atheme_audacious_stopped_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
451 {
452  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
453  GError *error = NULL;
454  gboolean OUT_is_stopped;
455  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_BOOLEAN, &OUT_is_stopped, G_TYPE_INVALID);
456  (*(org_atheme_audacious_stopped_reply)data->cb) (proxy, OUT_is_stopped, error, data->userdata);
457  return;
458 }
459 
460 static
461 #ifdef G_HAVE_INLINE
462 inline
463 #endif
464 DBusGProxyCall*
465 org_atheme_audacious_stopped_async (DBusGProxy *proxy, org_atheme_audacious_stopped_reply callback, gpointer userdata)
466 
467 {
468  DBusGAsyncData *stuff;
469  stuff = g_slice_new (DBusGAsyncData);
470  stuff->cb = G_CALLBACK (callback);
471  stuff->userdata = userdata;
472  return dbus_g_proxy_begin_call (proxy, "Stopped", org_atheme_audacious_stopped_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
473 }
474 static
475 #ifdef G_HAVE_INLINE
476 inline
477 #endif
478 gboolean
479 org_atheme_audacious_status (DBusGProxy *proxy, char ** OUT_status, GError **error)
480 
481 {
482  return dbus_g_proxy_call (proxy, "Status", error, G_TYPE_INVALID, G_TYPE_STRING, OUT_status, G_TYPE_INVALID);
483 }
484 
485 typedef void (*org_atheme_audacious_status_reply) (DBusGProxy *proxy, char * OUT_status, GError *error, gpointer userdata);
486 
487 static void
488 org_atheme_audacious_status_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
489 {
490  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
491  GError *error = NULL;
492  char * OUT_status;
493  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_STRING, &OUT_status, G_TYPE_INVALID);
494  (*(org_atheme_audacious_status_reply)data->cb) (proxy, OUT_status, error, data->userdata);
495  return;
496 }
497 
498 static
499 #ifdef G_HAVE_INLINE
500 inline
501 #endif
502 DBusGProxyCall*
503 org_atheme_audacious_status_async (DBusGProxy *proxy, org_atheme_audacious_status_reply callback, gpointer userdata)
504 
505 {
506  DBusGAsyncData *stuff;
507  stuff = g_slice_new (DBusGAsyncData);
508  stuff->cb = G_CALLBACK (callback);
509  stuff->userdata = userdata;
510  return dbus_g_proxy_begin_call (proxy, "Status", org_atheme_audacious_status_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
511 }
512 static
513 #ifdef G_HAVE_INLINE
514 inline
515 #endif
516 gboolean
517 org_atheme_audacious_info (DBusGProxy *proxy, gint* OUT_rate, gint* OUT_freq, gint* OUT_nch, GError **error)
518 
519 {
520  return dbus_g_proxy_call (proxy, "Info", error, G_TYPE_INVALID, G_TYPE_INT, OUT_rate, G_TYPE_INT, OUT_freq, G_TYPE_INT, OUT_nch, G_TYPE_INVALID);
521 }
522 
523 typedef void (*org_atheme_audacious_info_reply) (DBusGProxy *proxy, gint OUT_rate, gint OUT_freq, gint OUT_nch, GError *error, gpointer userdata);
524 
525 static void
526 org_atheme_audacious_info_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
527 {
528  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
529  GError *error = NULL;
530  gint OUT_rate;
531  gint OUT_freq;
532  gint OUT_nch;
533  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INT, &OUT_rate, G_TYPE_INT, &OUT_freq, G_TYPE_INT, &OUT_nch, G_TYPE_INVALID);
534  (*(org_atheme_audacious_info_reply)data->cb) (proxy, OUT_rate, OUT_freq, OUT_nch, error, data->userdata);
535  return;
536 }
537 
538 static
539 #ifdef G_HAVE_INLINE
540 inline
541 #endif
542 DBusGProxyCall*
543 org_atheme_audacious_info_async (DBusGProxy *proxy, org_atheme_audacious_info_reply callback, gpointer userdata)
544 
545 {
546  DBusGAsyncData *stuff;
547  stuff = g_slice_new (DBusGAsyncData);
548  stuff->cb = G_CALLBACK (callback);
549  stuff->userdata = userdata;
550  return dbus_g_proxy_begin_call (proxy, "Info", org_atheme_audacious_info_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
551 }
552 static
553 #ifdef G_HAVE_INLINE
554 inline
555 #endif
556 gboolean
557 org_atheme_audacious_time (DBusGProxy *proxy, guint* OUT_time, GError **error)
558 
559 {
560  return dbus_g_proxy_call (proxy, "Time", error, G_TYPE_INVALID, G_TYPE_UINT, OUT_time, G_TYPE_INVALID);
561 }
562 
563 typedef void (*org_atheme_audacious_time_reply) (DBusGProxy *proxy, guint OUT_time, GError *error, gpointer userdata);
564 
565 static void
566 org_atheme_audacious_time_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
567 {
568  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
569  GError *error = NULL;
570  guint OUT_time;
571  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_UINT, &OUT_time, G_TYPE_INVALID);
572  (*(org_atheme_audacious_time_reply)data->cb) (proxy, OUT_time, error, data->userdata);
573  return;
574 }
575 
576 static
577 #ifdef G_HAVE_INLINE
578 inline
579 #endif
580 DBusGProxyCall*
581 org_atheme_audacious_time_async (DBusGProxy *proxy, org_atheme_audacious_time_reply callback, gpointer userdata)
582 
583 {
584  DBusGAsyncData *stuff;
585  stuff = g_slice_new (DBusGAsyncData);
586  stuff->cb = G_CALLBACK (callback);
587  stuff->userdata = userdata;
588  return dbus_g_proxy_begin_call (proxy, "Time", org_atheme_audacious_time_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
589 }
590 static
591 #ifdef G_HAVE_INLINE
592 inline
593 #endif
594 gboolean
595 org_atheme_audacious_seek (DBusGProxy *proxy, const guint IN_pos, GError **error)
596 
597 {
598  return dbus_g_proxy_call (proxy, "Seek", error, G_TYPE_UINT, IN_pos, G_TYPE_INVALID, G_TYPE_INVALID);
599 }
600 
601 typedef void (*org_atheme_audacious_seek_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
602 
603 static void
604 org_atheme_audacious_seek_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
605 {
606  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
607  GError *error = NULL;
608  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
609  (*(org_atheme_audacious_seek_reply)data->cb) (proxy, error, data->userdata);
610  return;
611 }
612 
613 static
614 #ifdef G_HAVE_INLINE
615 inline
616 #endif
617 DBusGProxyCall*
618 org_atheme_audacious_seek_async (DBusGProxy *proxy, const guint IN_pos, org_atheme_audacious_seek_reply callback, gpointer userdata)
619 
620 {
621  DBusGAsyncData *stuff;
622  stuff = g_slice_new (DBusGAsyncData);
623  stuff->cb = G_CALLBACK (callback);
624  stuff->userdata = userdata;
625  return dbus_g_proxy_begin_call (proxy, "Seek", org_atheme_audacious_seek_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_UINT, IN_pos, G_TYPE_INVALID);
626 }
627 static
628 #ifdef G_HAVE_INLINE
629 inline
630 #endif
631 gboolean
632 org_atheme_audacious_volume (DBusGProxy *proxy, gint* OUT_vl, gint* OUT_vr, GError **error)
633 
634 {
635  return dbus_g_proxy_call (proxy, "Volume", error, G_TYPE_INVALID, G_TYPE_INT, OUT_vl, G_TYPE_INT, OUT_vr, G_TYPE_INVALID);
636 }
637 
638 typedef void (*org_atheme_audacious_volume_reply) (DBusGProxy *proxy, gint OUT_vl, gint OUT_vr, GError *error, gpointer userdata);
639 
640 static void
641 org_atheme_audacious_volume_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
642 {
643  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
644  GError *error = NULL;
645  gint OUT_vl;
646  gint OUT_vr;
647  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INT, &OUT_vl, G_TYPE_INT, &OUT_vr, G_TYPE_INVALID);
648  (*(org_atheme_audacious_volume_reply)data->cb) (proxy, OUT_vl, OUT_vr, error, data->userdata);
649  return;
650 }
651 
652 static
653 #ifdef G_HAVE_INLINE
654 inline
655 #endif
656 DBusGProxyCall*
657 org_atheme_audacious_volume_async (DBusGProxy *proxy, org_atheme_audacious_volume_reply callback, gpointer userdata)
658 
659 {
660  DBusGAsyncData *stuff;
661  stuff = g_slice_new (DBusGAsyncData);
662  stuff->cb = G_CALLBACK (callback);
663  stuff->userdata = userdata;
664  return dbus_g_proxy_begin_call (proxy, "Volume", org_atheme_audacious_volume_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
665 }
666 static
667 #ifdef G_HAVE_INLINE
668 inline
669 #endif
670 gboolean
671 org_atheme_audacious_set_volume (DBusGProxy *proxy, const gint IN_vl, const gint IN_vr, GError **error)
672 
673 {
674  return dbus_g_proxy_call (proxy, "SetVolume", error, G_TYPE_INT, IN_vl, G_TYPE_INT, IN_vr, G_TYPE_INVALID, G_TYPE_INVALID);
675 }
676 
677 typedef void (*org_atheme_audacious_set_volume_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
678 
679 static void
680 org_atheme_audacious_set_volume_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
681 {
682  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
683  GError *error = NULL;
684  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
685  (*(org_atheme_audacious_set_volume_reply)data->cb) (proxy, error, data->userdata);
686  return;
687 }
688 
689 static
690 #ifdef G_HAVE_INLINE
691 inline
692 #endif
693 DBusGProxyCall*
694 org_atheme_audacious_set_volume_async (DBusGProxy *proxy, const gint IN_vl, const gint IN_vr, org_atheme_audacious_set_volume_reply callback, gpointer userdata)
695 
696 {
697  DBusGAsyncData *stuff;
698  stuff = g_slice_new (DBusGAsyncData);
699  stuff->cb = G_CALLBACK (callback);
700  stuff->userdata = userdata;
701  return dbus_g_proxy_begin_call (proxy, "SetVolume", org_atheme_audacious_set_volume_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INT, IN_vl, G_TYPE_INT, IN_vr, G_TYPE_INVALID);
702 }
703 static
704 #ifdef G_HAVE_INLINE
705 inline
706 #endif
707 gboolean
708 org_atheme_audacious_balance (DBusGProxy *proxy, gint* OUT_balance, GError **error)
709 
710 {
711  return dbus_g_proxy_call (proxy, "Balance", error, G_TYPE_INVALID, G_TYPE_INT, OUT_balance, G_TYPE_INVALID);
712 }
713 
714 typedef void (*org_atheme_audacious_balance_reply) (DBusGProxy *proxy, gint OUT_balance, GError *error, gpointer userdata);
715 
716 static void
717 org_atheme_audacious_balance_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
718 {
719  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
720  GError *error = NULL;
721  gint OUT_balance;
722  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INT, &OUT_balance, G_TYPE_INVALID);
723  (*(org_atheme_audacious_balance_reply)data->cb) (proxy, OUT_balance, error, data->userdata);
724  return;
725 }
726 
727 static
728 #ifdef G_HAVE_INLINE
729 inline
730 #endif
731 DBusGProxyCall*
732 org_atheme_audacious_balance_async (DBusGProxy *proxy, org_atheme_audacious_balance_reply callback, gpointer userdata)
733 
734 {
735  DBusGAsyncData *stuff;
736  stuff = g_slice_new (DBusGAsyncData);
737  stuff->cb = G_CALLBACK (callback);
738  stuff->userdata = userdata;
739  return dbus_g_proxy_begin_call (proxy, "Balance", org_atheme_audacious_balance_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
740 }
741 static
742 #ifdef G_HAVE_INLINE
743 inline
744 #endif
745 gboolean
746 org_atheme_audacious_position (DBusGProxy *proxy, guint* OUT_pos, GError **error)
747 
748 {
749  return dbus_g_proxy_call (proxy, "Position", error, G_TYPE_INVALID, G_TYPE_UINT, OUT_pos, G_TYPE_INVALID);
750 }
751 
752 typedef void (*org_atheme_audacious_position_reply) (DBusGProxy *proxy, guint OUT_pos, GError *error, gpointer userdata);
753 
754 static void
755 org_atheme_audacious_position_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
756 {
757  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
758  GError *error = NULL;
759  guint OUT_pos;
760  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_UINT, &OUT_pos, G_TYPE_INVALID);
761  (*(org_atheme_audacious_position_reply)data->cb) (proxy, OUT_pos, error, data->userdata);
762  return;
763 }
764 
765 static
766 #ifdef G_HAVE_INLINE
767 inline
768 #endif
769 DBusGProxyCall*
770 org_atheme_audacious_position_async (DBusGProxy *proxy, org_atheme_audacious_position_reply callback, gpointer userdata)
771 
772 {
773  DBusGAsyncData *stuff;
774  stuff = g_slice_new (DBusGAsyncData);
775  stuff->cb = G_CALLBACK (callback);
776  stuff->userdata = userdata;
777  return dbus_g_proxy_begin_call (proxy, "Position", org_atheme_audacious_position_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
778 }
779 static
780 #ifdef G_HAVE_INLINE
781 inline
782 #endif
783 gboolean
784 org_atheme_audacious_advance (DBusGProxy *proxy, GError **error)
785 
786 {
787  return dbus_g_proxy_call (proxy, "Advance", error, G_TYPE_INVALID, G_TYPE_INVALID);
788 }
789 
790 typedef void (*org_atheme_audacious_advance_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
791 
792 static void
793 org_atheme_audacious_advance_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
794 {
795  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
796  GError *error = NULL;
797  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
798  (*(org_atheme_audacious_advance_reply)data->cb) (proxy, error, data->userdata);
799  return;
800 }
801 
802 static
803 #ifdef G_HAVE_INLINE
804 inline
805 #endif
806 DBusGProxyCall*
807 org_atheme_audacious_advance_async (DBusGProxy *proxy, org_atheme_audacious_advance_reply callback, gpointer userdata)
808 
809 {
810  DBusGAsyncData *stuff;
811  stuff = g_slice_new (DBusGAsyncData);
812  stuff->cb = G_CALLBACK (callback);
813  stuff->userdata = userdata;
814  return dbus_g_proxy_begin_call (proxy, "Advance", org_atheme_audacious_advance_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
815 }
816 static
817 #ifdef G_HAVE_INLINE
818 inline
819 #endif
820 gboolean
821 org_atheme_audacious_reverse (DBusGProxy *proxy, GError **error)
822 
823 {
824  return dbus_g_proxy_call (proxy, "Reverse", error, G_TYPE_INVALID, G_TYPE_INVALID);
825 }
826 
827 typedef void (*org_atheme_audacious_reverse_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
828 
829 static void
830 org_atheme_audacious_reverse_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
831 {
832  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
833  GError *error = NULL;
834  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
835  (*(org_atheme_audacious_reverse_reply)data->cb) (proxy, error, data->userdata);
836  return;
837 }
838 
839 static
840 #ifdef G_HAVE_INLINE
841 inline
842 #endif
843 DBusGProxyCall*
844 org_atheme_audacious_reverse_async (DBusGProxy *proxy, org_atheme_audacious_reverse_reply callback, gpointer userdata)
845 
846 {
847  DBusGAsyncData *stuff;
848  stuff = g_slice_new (DBusGAsyncData);
849  stuff->cb = G_CALLBACK (callback);
850  stuff->userdata = userdata;
851  return dbus_g_proxy_begin_call (proxy, "Reverse", org_atheme_audacious_reverse_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
852 }
853 static
854 #ifdef G_HAVE_INLINE
855 inline
856 #endif
857 gboolean
858 org_atheme_audacious_length (DBusGProxy *proxy, gint* OUT_length, GError **error)
859 
860 {
861  return dbus_g_proxy_call (proxy, "Length", error, G_TYPE_INVALID, G_TYPE_INT, OUT_length, G_TYPE_INVALID);
862 }
863 
864 typedef void (*org_atheme_audacious_length_reply) (DBusGProxy *proxy, gint OUT_length, GError *error, gpointer userdata);
865 
866 static void
867 org_atheme_audacious_length_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
868 {
869  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
870  GError *error = NULL;
871  gint OUT_length;
872  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INT, &OUT_length, G_TYPE_INVALID);
873  (*(org_atheme_audacious_length_reply)data->cb) (proxy, OUT_length, error, data->userdata);
874  return;
875 }
876 
877 static
878 #ifdef G_HAVE_INLINE
879 inline
880 #endif
881 DBusGProxyCall*
882 org_atheme_audacious_length_async (DBusGProxy *proxy, org_atheme_audacious_length_reply callback, gpointer userdata)
883 
884 {
885  DBusGAsyncData *stuff;
886  stuff = g_slice_new (DBusGAsyncData);
887  stuff->cb = G_CALLBACK (callback);
888  stuff->userdata = userdata;
889  return dbus_g_proxy_begin_call (proxy, "Length", org_atheme_audacious_length_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
890 }
891 static
892 #ifdef G_HAVE_INLINE
893 inline
894 #endif
895 gboolean
896 org_atheme_audacious_song_title (DBusGProxy *proxy, const guint IN_pos, char ** OUT_title, GError **error)
897 
898 {
899  return dbus_g_proxy_call (proxy, "SongTitle", error, G_TYPE_UINT, IN_pos, G_TYPE_INVALID, G_TYPE_STRING, OUT_title, G_TYPE_INVALID);
900 }
901 
902 typedef void (*org_atheme_audacious_song_title_reply) (DBusGProxy *proxy, char * OUT_title, GError *error, gpointer userdata);
903 
904 static void
905 org_atheme_audacious_song_title_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
906 {
907  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
908  GError *error = NULL;
909  char * OUT_title;
910  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_STRING, &OUT_title, G_TYPE_INVALID);
911  (*(org_atheme_audacious_song_title_reply)data->cb) (proxy, OUT_title, error, data->userdata);
912  return;
913 }
914 
915 static
916 #ifdef G_HAVE_INLINE
917 inline
918 #endif
919 DBusGProxyCall*
920 org_atheme_audacious_song_title_async (DBusGProxy *proxy, const guint IN_pos, org_atheme_audacious_song_title_reply callback, gpointer userdata)
921 
922 {
923  DBusGAsyncData *stuff;
924  stuff = g_slice_new (DBusGAsyncData);
925  stuff->cb = G_CALLBACK (callback);
926  stuff->userdata = userdata;
927  return dbus_g_proxy_begin_call (proxy, "SongTitle", org_atheme_audacious_song_title_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_UINT, IN_pos, G_TYPE_INVALID);
928 }
929 static
930 #ifdef G_HAVE_INLINE
931 inline
932 #endif
933 gboolean
934 org_atheme_audacious_song_filename (DBusGProxy *proxy, const guint IN_pos, char ** OUT_filename, GError **error)
935 
936 {
937  return dbus_g_proxy_call (proxy, "SongFilename", error, G_TYPE_UINT, IN_pos, G_TYPE_INVALID, G_TYPE_STRING, OUT_filename, G_TYPE_INVALID);
938 }
939 
940 typedef void (*org_atheme_audacious_song_filename_reply) (DBusGProxy *proxy, char * OUT_filename, GError *error, gpointer userdata);
941 
942 static void
943 org_atheme_audacious_song_filename_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
944 {
945  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
946  GError *error = NULL;
947  char * OUT_filename;
948  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_STRING, &OUT_filename, G_TYPE_INVALID);
949  (*(org_atheme_audacious_song_filename_reply)data->cb) (proxy, OUT_filename, error, data->userdata);
950  return;
951 }
952 
953 static
954 #ifdef G_HAVE_INLINE
955 inline
956 #endif
957 DBusGProxyCall*
958 org_atheme_audacious_song_filename_async (DBusGProxy *proxy, const guint IN_pos, org_atheme_audacious_song_filename_reply callback, gpointer userdata)
959 
960 {
961  DBusGAsyncData *stuff;
962  stuff = g_slice_new (DBusGAsyncData);
963  stuff->cb = G_CALLBACK (callback);
964  stuff->userdata = userdata;
965  return dbus_g_proxy_begin_call (proxy, "SongFilename", org_atheme_audacious_song_filename_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_UINT, IN_pos, G_TYPE_INVALID);
966 }
967 static
968 #ifdef G_HAVE_INLINE
969 inline
970 #endif
971 gboolean
972 org_atheme_audacious_song_length (DBusGProxy *proxy, const guint IN_pos, gint* OUT_length, GError **error)
973 
974 {
975  return dbus_g_proxy_call (proxy, "SongLength", error, G_TYPE_UINT, IN_pos, G_TYPE_INVALID, G_TYPE_INT, OUT_length, G_TYPE_INVALID);
976 }
977 
978 typedef void (*org_atheme_audacious_song_length_reply) (DBusGProxy *proxy, gint OUT_length, GError *error, gpointer userdata);
979 
980 static void
981 org_atheme_audacious_song_length_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
982 {
983  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
984  GError *error = NULL;
985  gint OUT_length;
986  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INT, &OUT_length, G_TYPE_INVALID);
987  (*(org_atheme_audacious_song_length_reply)data->cb) (proxy, OUT_length, error, data->userdata);
988  return;
989 }
990 
991 static
992 #ifdef G_HAVE_INLINE
993 inline
994 #endif
995 DBusGProxyCall*
996 org_atheme_audacious_song_length_async (DBusGProxy *proxy, const guint IN_pos, org_atheme_audacious_song_length_reply callback, gpointer userdata)
997 
998 {
999  DBusGAsyncData *stuff;
1000  stuff = g_slice_new (DBusGAsyncData);
1001  stuff->cb = G_CALLBACK (callback);
1002  stuff->userdata = userdata;
1003  return dbus_g_proxy_begin_call (proxy, "SongLength", org_atheme_audacious_song_length_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_UINT, IN_pos, G_TYPE_INVALID);
1004 }
1005 static
1006 #ifdef G_HAVE_INLINE
1007 inline
1008 #endif
1009 gboolean
1010 org_atheme_audacious_song_frames (DBusGProxy *proxy, const guint IN_pos, gint* OUT_length, GError **error)
1011 
1012 {
1013  return dbus_g_proxy_call (proxy, "SongFrames", error, G_TYPE_UINT, IN_pos, G_TYPE_INVALID, G_TYPE_INT, OUT_length, G_TYPE_INVALID);
1014 }
1015 
1016 typedef void (*org_atheme_audacious_song_frames_reply) (DBusGProxy *proxy, gint OUT_length, GError *error, gpointer userdata);
1017 
1018 static void
1019 org_atheme_audacious_song_frames_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
1020 {
1021  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
1022  GError *error = NULL;
1023  gint OUT_length;
1024  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INT, &OUT_length, G_TYPE_INVALID);
1025  (*(org_atheme_audacious_song_frames_reply)data->cb) (proxy, OUT_length, error, data->userdata);
1026  return;
1027 }
1028 
1029 static
1030 #ifdef G_HAVE_INLINE
1031 inline
1032 #endif
1033 DBusGProxyCall*
1034 org_atheme_audacious_song_frames_async (DBusGProxy *proxy, const guint IN_pos, org_atheme_audacious_song_frames_reply callback, gpointer userdata)
1035 
1036 {
1037  DBusGAsyncData *stuff;
1038  stuff = g_slice_new (DBusGAsyncData);
1039  stuff->cb = G_CALLBACK (callback);
1040  stuff->userdata = userdata;
1041  return dbus_g_proxy_begin_call (proxy, "SongFrames", org_atheme_audacious_song_frames_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_UINT, IN_pos, G_TYPE_INVALID);
1042 }
1043 static
1044 #ifdef G_HAVE_INLINE
1045 inline
1046 #endif
1047 gboolean
1048 org_atheme_audacious_song_tuple (DBusGProxy *proxy, const guint IN_pos, const char * IN_tuple, GValue* OUT_value, GError **error)
1049 
1050 {
1051  return dbus_g_proxy_call (proxy, "SongTuple", error, G_TYPE_UINT, IN_pos, G_TYPE_STRING, IN_tuple, G_TYPE_INVALID, G_TYPE_VALUE, OUT_value, G_TYPE_INVALID);
1052 }
1053 
1054 typedef void (*org_atheme_audacious_song_tuple_reply) (DBusGProxy *proxy, GValue OUT_value, GError *error, gpointer userdata);
1055 
1056 static void
1057 org_atheme_audacious_song_tuple_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
1058 {
1059  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
1060  GError *error = NULL;
1061  GValue OUT_value = { 0, };
1062  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_VALUE, &OUT_value, G_TYPE_INVALID);
1063  (*(org_atheme_audacious_song_tuple_reply)data->cb) (proxy, OUT_value, error, data->userdata);
1064  return;
1065 }
1066 
1067 static
1068 #ifdef G_HAVE_INLINE
1069 inline
1070 #endif
1071 DBusGProxyCall*
1072 org_atheme_audacious_song_tuple_async (DBusGProxy *proxy, const guint IN_pos, const char * IN_tuple, org_atheme_audacious_song_tuple_reply callback, gpointer userdata)
1073 
1074 {
1075  DBusGAsyncData *stuff;
1076  stuff = g_slice_new (DBusGAsyncData);
1077  stuff->cb = G_CALLBACK (callback);
1078  stuff->userdata = userdata;
1079  return dbus_g_proxy_begin_call (proxy, "SongTuple", org_atheme_audacious_song_tuple_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_UINT, IN_pos, G_TYPE_STRING, IN_tuple, G_TYPE_INVALID);
1080 }
1081 static
1082 #ifdef G_HAVE_INLINE
1083 inline
1084 #endif
1085 gboolean
1086 org_atheme_audacious_jump (DBusGProxy *proxy, const guint IN_pos, GError **error)
1087 
1088 {
1089  return dbus_g_proxy_call (proxy, "Jump", error, G_TYPE_UINT, IN_pos, G_TYPE_INVALID, G_TYPE_INVALID);
1090 }
1091 
1092 typedef void (*org_atheme_audacious_jump_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
1093 
1094 static void
1095 org_atheme_audacious_jump_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
1096 {
1097  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
1098  GError *error = NULL;
1099  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
1100  (*(org_atheme_audacious_jump_reply)data->cb) (proxy, error, data->userdata);
1101  return;
1102 }
1103 
1104 static
1105 #ifdef G_HAVE_INLINE
1106 inline
1107 #endif
1108 DBusGProxyCall*
1109 org_atheme_audacious_jump_async (DBusGProxy *proxy, const guint IN_pos, org_atheme_audacious_jump_reply callback, gpointer userdata)
1110 
1111 {
1112  DBusGAsyncData *stuff;
1113  stuff = g_slice_new (DBusGAsyncData);
1114  stuff->cb = G_CALLBACK (callback);
1115  stuff->userdata = userdata;
1116  return dbus_g_proxy_begin_call (proxy, "Jump", org_atheme_audacious_jump_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_UINT, IN_pos, G_TYPE_INVALID);
1117 }
1118 static
1119 #ifdef G_HAVE_INLINE
1120 inline
1121 #endif
1122 gboolean
1123 org_atheme_audacious_add (DBusGProxy *proxy, const char * IN_file, GError **error)
1124 
1125 {
1126  return dbus_g_proxy_call (proxy, "Add", error, G_TYPE_STRING, IN_file, G_TYPE_INVALID, G_TYPE_INVALID);
1127 }
1128 
1129 typedef void (*org_atheme_audacious_add_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
1130 
1131 static void
1132 org_atheme_audacious_add_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
1133 {
1134  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
1135  GError *error = NULL;
1136  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
1137  (*(org_atheme_audacious_add_reply)data->cb) (proxy, error, data->userdata);
1138  return;
1139 }
1140 
1141 static
1142 #ifdef G_HAVE_INLINE
1143 inline
1144 #endif
1145 DBusGProxyCall*
1146 org_atheme_audacious_add_async (DBusGProxy *proxy, const char * IN_file, org_atheme_audacious_add_reply callback, gpointer userdata)
1147 
1148 {
1149  DBusGAsyncData *stuff;
1150  stuff = g_slice_new (DBusGAsyncData);
1151  stuff->cb = G_CALLBACK (callback);
1152  stuff->userdata = userdata;
1153  return dbus_g_proxy_begin_call (proxy, "Add", org_atheme_audacious_add_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_STRING, IN_file, G_TYPE_INVALID);
1154 }
1155 static
1156 #ifdef G_HAVE_INLINE
1157 inline
1158 #endif
1159 gboolean
1160 org_atheme_audacious_add_url (DBusGProxy *proxy, const char * IN_url, GError **error)
1161 
1162 {
1163  return dbus_g_proxy_call (proxy, "AddUrl", error, G_TYPE_STRING, IN_url, G_TYPE_INVALID, G_TYPE_INVALID);
1164 }
1165 
1166 typedef void (*org_atheme_audacious_add_url_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
1167 
1168 static void
1169 org_atheme_audacious_add_url_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
1170 {
1171  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
1172  GError *error = NULL;
1173  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
1174  (*(org_atheme_audacious_add_url_reply)data->cb) (proxy, error, data->userdata);
1175  return;
1176 }
1177 
1178 static
1179 #ifdef G_HAVE_INLINE
1180 inline
1181 #endif
1182 DBusGProxyCall*
1183 org_atheme_audacious_add_url_async (DBusGProxy *proxy, const char * IN_url, org_atheme_audacious_add_url_reply callback, gpointer userdata)
1184 
1185 {
1186  DBusGAsyncData *stuff;
1187  stuff = g_slice_new (DBusGAsyncData);
1188  stuff->cb = G_CALLBACK (callback);
1189  stuff->userdata = userdata;
1190  return dbus_g_proxy_begin_call (proxy, "AddUrl", org_atheme_audacious_add_url_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_STRING, IN_url, G_TYPE_INVALID);
1191 }
1192 static
1193 #ifdef G_HAVE_INLINE
1194 inline
1195 #endif
1196 gboolean
1197 org_atheme_audacious_add_list (DBusGProxy *proxy, const char ** IN_filenames, GError **error)
1198 
1199 {
1200  return dbus_g_proxy_call (proxy, "AddList", error, G_TYPE_STRV, IN_filenames, G_TYPE_INVALID, G_TYPE_INVALID);
1201 }
1202 
1203 typedef void (*org_atheme_audacious_add_list_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
1204 
1205 static void
1206 org_atheme_audacious_add_list_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
1207 {
1208  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
1209  GError *error = NULL;
1210  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
1211  (*(org_atheme_audacious_add_list_reply)data->cb) (proxy, error, data->userdata);
1212  return;
1213 }
1214 
1215 static
1216 #ifdef G_HAVE_INLINE
1217 inline
1218 #endif
1219 DBusGProxyCall*
1220 org_atheme_audacious_add_list_async (DBusGProxy *proxy, const char ** IN_filenames, org_atheme_audacious_add_list_reply callback, gpointer userdata)
1221 
1222 {
1223  DBusGAsyncData *stuff;
1224  stuff = g_slice_new (DBusGAsyncData);
1225  stuff->cb = G_CALLBACK (callback);
1226  stuff->userdata = userdata;
1227  return dbus_g_proxy_begin_call (proxy, "AddList", org_atheme_audacious_add_list_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_STRV, IN_filenames, G_TYPE_INVALID);
1228 }
1229 static
1230 #ifdef G_HAVE_INLINE
1231 inline
1232 #endif
1233 gboolean
1234 org_atheme_audacious_open_list (DBusGProxy *proxy, const char ** IN_filenames, GError **error)
1235 
1236 {
1237  return dbus_g_proxy_call (proxy, "OpenList", error, G_TYPE_STRV, IN_filenames, G_TYPE_INVALID, G_TYPE_INVALID);
1238 }
1239 
1240 typedef void (*org_atheme_audacious_open_list_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
1241 
1242 static void
1243 org_atheme_audacious_open_list_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
1244 {
1245  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
1246  GError *error = NULL;
1247  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
1248  (*(org_atheme_audacious_open_list_reply)data->cb) (proxy, error, data->userdata);
1249  return;
1250 }
1251 
1252 static
1253 #ifdef G_HAVE_INLINE
1254 inline
1255 #endif
1256 DBusGProxyCall*
1257 org_atheme_audacious_open_list_async (DBusGProxy *proxy, const char ** IN_filenames, org_atheme_audacious_open_list_reply callback, gpointer userdata)
1258 
1259 {
1260  DBusGAsyncData *stuff;
1261  stuff = g_slice_new (DBusGAsyncData);
1262  stuff->cb = G_CALLBACK (callback);
1263  stuff->userdata = userdata;
1264  return dbus_g_proxy_begin_call (proxy, "OpenList", org_atheme_audacious_open_list_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_STRV, IN_filenames, G_TYPE_INVALID);
1265 }
1266 static
1267 #ifdef G_HAVE_INLINE
1268 inline
1269 #endif
1270 gboolean
1271 org_atheme_audacious_open_list_to_temp (DBusGProxy *proxy, const char ** IN_filenames, GError **error)
1272 
1273 {
1274  return dbus_g_proxy_call (proxy, "OpenListToTemp", error, G_TYPE_STRV, IN_filenames, G_TYPE_INVALID, G_TYPE_INVALID);
1275 }
1276 
1277 typedef void (*org_atheme_audacious_open_list_to_temp_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
1278 
1279 static void
1280 org_atheme_audacious_open_list_to_temp_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
1281 {
1282  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
1283  GError *error = NULL;
1284  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
1285  (*(org_atheme_audacious_open_list_to_temp_reply)data->cb) (proxy, error, data->userdata);
1286  return;
1287 }
1288 
1289 static
1290 #ifdef G_HAVE_INLINE
1291 inline
1292 #endif
1293 DBusGProxyCall*
1294 org_atheme_audacious_open_list_to_temp_async (DBusGProxy *proxy, const char ** IN_filenames, org_atheme_audacious_open_list_to_temp_reply callback, gpointer userdata)
1295 
1296 {
1297  DBusGAsyncData *stuff;
1298  stuff = g_slice_new (DBusGAsyncData);
1299  stuff->cb = G_CALLBACK (callback);
1300  stuff->userdata = userdata;
1301  return dbus_g_proxy_begin_call (proxy, "OpenListToTemp", org_atheme_audacious_open_list_to_temp_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_STRV, IN_filenames, G_TYPE_INVALID);
1302 }
1303 static
1304 #ifdef G_HAVE_INLINE
1305 inline
1306 #endif
1307 gboolean
1308 org_atheme_audacious_delete (DBusGProxy *proxy, const guint IN_pos, GError **error)
1309 
1310 {
1311  return dbus_g_proxy_call (proxy, "Delete", error, G_TYPE_UINT, IN_pos, G_TYPE_INVALID, G_TYPE_INVALID);
1312 }
1313 
1314 typedef void (*org_atheme_audacious_delete_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
1315 
1316 static void
1317 org_atheme_audacious_delete_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
1318 {
1319  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
1320  GError *error = NULL;
1321  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
1322  (*(org_atheme_audacious_delete_reply)data->cb) (proxy, error, data->userdata);
1323  return;
1324 }
1325 
1326 static
1327 #ifdef G_HAVE_INLINE
1328 inline
1329 #endif
1330 DBusGProxyCall*
1331 org_atheme_audacious_delete_async (DBusGProxy *proxy, const guint IN_pos, org_atheme_audacious_delete_reply callback, gpointer userdata)
1332 
1333 {
1334  DBusGAsyncData *stuff;
1335  stuff = g_slice_new (DBusGAsyncData);
1336  stuff->cb = G_CALLBACK (callback);
1337  stuff->userdata = userdata;
1338  return dbus_g_proxy_begin_call (proxy, "Delete", org_atheme_audacious_delete_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_UINT, IN_pos, G_TYPE_INVALID);
1339 }
1340 static
1341 #ifdef G_HAVE_INLINE
1342 inline
1343 #endif
1344 gboolean
1345 org_atheme_audacious_clear (DBusGProxy *proxy, GError **error)
1346 
1347 {
1348  return dbus_g_proxy_call (proxy, "Clear", error, G_TYPE_INVALID, G_TYPE_INVALID);
1349 }
1350 
1351 typedef void (*org_atheme_audacious_clear_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
1352 
1353 static void
1354 org_atheme_audacious_clear_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
1355 {
1356  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
1357  GError *error = NULL;
1358  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
1359  (*(org_atheme_audacious_clear_reply)data->cb) (proxy, error, data->userdata);
1360  return;
1361 }
1362 
1363 static
1364 #ifdef G_HAVE_INLINE
1365 inline
1366 #endif
1367 DBusGProxyCall*
1368 org_atheme_audacious_clear_async (DBusGProxy *proxy, org_atheme_audacious_clear_reply callback, gpointer userdata)
1369 
1370 {
1371  DBusGAsyncData *stuff;
1372  stuff = g_slice_new (DBusGAsyncData);
1373  stuff->cb = G_CALLBACK (callback);
1374  stuff->userdata = userdata;
1375  return dbus_g_proxy_begin_call (proxy, "Clear", org_atheme_audacious_clear_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
1376 }
1377 static
1378 #ifdef G_HAVE_INLINE
1379 inline
1380 #endif
1381 gboolean
1382 org_atheme_audacious_auto_advance (DBusGProxy *proxy, gboolean* OUT_is_advance, GError **error)
1383 
1384 {
1385  return dbus_g_proxy_call (proxy, "AutoAdvance", error, G_TYPE_INVALID, G_TYPE_BOOLEAN, OUT_is_advance, G_TYPE_INVALID);
1386 }
1387 
1388 typedef void (*org_atheme_audacious_auto_advance_reply) (DBusGProxy *proxy, gboolean OUT_is_advance, GError *error, gpointer userdata);
1389 
1390 static void
1391 org_atheme_audacious_auto_advance_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
1392 {
1393  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
1394  GError *error = NULL;
1395  gboolean OUT_is_advance;
1396  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_BOOLEAN, &OUT_is_advance, G_TYPE_INVALID);
1397  (*(org_atheme_audacious_auto_advance_reply)data->cb) (proxy, OUT_is_advance, error, data->userdata);
1398  return;
1399 }
1400 
1401 static
1402 #ifdef G_HAVE_INLINE
1403 inline
1404 #endif
1405 DBusGProxyCall*
1407 
1408 {
1409  DBusGAsyncData *stuff;
1410  stuff = g_slice_new (DBusGAsyncData);
1411  stuff->cb = G_CALLBACK (callback);
1412  stuff->userdata = userdata;
1413  return dbus_g_proxy_begin_call (proxy, "AutoAdvance", org_atheme_audacious_auto_advance_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
1414 }
1415 static
1416 #ifdef G_HAVE_INLINE
1417 inline
1418 #endif
1419 gboolean
1421 
1422 {
1423  return dbus_g_proxy_call (proxy, "ToggleAutoAdvance", error, G_TYPE_INVALID, G_TYPE_INVALID);
1424 }
1425 
1426 typedef void (*org_atheme_audacious_toggle_auto_advance_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
1427 
1428 static void
1429 org_atheme_audacious_toggle_auto_advance_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
1430 {
1431  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
1432  GError *error = NULL;
1433  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
1434  (*(org_atheme_audacious_toggle_auto_advance_reply)data->cb) (proxy, error, data->userdata);
1435  return;
1436 }
1437 
1438 static
1439 #ifdef G_HAVE_INLINE
1440 inline
1441 #endif
1442 DBusGProxyCall*
1444 
1445 {
1446  DBusGAsyncData *stuff;
1447  stuff = g_slice_new (DBusGAsyncData);
1448  stuff->cb = G_CALLBACK (callback);
1449  stuff->userdata = userdata;
1450  return dbus_g_proxy_begin_call (proxy, "ToggleAutoAdvance", org_atheme_audacious_toggle_auto_advance_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
1451 }
1452 static
1453 #ifdef G_HAVE_INLINE
1454 inline
1455 #endif
1456 gboolean
1457 org_atheme_audacious_repeat (DBusGProxy *proxy, gboolean* OUT_is_repeat, GError **error)
1458 
1459 {
1460  return dbus_g_proxy_call (proxy, "Repeat", error, G_TYPE_INVALID, G_TYPE_BOOLEAN, OUT_is_repeat, G_TYPE_INVALID);
1461 }
1462 
1463 typedef void (*org_atheme_audacious_repeat_reply) (DBusGProxy *proxy, gboolean OUT_is_repeat, GError *error, gpointer userdata);
1464 
1465 static void
1466 org_atheme_audacious_repeat_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
1467 {
1468  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
1469  GError *error = NULL;
1470  gboolean OUT_is_repeat;
1471  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_BOOLEAN, &OUT_is_repeat, G_TYPE_INVALID);
1472  (*(org_atheme_audacious_repeat_reply)data->cb) (proxy, OUT_is_repeat, error, data->userdata);
1473  return;
1474 }
1475 
1476 static
1477 #ifdef G_HAVE_INLINE
1478 inline
1479 #endif
1480 DBusGProxyCall*
1481 org_atheme_audacious_repeat_async (DBusGProxy *proxy, org_atheme_audacious_repeat_reply callback, gpointer userdata)
1482 
1483 {
1484  DBusGAsyncData *stuff;
1485  stuff = g_slice_new (DBusGAsyncData);
1486  stuff->cb = G_CALLBACK (callback);
1487  stuff->userdata = userdata;
1488  return dbus_g_proxy_begin_call (proxy, "Repeat", org_atheme_audacious_repeat_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
1489 }
1490 static
1491 #ifdef G_HAVE_INLINE
1492 inline
1493 #endif
1494 gboolean
1495 org_atheme_audacious_toggle_repeat (DBusGProxy *proxy, GError **error)
1496 
1497 {
1498  return dbus_g_proxy_call (proxy, "ToggleRepeat", error, G_TYPE_INVALID, G_TYPE_INVALID);
1499 }
1500 
1501 typedef void (*org_atheme_audacious_toggle_repeat_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
1502 
1503 static void
1504 org_atheme_audacious_toggle_repeat_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
1505 {
1506  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
1507  GError *error = NULL;
1508  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
1509  (*(org_atheme_audacious_toggle_repeat_reply)data->cb) (proxy, error, data->userdata);
1510  return;
1511 }
1512 
1513 static
1514 #ifdef G_HAVE_INLINE
1515 inline
1516 #endif
1517 DBusGProxyCall*
1519 
1520 {
1521  DBusGAsyncData *stuff;
1522  stuff = g_slice_new (DBusGAsyncData);
1523  stuff->cb = G_CALLBACK (callback);
1524  stuff->userdata = userdata;
1525  return dbus_g_proxy_begin_call (proxy, "ToggleRepeat", org_atheme_audacious_toggle_repeat_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
1526 }
1527 static
1528 #ifdef G_HAVE_INLINE
1529 inline
1530 #endif
1531 gboolean
1532 org_atheme_audacious_shuffle (DBusGProxy *proxy, gboolean* OUT_is_shuffle, GError **error)
1533 
1534 {
1535  return dbus_g_proxy_call (proxy, "Shuffle", error, G_TYPE_INVALID, G_TYPE_BOOLEAN, OUT_is_shuffle, G_TYPE_INVALID);
1536 }
1537 
1538 typedef void (*org_atheme_audacious_shuffle_reply) (DBusGProxy *proxy, gboolean OUT_is_shuffle, GError *error, gpointer userdata);
1539 
1540 static void
1541 org_atheme_audacious_shuffle_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
1542 {
1543  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
1544  GError *error = NULL;
1545  gboolean OUT_is_shuffle;
1546  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_BOOLEAN, &OUT_is_shuffle, G_TYPE_INVALID);
1547  (*(org_atheme_audacious_shuffle_reply)data->cb) (proxy, OUT_is_shuffle, error, data->userdata);
1548  return;
1549 }
1550 
1551 static
1552 #ifdef G_HAVE_INLINE
1553 inline
1554 #endif
1555 DBusGProxyCall*
1556 org_atheme_audacious_shuffle_async (DBusGProxy *proxy, org_atheme_audacious_shuffle_reply callback, gpointer userdata)
1557 
1558 {
1559  DBusGAsyncData *stuff;
1560  stuff = g_slice_new (DBusGAsyncData);
1561  stuff->cb = G_CALLBACK (callback);
1562  stuff->userdata = userdata;
1563  return dbus_g_proxy_begin_call (proxy, "Shuffle", org_atheme_audacious_shuffle_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
1564 }
1565 static
1566 #ifdef G_HAVE_INLINE
1567 inline
1568 #endif
1569 gboolean
1570 org_atheme_audacious_toggle_shuffle (DBusGProxy *proxy, GError **error)
1571 
1572 {
1573  return dbus_g_proxy_call (proxy, "ToggleShuffle", error, G_TYPE_INVALID, G_TYPE_INVALID);
1574 }
1575 
1576 typedef void (*org_atheme_audacious_toggle_shuffle_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
1577 
1578 static void
1579 org_atheme_audacious_toggle_shuffle_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
1580 {
1581  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
1582  GError *error = NULL;
1583  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
1584  (*(org_atheme_audacious_toggle_shuffle_reply)data->cb) (proxy, error, data->userdata);
1585  return;
1586 }
1587 
1588 static
1589 #ifdef G_HAVE_INLINE
1590 inline
1591 #endif
1592 DBusGProxyCall*
1594 
1595 {
1596  DBusGAsyncData *stuff;
1597  stuff = g_slice_new (DBusGAsyncData);
1598  stuff->cb = G_CALLBACK (callback);
1599  stuff->userdata = userdata;
1600  return dbus_g_proxy_begin_call (proxy, "ToggleShuffle", org_atheme_audacious_toggle_shuffle_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
1601 }
1602 static
1603 #ifdef G_HAVE_INLINE
1604 inline
1605 #endif
1606 gboolean
1607 org_atheme_audacious_stop_after (DBusGProxy *proxy, gboolean* OUT_is_stopping, GError **error)
1608 
1609 {
1610  return dbus_g_proxy_call (proxy, "StopAfter", error, G_TYPE_INVALID, G_TYPE_BOOLEAN, OUT_is_stopping, G_TYPE_INVALID);
1611 }
1612 
1613 typedef void (*org_atheme_audacious_stop_after_reply) (DBusGProxy *proxy, gboolean OUT_is_stopping, GError *error, gpointer userdata);
1614 
1615 static void
1616 org_atheme_audacious_stop_after_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
1617 {
1618  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
1619  GError *error = NULL;
1620  gboolean OUT_is_stopping;
1621  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_BOOLEAN, &OUT_is_stopping, G_TYPE_INVALID);
1622  (*(org_atheme_audacious_stop_after_reply)data->cb) (proxy, OUT_is_stopping, error, data->userdata);
1623  return;
1624 }
1625 
1626 static
1627 #ifdef G_HAVE_INLINE
1628 inline
1629 #endif
1630 DBusGProxyCall*
1632 
1633 {
1634  DBusGAsyncData *stuff;
1635  stuff = g_slice_new (DBusGAsyncData);
1636  stuff->cb = G_CALLBACK (callback);
1637  stuff->userdata = userdata;
1638  return dbus_g_proxy_begin_call (proxy, "StopAfter", org_atheme_audacious_stop_after_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
1639 }
1640 static
1641 #ifdef G_HAVE_INLINE
1642 inline
1643 #endif
1644 gboolean
1645 org_atheme_audacious_toggle_stop_after (DBusGProxy *proxy, GError **error)
1646 
1647 {
1648  return dbus_g_proxy_call (proxy, "ToggleStopAfter", error, G_TYPE_INVALID, G_TYPE_INVALID);
1649 }
1650 
1651 typedef void (*org_atheme_audacious_toggle_stop_after_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
1652 
1653 static void
1654 org_atheme_audacious_toggle_stop_after_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
1655 {
1656  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
1657  GError *error = NULL;
1658  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
1659  (*(org_atheme_audacious_toggle_stop_after_reply)data->cb) (proxy, error, data->userdata);
1660  return;
1661 }
1662 
1663 static
1664 #ifdef G_HAVE_INLINE
1665 inline
1666 #endif
1667 DBusGProxyCall*
1669 
1670 {
1671  DBusGAsyncData *stuff;
1672  stuff = g_slice_new (DBusGAsyncData);
1673  stuff->cb = G_CALLBACK (callback);
1674  stuff->userdata = userdata;
1675  return dbus_g_proxy_begin_call (proxy, "ToggleStopAfter", org_atheme_audacious_toggle_stop_after_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
1676 }
1677 static
1678 #ifdef G_HAVE_INLINE
1679 inline
1680 #endif
1681 gboolean
1682 org_atheme_audacious_show_prefs_box (DBusGProxy *proxy, const gboolean IN_show, GError **error)
1683 
1684 {
1685  return dbus_g_proxy_call (proxy, "ShowPrefsBox", error, G_TYPE_BOOLEAN, IN_show, G_TYPE_INVALID, G_TYPE_INVALID);
1686 }
1687 
1688 typedef void (*org_atheme_audacious_show_prefs_box_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
1689 
1690 static void
1691 org_atheme_audacious_show_prefs_box_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
1692 {
1693  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
1694  GError *error = NULL;
1695  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
1696  (*(org_atheme_audacious_show_prefs_box_reply)data->cb) (proxy, error, data->userdata);
1697  return;
1698 }
1699 
1700 static
1701 #ifdef G_HAVE_INLINE
1702 inline
1703 #endif
1704 DBusGProxyCall*
1705 org_atheme_audacious_show_prefs_box_async (DBusGProxy *proxy, const gboolean IN_show, org_atheme_audacious_show_prefs_box_reply callback, gpointer userdata)
1706 
1707 {
1708  DBusGAsyncData *stuff;
1709  stuff = g_slice_new (DBusGAsyncData);
1710  stuff->cb = G_CALLBACK (callback);
1711  stuff->userdata = userdata;
1712  return dbus_g_proxy_begin_call (proxy, "ShowPrefsBox", org_atheme_audacious_show_prefs_box_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_BOOLEAN, IN_show, G_TYPE_INVALID);
1713 }
1714 static
1715 #ifdef G_HAVE_INLINE
1716 inline
1717 #endif
1718 gboolean
1719 org_atheme_audacious_show_about_box (DBusGProxy *proxy, const gboolean IN_show, GError **error)
1720 
1721 {
1722  return dbus_g_proxy_call (proxy, "ShowAboutBox", error, G_TYPE_BOOLEAN, IN_show, G_TYPE_INVALID, G_TYPE_INVALID);
1723 }
1724 
1725 typedef void (*org_atheme_audacious_show_about_box_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
1726 
1727 static void
1728 org_atheme_audacious_show_about_box_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
1729 {
1730  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
1731  GError *error = NULL;
1732  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
1733  (*(org_atheme_audacious_show_about_box_reply)data->cb) (proxy, error, data->userdata);
1734  return;
1735 }
1736 
1737 static
1738 #ifdef G_HAVE_INLINE
1739 inline
1740 #endif
1741 DBusGProxyCall*
1742 org_atheme_audacious_show_about_box_async (DBusGProxy *proxy, const gboolean IN_show, org_atheme_audacious_show_about_box_reply callback, gpointer userdata)
1743 
1744 {
1745  DBusGAsyncData *stuff;
1746  stuff = g_slice_new (DBusGAsyncData);
1747  stuff->cb = G_CALLBACK (callback);
1748  stuff->userdata = userdata;
1749  return dbus_g_proxy_begin_call (proxy, "ShowAboutBox", org_atheme_audacious_show_about_box_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_BOOLEAN, IN_show, G_TYPE_INVALID);
1750 }
1751 static
1752 #ifdef G_HAVE_INLINE
1753 inline
1754 #endif
1755 gboolean
1756 org_atheme_audacious_show_jtf_box (DBusGProxy *proxy, const gboolean IN_show, GError **error)
1757 
1758 {
1759  return dbus_g_proxy_call (proxy, "ShowJtfBox", error, G_TYPE_BOOLEAN, IN_show, G_TYPE_INVALID, G_TYPE_INVALID);
1760 }
1761 
1762 typedef void (*org_atheme_audacious_show_jtf_box_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
1763 
1764 static void
1765 org_atheme_audacious_show_jtf_box_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
1766 {
1767  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
1768  GError *error = NULL;
1769  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
1770  (*(org_atheme_audacious_show_jtf_box_reply)data->cb) (proxy, error, data->userdata);
1771  return;
1772 }
1773 
1774 static
1775 #ifdef G_HAVE_INLINE
1776 inline
1777 #endif
1778 DBusGProxyCall*
1779 org_atheme_audacious_show_jtf_box_async (DBusGProxy *proxy, const gboolean IN_show, org_atheme_audacious_show_jtf_box_reply callback, gpointer userdata)
1780 
1781 {
1782  DBusGAsyncData *stuff;
1783  stuff = g_slice_new (DBusGAsyncData);
1784  stuff->cb = G_CALLBACK (callback);
1785  stuff->userdata = userdata;
1786  return dbus_g_proxy_begin_call (proxy, "ShowJtfBox", org_atheme_audacious_show_jtf_box_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_BOOLEAN, IN_show, G_TYPE_INVALID);
1787 }
1788 static
1789 #ifdef G_HAVE_INLINE
1790 inline
1791 #endif
1792 gboolean
1793 org_atheme_audacious_show_filebrowser (DBusGProxy *proxy, const gboolean IN_show, GError **error)
1794 
1795 {
1796  return dbus_g_proxy_call (proxy, "ShowFilebrowser", error, G_TYPE_BOOLEAN, IN_show, G_TYPE_INVALID, G_TYPE_INVALID);
1797 }
1798 
1799 typedef void (*org_atheme_audacious_show_filebrowser_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
1800 
1801 static void
1802 org_atheme_audacious_show_filebrowser_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
1803 {
1804  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
1805  GError *error = NULL;
1806  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
1807  (*(org_atheme_audacious_show_filebrowser_reply)data->cb) (proxy, error, data->userdata);
1808  return;
1809 }
1810 
1811 static
1812 #ifdef G_HAVE_INLINE
1813 inline
1814 #endif
1815 DBusGProxyCall*
1816 org_atheme_audacious_show_filebrowser_async (DBusGProxy *proxy, const gboolean IN_show, org_atheme_audacious_show_filebrowser_reply callback, gpointer userdata)
1817 
1818 {
1819  DBusGAsyncData *stuff;
1820  stuff = g_slice_new (DBusGAsyncData);
1821  stuff->cb = G_CALLBACK (callback);
1822  stuff->userdata = userdata;
1823  return dbus_g_proxy_begin_call (proxy, "ShowFilebrowser", org_atheme_audacious_show_filebrowser_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_BOOLEAN, IN_show, G_TYPE_INVALID);
1824 }
1825 static
1826 #ifdef G_HAVE_INLINE
1827 inline
1828 #endif
1829 gboolean
1830 org_atheme_audacious_play_pause (DBusGProxy *proxy, GError **error)
1831 
1832 {
1833  return dbus_g_proxy_call (proxy, "PlayPause", error, G_TYPE_INVALID, G_TYPE_INVALID);
1834 }
1835 
1836 typedef void (*org_atheme_audacious_play_pause_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
1837 
1838 static void
1839 org_atheme_audacious_play_pause_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
1840 {
1841  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
1842  GError *error = NULL;
1843  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
1844  (*(org_atheme_audacious_play_pause_reply)data->cb) (proxy, error, data->userdata);
1845  return;
1846 }
1847 
1848 static
1849 #ifdef G_HAVE_INLINE
1850 inline
1851 #endif
1852 DBusGProxyCall*
1854 
1855 {
1856  DBusGAsyncData *stuff;
1857  stuff = g_slice_new (DBusGAsyncData);
1858  stuff->cb = G_CALLBACK (callback);
1859  stuff->userdata = userdata;
1860  return dbus_g_proxy_begin_call (proxy, "PlayPause", org_atheme_audacious_play_pause_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
1861 }
1862 static
1863 #ifdef G_HAVE_INLINE
1864 inline
1865 #endif
1866 gboolean
1867 org_atheme_audacious_queue_get_list_pos (DBusGProxy *proxy, const guint IN_qpos, guint* OUT_pos, GError **error)
1868 
1869 {
1870  return dbus_g_proxy_call (proxy, "QueueGetListPos", error, G_TYPE_UINT, IN_qpos, G_TYPE_INVALID, G_TYPE_UINT, OUT_pos, G_TYPE_INVALID);
1871 }
1872 
1873 typedef void (*org_atheme_audacious_queue_get_list_pos_reply) (DBusGProxy *proxy, guint OUT_pos, GError *error, gpointer userdata);
1874 
1875 static void
1876 org_atheme_audacious_queue_get_list_pos_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
1877 {
1878  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
1879  GError *error = NULL;
1880  guint OUT_pos;
1881  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_UINT, &OUT_pos, G_TYPE_INVALID);
1882  (*(org_atheme_audacious_queue_get_list_pos_reply)data->cb) (proxy, OUT_pos, error, data->userdata);
1883  return;
1884 }
1885 
1886 static
1887 #ifdef G_HAVE_INLINE
1888 inline
1889 #endif
1890 DBusGProxyCall*
1891 org_atheme_audacious_queue_get_list_pos_async (DBusGProxy *proxy, const guint IN_qpos, org_atheme_audacious_queue_get_list_pos_reply callback, gpointer userdata)
1892 
1893 {
1894  DBusGAsyncData *stuff;
1895  stuff = g_slice_new (DBusGAsyncData);
1896  stuff->cb = G_CALLBACK (callback);
1897  stuff->userdata = userdata;
1898  return dbus_g_proxy_begin_call (proxy, "QueueGetListPos", org_atheme_audacious_queue_get_list_pos_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_UINT, IN_qpos, G_TYPE_INVALID);
1899 }
1900 static
1901 #ifdef G_HAVE_INLINE
1902 inline
1903 #endif
1904 gboolean
1905 org_atheme_audacious_queue_get_queue_pos (DBusGProxy *proxy, const guint IN_pos, guint* OUT_qpos, GError **error)
1906 
1907 {
1908  return dbus_g_proxy_call (proxy, "QueueGetQueuePos", error, G_TYPE_UINT, IN_pos, G_TYPE_INVALID, G_TYPE_UINT, OUT_qpos, G_TYPE_INVALID);
1909 }
1910 
1911 typedef void (*org_atheme_audacious_queue_get_queue_pos_reply) (DBusGProxy *proxy, guint OUT_qpos, GError *error, gpointer userdata);
1912 
1913 static void
1914 org_atheme_audacious_queue_get_queue_pos_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
1915 {
1916  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
1917  GError *error = NULL;
1918  guint OUT_qpos;
1919  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_UINT, &OUT_qpos, G_TYPE_INVALID);
1920  (*(org_atheme_audacious_queue_get_queue_pos_reply)data->cb) (proxy, OUT_qpos, error, data->userdata);
1921  return;
1922 }
1923 
1924 static
1925 #ifdef G_HAVE_INLINE
1926 inline
1927 #endif
1928 DBusGProxyCall*
1929 org_atheme_audacious_queue_get_queue_pos_async (DBusGProxy *proxy, const guint IN_pos, org_atheme_audacious_queue_get_queue_pos_reply callback, gpointer userdata)
1930 
1931 {
1932  DBusGAsyncData *stuff;
1933  stuff = g_slice_new (DBusGAsyncData);
1934  stuff->cb = G_CALLBACK (callback);
1935  stuff->userdata = userdata;
1936  return dbus_g_proxy_begin_call (proxy, "QueueGetQueuePos", org_atheme_audacious_queue_get_queue_pos_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_UINT, IN_pos, G_TYPE_INVALID);
1937 }
1938 static
1939 #ifdef G_HAVE_INLINE
1940 inline
1941 #endif
1942 gboolean
1943 org_atheme_audacious_get_info (DBusGProxy *proxy, gint* OUT_rate, gint* OUT_freq, gint* OUT_nch, GError **error)
1944 
1945 {
1946  return dbus_g_proxy_call (proxy, "GetInfo", error, G_TYPE_INVALID, G_TYPE_INT, OUT_rate, G_TYPE_INT, OUT_freq, G_TYPE_INT, OUT_nch, G_TYPE_INVALID);
1947 }
1948 
1949 typedef void (*org_atheme_audacious_get_info_reply) (DBusGProxy *proxy, gint OUT_rate, gint OUT_freq, gint OUT_nch, GError *error, gpointer userdata);
1950 
1951 static void
1952 org_atheme_audacious_get_info_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
1953 {
1954  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
1955  GError *error = NULL;
1956  gint OUT_rate;
1957  gint OUT_freq;
1958  gint OUT_nch;
1959  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INT, &OUT_rate, G_TYPE_INT, &OUT_freq, G_TYPE_INT, &OUT_nch, G_TYPE_INVALID);
1960  (*(org_atheme_audacious_get_info_reply)data->cb) (proxy, OUT_rate, OUT_freq, OUT_nch, error, data->userdata);
1961  return;
1962 }
1963 
1964 static
1965 #ifdef G_HAVE_INLINE
1966 inline
1967 #endif
1968 DBusGProxyCall*
1969 org_atheme_audacious_get_info_async (DBusGProxy *proxy, org_atheme_audacious_get_info_reply callback, gpointer userdata)
1970 
1971 {
1972  DBusGAsyncData *stuff;
1973  stuff = g_slice_new (DBusGAsyncData);
1974  stuff->cb = G_CALLBACK (callback);
1975  stuff->userdata = userdata;
1976  return dbus_g_proxy_begin_call (proxy, "GetInfo", org_atheme_audacious_get_info_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
1977 }
1978 static
1979 #ifdef G_HAVE_INLINE
1980 inline
1981 #endif
1982 gboolean
1983 org_atheme_audacious_toggle_aot (DBusGProxy *proxy, const gboolean IN_ontop, GError **error)
1984 
1985 {
1986  return dbus_g_proxy_call (proxy, "ToggleAot", error, G_TYPE_BOOLEAN, IN_ontop, G_TYPE_INVALID, G_TYPE_INVALID);
1987 }
1988 
1989 typedef void (*org_atheme_audacious_toggle_aot_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
1990 
1991 static void
1992 org_atheme_audacious_toggle_aot_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
1993 {
1994  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
1995  GError *error = NULL;
1996  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
1997  (*(org_atheme_audacious_toggle_aot_reply)data->cb) (proxy, error, data->userdata);
1998  return;
1999 }
2000 
2001 static
2002 #ifdef G_HAVE_INLINE
2003 inline
2004 #endif
2005 DBusGProxyCall*
2006 org_atheme_audacious_toggle_aot_async (DBusGProxy *proxy, const gboolean IN_ontop, org_atheme_audacious_toggle_aot_reply callback, gpointer userdata)
2007 
2008 {
2009  DBusGAsyncData *stuff;
2010  stuff = g_slice_new (DBusGAsyncData);
2011  stuff->cb = G_CALLBACK (callback);
2012  stuff->userdata = userdata;
2013  return dbus_g_proxy_begin_call (proxy, "ToggleAot", org_atheme_audacious_toggle_aot_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_BOOLEAN, IN_ontop, G_TYPE_INVALID);
2014 }
2015 static
2016 #ifdef G_HAVE_INLINE
2017 inline
2018 #endif
2019 gboolean
2020 org_atheme_audacious_get_playqueue_length (DBusGProxy *proxy, gint* OUT_length, GError **error)
2021 
2022 {
2023  return dbus_g_proxy_call (proxy, "GetPlayqueueLength", error, G_TYPE_INVALID, G_TYPE_INT, OUT_length, G_TYPE_INVALID);
2024 }
2025 
2026 typedef void (*org_atheme_audacious_get_playqueue_length_reply) (DBusGProxy *proxy, gint OUT_length, GError *error, gpointer userdata);
2027 
2028 static void
2029 org_atheme_audacious_get_playqueue_length_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
2030 {
2031  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
2032  GError *error = NULL;
2033  gint OUT_length;
2034  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INT, &OUT_length, G_TYPE_INVALID);
2035  (*(org_atheme_audacious_get_playqueue_length_reply)data->cb) (proxy, OUT_length, error, data->userdata);
2036  return;
2037 }
2038 
2039 static
2040 #ifdef G_HAVE_INLINE
2041 inline
2042 #endif
2043 DBusGProxyCall*
2045 
2046 {
2047  DBusGAsyncData *stuff;
2048  stuff = g_slice_new (DBusGAsyncData);
2049  stuff->cb = G_CALLBACK (callback);
2050  stuff->userdata = userdata;
2051  return dbus_g_proxy_begin_call (proxy, "GetPlayqueueLength", org_atheme_audacious_get_playqueue_length_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
2052 }
2053 static
2054 #ifdef G_HAVE_INLINE
2055 inline
2056 #endif
2057 gboolean
2058 org_atheme_audacious_playlist_ins_url_string (DBusGProxy *proxy, const char * IN_url, const gint IN_pos, GError **error)
2059 
2060 {
2061  return dbus_g_proxy_call (proxy, "PlaylistInsUrlString", error, G_TYPE_STRING, IN_url, G_TYPE_INT, IN_pos, G_TYPE_INVALID, G_TYPE_INVALID);
2062 }
2063 
2064 typedef void (*org_atheme_audacious_playlist_ins_url_string_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
2065 
2066 static void
2067 org_atheme_audacious_playlist_ins_url_string_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
2068 {
2069  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
2070  GError *error = NULL;
2071  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
2072  (*(org_atheme_audacious_playlist_ins_url_string_reply)data->cb) (proxy, error, data->userdata);
2073  return;
2074 }
2075 
2076 static
2077 #ifdef G_HAVE_INLINE
2078 inline
2079 #endif
2080 DBusGProxyCall*
2081 org_atheme_audacious_playlist_ins_url_string_async (DBusGProxy *proxy, const char * IN_url, const gint IN_pos, org_atheme_audacious_playlist_ins_url_string_reply callback, gpointer userdata)
2082 
2083 {
2084  DBusGAsyncData *stuff;
2085  stuff = g_slice_new (DBusGAsyncData);
2086  stuff->cb = G_CALLBACK (callback);
2087  stuff->userdata = userdata;
2088  return dbus_g_proxy_begin_call (proxy, "PlaylistInsUrlString", org_atheme_audacious_playlist_ins_url_string_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_STRING, IN_url, G_TYPE_INT, IN_pos, G_TYPE_INVALID);
2089 }
2090 static
2091 #ifdef G_HAVE_INLINE
2092 inline
2093 #endif
2094 gboolean
2095 org_atheme_audacious_playlist_add (DBusGProxy *proxy, const char * IN_list, GError **error)
2096 
2097 {
2098  return dbus_g_proxy_call (proxy, "PlaylistAdd", error, G_TYPE_STRING, IN_list, G_TYPE_INVALID, G_TYPE_INVALID);
2099 }
2100 
2101 typedef void (*org_atheme_audacious_playlist_add_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
2102 
2103 static void
2104 org_atheme_audacious_playlist_add_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
2105 {
2106  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
2107  GError *error = NULL;
2108  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
2109  (*(org_atheme_audacious_playlist_add_reply)data->cb) (proxy, error, data->userdata);
2110  return;
2111 }
2112 
2113 static
2114 #ifdef G_HAVE_INLINE
2115 inline
2116 #endif
2117 DBusGProxyCall*
2118 org_atheme_audacious_playlist_add_async (DBusGProxy *proxy, const char * IN_list, org_atheme_audacious_playlist_add_reply callback, gpointer userdata)
2119 
2120 {
2121  DBusGAsyncData *stuff;
2122  stuff = g_slice_new (DBusGAsyncData);
2123  stuff->cb = G_CALLBACK (callback);
2124  stuff->userdata = userdata;
2125  return dbus_g_proxy_begin_call (proxy, "PlaylistAdd", org_atheme_audacious_playlist_add_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_STRING, IN_list, G_TYPE_INVALID);
2126 }
2127 static
2128 #ifdef G_HAVE_INLINE
2129 inline
2130 #endif
2131 gboolean
2132 org_atheme_audacious_playqueue_add (DBusGProxy *proxy, const gint IN_pos, GError **error)
2133 
2134 {
2135  return dbus_g_proxy_call (proxy, "PlayqueueAdd", error, G_TYPE_INT, IN_pos, G_TYPE_INVALID, G_TYPE_INVALID);
2136 }
2137 
2138 typedef void (*org_atheme_audacious_playqueue_add_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
2139 
2140 static void
2141 org_atheme_audacious_playqueue_add_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
2142 {
2143  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
2144  GError *error = NULL;
2145  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
2146  (*(org_atheme_audacious_playqueue_add_reply)data->cb) (proxy, error, data->userdata);
2147  return;
2148 }
2149 
2150 static
2151 #ifdef G_HAVE_INLINE
2152 inline
2153 #endif
2154 DBusGProxyCall*
2155 org_atheme_audacious_playqueue_add_async (DBusGProxy *proxy, const gint IN_pos, org_atheme_audacious_playqueue_add_reply callback, gpointer userdata)
2156 
2157 {
2158  DBusGAsyncData *stuff;
2159  stuff = g_slice_new (DBusGAsyncData);
2160  stuff->cb = G_CALLBACK (callback);
2161  stuff->userdata = userdata;
2162  return dbus_g_proxy_begin_call (proxy, "PlayqueueAdd", org_atheme_audacious_playqueue_add_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INT, IN_pos, G_TYPE_INVALID);
2163 }
2164 static
2165 #ifdef G_HAVE_INLINE
2166 inline
2167 #endif
2168 gboolean
2169 org_atheme_audacious_playqueue_remove (DBusGProxy *proxy, const gint IN_pos, GError **error)
2170 
2171 {
2172  return dbus_g_proxy_call (proxy, "PlayqueueRemove", error, G_TYPE_INT, IN_pos, G_TYPE_INVALID, G_TYPE_INVALID);
2173 }
2174 
2175 typedef void (*org_atheme_audacious_playqueue_remove_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
2176 
2177 static void
2178 org_atheme_audacious_playqueue_remove_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
2179 {
2180  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
2181  GError *error = NULL;
2182  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
2183  (*(org_atheme_audacious_playqueue_remove_reply)data->cb) (proxy, error, data->userdata);
2184  return;
2185 }
2186 
2187 static
2188 #ifdef G_HAVE_INLINE
2189 inline
2190 #endif
2191 DBusGProxyCall*
2192 org_atheme_audacious_playqueue_remove_async (DBusGProxy *proxy, const gint IN_pos, org_atheme_audacious_playqueue_remove_reply callback, gpointer userdata)
2193 
2194 {
2195  DBusGAsyncData *stuff;
2196  stuff = g_slice_new (DBusGAsyncData);
2197  stuff->cb = G_CALLBACK (callback);
2198  stuff->userdata = userdata;
2199  return dbus_g_proxy_begin_call (proxy, "PlayqueueRemove", org_atheme_audacious_playqueue_remove_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INT, IN_pos, G_TYPE_INVALID);
2200 }
2201 static
2202 #ifdef G_HAVE_INLINE
2203 inline
2204 #endif
2205 gboolean
2206 org_atheme_audacious_playqueue_clear (DBusGProxy *proxy, GError **error)
2207 
2208 {
2209  return dbus_g_proxy_call (proxy, "PlayqueueClear", error, G_TYPE_INVALID, G_TYPE_INVALID);
2210 }
2211 
2212 typedef void (*org_atheme_audacious_playqueue_clear_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
2213 
2214 static void
2215 org_atheme_audacious_playqueue_clear_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
2216 {
2217  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
2218  GError *error = NULL;
2219  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
2220  (*(org_atheme_audacious_playqueue_clear_reply)data->cb) (proxy, error, data->userdata);
2221  return;
2222 }
2223 
2224 static
2225 #ifdef G_HAVE_INLINE
2226 inline
2227 #endif
2228 DBusGProxyCall*
2230 
2231 {
2232  DBusGAsyncData *stuff;
2233  stuff = g_slice_new (DBusGAsyncData);
2234  stuff->cb = G_CALLBACK (callback);
2235  stuff->userdata = userdata;
2236  return dbus_g_proxy_begin_call (proxy, "PlayqueueClear", org_atheme_audacious_playqueue_clear_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
2237 }
2238 static
2239 #ifdef G_HAVE_INLINE
2240 inline
2241 #endif
2242 gboolean
2243 org_atheme_audacious_playqueue_is_queued (DBusGProxy *proxy, const gint IN_pos, gboolean* OUT_is_queued, GError **error)
2244 
2245 {
2246  return dbus_g_proxy_call (proxy, "PlayqueueIsQueued", error, G_TYPE_INT, IN_pos, G_TYPE_INVALID, G_TYPE_BOOLEAN, OUT_is_queued, G_TYPE_INVALID);
2247 }
2248 
2249 typedef void (*org_atheme_audacious_playqueue_is_queued_reply) (DBusGProxy *proxy, gboolean OUT_is_queued, GError *error, gpointer userdata);
2250 
2251 static void
2252 org_atheme_audacious_playqueue_is_queued_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
2253 {
2254  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
2255  GError *error = NULL;
2256  gboolean OUT_is_queued;
2257  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_BOOLEAN, &OUT_is_queued, G_TYPE_INVALID);
2258  (*(org_atheme_audacious_playqueue_is_queued_reply)data->cb) (proxy, OUT_is_queued, error, data->userdata);
2259  return;
2260 }
2261 
2262 static
2263 #ifdef G_HAVE_INLINE
2264 inline
2265 #endif
2266 DBusGProxyCall*
2267 org_atheme_audacious_playqueue_is_queued_async (DBusGProxy *proxy, const gint IN_pos, org_atheme_audacious_playqueue_is_queued_reply callback, gpointer userdata)
2268 
2269 {
2270  DBusGAsyncData *stuff;
2271  stuff = g_slice_new (DBusGAsyncData);
2272  stuff->cb = G_CALLBACK (callback);
2273  stuff->userdata = userdata;
2274  return dbus_g_proxy_begin_call (proxy, "PlayqueueIsQueued", org_atheme_audacious_playqueue_is_queued_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INT, IN_pos, G_TYPE_INVALID);
2275 }
2276 static
2277 #ifdef G_HAVE_INLINE
2278 inline
2279 #endif
2280 gboolean
2281 org_atheme_audacious_playlist_enqueue_to_temp (DBusGProxy *proxy, const char * IN_url, GError **error)
2282 
2283 {
2284  return dbus_g_proxy_call (proxy, "PlaylistEnqueueToTemp", error, G_TYPE_STRING, IN_url, G_TYPE_INVALID, G_TYPE_INVALID);
2285 }
2286 
2287 typedef void (*org_atheme_audacious_playlist_enqueue_to_temp_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
2288 
2289 static void
2290 org_atheme_audacious_playlist_enqueue_to_temp_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
2291 {
2292  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
2293  GError *error = NULL;
2294  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
2295  (*(org_atheme_audacious_playlist_enqueue_to_temp_reply)data->cb) (proxy, error, data->userdata);
2296  return;
2297 }
2298 
2299 static
2300 #ifdef G_HAVE_INLINE
2301 inline
2302 #endif
2303 DBusGProxyCall*
2304 org_atheme_audacious_playlist_enqueue_to_temp_async (DBusGProxy *proxy, const char * IN_url, org_atheme_audacious_playlist_enqueue_to_temp_reply callback, gpointer userdata)
2305 
2306 {
2307  DBusGAsyncData *stuff;
2308  stuff = g_slice_new (DBusGAsyncData);
2309  stuff->cb = G_CALLBACK (callback);
2310  stuff->userdata = userdata;
2311  return dbus_g_proxy_begin_call (proxy, "PlaylistEnqueueToTemp", org_atheme_audacious_playlist_enqueue_to_temp_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_STRING, IN_url, G_TYPE_INVALID);
2312 }
2313 static
2314 #ifdef G_HAVE_INLINE
2315 inline
2316 #endif
2317 gboolean
2318 org_atheme_audacious_get_eq (DBusGProxy *proxy, gdouble* OUT_preamp, GArray** OUT_bands, GError **error)
2319 
2320 {
2321  return dbus_g_proxy_call (proxy, "GetEq", error, G_TYPE_INVALID, G_TYPE_DOUBLE, OUT_preamp, dbus_g_type_get_collection ("GArray", G_TYPE_DOUBLE), OUT_bands, G_TYPE_INVALID);
2322 }
2323 
2324 typedef void (*org_atheme_audacious_get_eq_reply) (DBusGProxy *proxy, gdouble OUT_preamp, GArray *OUT_bands, GError *error, gpointer userdata);
2325 
2326 static void
2327 org_atheme_audacious_get_eq_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
2328 {
2329  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
2330  GError *error = NULL;
2331  gdouble OUT_preamp;
2332  GArray* OUT_bands;
2333  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_DOUBLE, &OUT_preamp, dbus_g_type_get_collection ("GArray", G_TYPE_DOUBLE), &OUT_bands, G_TYPE_INVALID);
2334  (*(org_atheme_audacious_get_eq_reply)data->cb) (proxy, OUT_preamp, OUT_bands, error, data->userdata);
2335  return;
2336 }
2337 
2338 static
2339 #ifdef G_HAVE_INLINE
2340 inline
2341 #endif
2342 DBusGProxyCall*
2343 org_atheme_audacious_get_eq_async (DBusGProxy *proxy, org_atheme_audacious_get_eq_reply callback, gpointer userdata)
2344 
2345 {
2346  DBusGAsyncData *stuff;
2347  stuff = g_slice_new (DBusGAsyncData);
2348  stuff->cb = G_CALLBACK (callback);
2349  stuff->userdata = userdata;
2350  return dbus_g_proxy_begin_call (proxy, "GetEq", org_atheme_audacious_get_eq_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
2351 }
2352 static
2353 #ifdef G_HAVE_INLINE
2354 inline
2355 #endif
2356 gboolean
2357 org_atheme_audacious_get_eq_preamp (DBusGProxy *proxy, gdouble* OUT_preamp, GError **error)
2358 
2359 {
2360  return dbus_g_proxy_call (proxy, "GetEqPreamp", error, G_TYPE_INVALID, G_TYPE_DOUBLE, OUT_preamp, G_TYPE_INVALID);
2361 }
2362 
2363 typedef void (*org_atheme_audacious_get_eq_preamp_reply) (DBusGProxy *proxy, gdouble OUT_preamp, GError *error, gpointer userdata);
2364 
2365 static void
2366 org_atheme_audacious_get_eq_preamp_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
2367 {
2368  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
2369  GError *error = NULL;
2370  gdouble OUT_preamp;
2371  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_DOUBLE, &OUT_preamp, G_TYPE_INVALID);
2372  (*(org_atheme_audacious_get_eq_preamp_reply)data->cb) (proxy, OUT_preamp, error, data->userdata);
2373  return;
2374 }
2375 
2376 static
2377 #ifdef G_HAVE_INLINE
2378 inline
2379 #endif
2380 DBusGProxyCall*
2382 
2383 {
2384  DBusGAsyncData *stuff;
2385  stuff = g_slice_new (DBusGAsyncData);
2386  stuff->cb = G_CALLBACK (callback);
2387  stuff->userdata = userdata;
2388  return dbus_g_proxy_begin_call (proxy, "GetEqPreamp", org_atheme_audacious_get_eq_preamp_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
2389 }
2390 static
2391 #ifdef G_HAVE_INLINE
2392 inline
2393 #endif
2394 gboolean
2395 org_atheme_audacious_get_eq_band (DBusGProxy *proxy, const gint IN_band, gdouble* OUT_value, GError **error)
2396 
2397 {
2398  return dbus_g_proxy_call (proxy, "GetEqBand", error, G_TYPE_INT, IN_band, G_TYPE_INVALID, G_TYPE_DOUBLE, OUT_value, G_TYPE_INVALID);
2399 }
2400 
2401 typedef void (*org_atheme_audacious_get_eq_band_reply) (DBusGProxy *proxy, gdouble OUT_value, GError *error, gpointer userdata);
2402 
2403 static void
2404 org_atheme_audacious_get_eq_band_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
2405 {
2406  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
2407  GError *error = NULL;
2408  gdouble OUT_value;
2409  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_DOUBLE, &OUT_value, G_TYPE_INVALID);
2410  (*(org_atheme_audacious_get_eq_band_reply)data->cb) (proxy, OUT_value, error, data->userdata);
2411  return;
2412 }
2413 
2414 static
2415 #ifdef G_HAVE_INLINE
2416 inline
2417 #endif
2418 DBusGProxyCall*
2419 org_atheme_audacious_get_eq_band_async (DBusGProxy *proxy, const gint IN_band, org_atheme_audacious_get_eq_band_reply callback, gpointer userdata)
2420 
2421 {
2422  DBusGAsyncData *stuff;
2423  stuff = g_slice_new (DBusGAsyncData);
2424  stuff->cb = G_CALLBACK (callback);
2425  stuff->userdata = userdata;
2426  return dbus_g_proxy_begin_call (proxy, "GetEqBand", org_atheme_audacious_get_eq_band_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INT, IN_band, G_TYPE_INVALID);
2427 }
2428 static
2429 #ifdef G_HAVE_INLINE
2430 inline
2431 #endif
2432 gboolean
2433 org_atheme_audacious_set_eq (DBusGProxy *proxy, const gdouble IN_preamp, const GArray* IN_bands, GError **error)
2434 
2435 {
2436  return dbus_g_proxy_call (proxy, "SetEq", error, G_TYPE_DOUBLE, IN_preamp, dbus_g_type_get_collection ("GArray", G_TYPE_DOUBLE), IN_bands, G_TYPE_INVALID, G_TYPE_INVALID);
2437 }
2438 
2439 typedef void (*org_atheme_audacious_set_eq_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
2440 
2441 static void
2442 org_atheme_audacious_set_eq_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
2443 {
2444  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
2445  GError *error = NULL;
2446  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
2447  (*(org_atheme_audacious_set_eq_reply)data->cb) (proxy, error, data->userdata);
2448  return;
2449 }
2450 
2451 static
2452 #ifdef G_HAVE_INLINE
2453 inline
2454 #endif
2455 DBusGProxyCall*
2456 org_atheme_audacious_set_eq_async (DBusGProxy *proxy, const gdouble IN_preamp, const GArray* IN_bands, org_atheme_audacious_set_eq_reply callback, gpointer userdata)
2457 
2458 {
2459  DBusGAsyncData *stuff;
2460  stuff = g_slice_new (DBusGAsyncData);
2461  stuff->cb = G_CALLBACK (callback);
2462  stuff->userdata = userdata;
2463  return dbus_g_proxy_begin_call (proxy, "SetEq", org_atheme_audacious_set_eq_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_DOUBLE, IN_preamp, dbus_g_type_get_collection ("GArray", G_TYPE_DOUBLE), IN_bands, G_TYPE_INVALID);
2464 }
2465 static
2466 #ifdef G_HAVE_INLINE
2467 inline
2468 #endif
2469 gboolean
2470 org_atheme_audacious_set_eq_preamp (DBusGProxy *proxy, const gdouble IN_preamp, GError **error)
2471 
2472 {
2473  return dbus_g_proxy_call (proxy, "SetEqPreamp", error, G_TYPE_DOUBLE, IN_preamp, G_TYPE_INVALID, G_TYPE_INVALID);
2474 }
2475 
2476 typedef void (*org_atheme_audacious_set_eq_preamp_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
2477 
2478 static void
2479 org_atheme_audacious_set_eq_preamp_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
2480 {
2481  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
2482  GError *error = NULL;
2483  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
2484  (*(org_atheme_audacious_set_eq_preamp_reply)data->cb) (proxy, error, data->userdata);
2485  return;
2486 }
2487 
2488 static
2489 #ifdef G_HAVE_INLINE
2490 inline
2491 #endif
2492 DBusGProxyCall*
2493 org_atheme_audacious_set_eq_preamp_async (DBusGProxy *proxy, const gdouble IN_preamp, org_atheme_audacious_set_eq_preamp_reply callback, gpointer userdata)
2494 
2495 {
2496  DBusGAsyncData *stuff;
2497  stuff = g_slice_new (DBusGAsyncData);
2498  stuff->cb = G_CALLBACK (callback);
2499  stuff->userdata = userdata;
2500  return dbus_g_proxy_begin_call (proxy, "SetEqPreamp", org_atheme_audacious_set_eq_preamp_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_DOUBLE, IN_preamp, G_TYPE_INVALID);
2501 }
2502 static
2503 #ifdef G_HAVE_INLINE
2504 inline
2505 #endif
2506 gboolean
2507 org_atheme_audacious_set_eq_band (DBusGProxy *proxy, const gint IN_band, const gdouble IN_value, GError **error)
2508 
2509 {
2510  return dbus_g_proxy_call (proxy, "SetEqBand", error, G_TYPE_INT, IN_band, G_TYPE_DOUBLE, IN_value, G_TYPE_INVALID, G_TYPE_INVALID);
2511 }
2512 
2513 typedef void (*org_atheme_audacious_set_eq_band_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
2514 
2515 static void
2516 org_atheme_audacious_set_eq_band_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
2517 {
2518  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
2519  GError *error = NULL;
2520  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
2521  (*(org_atheme_audacious_set_eq_band_reply)data->cb) (proxy, error, data->userdata);
2522  return;
2523 }
2524 
2525 static
2526 #ifdef G_HAVE_INLINE
2527 inline
2528 #endif
2529 DBusGProxyCall*
2530 org_atheme_audacious_set_eq_band_async (DBusGProxy *proxy, const gint IN_band, const gdouble IN_value, org_atheme_audacious_set_eq_band_reply callback, gpointer userdata)
2531 
2532 {
2533  DBusGAsyncData *stuff;
2534  stuff = g_slice_new (DBusGAsyncData);
2535  stuff->cb = G_CALLBACK (callback);
2536  stuff->userdata = userdata;
2537  return dbus_g_proxy_begin_call (proxy, "SetEqBand", org_atheme_audacious_set_eq_band_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INT, IN_band, G_TYPE_DOUBLE, IN_value, G_TYPE_INVALID);
2538 }
2539 static
2540 #ifdef G_HAVE_INLINE
2541 inline
2542 #endif
2543 gboolean
2544 org_atheme_audacious_equalizer_activate (DBusGProxy *proxy, const gboolean IN_active, GError **error)
2545 
2546 {
2547  return dbus_g_proxy_call (proxy, "EqualizerActivate", error, G_TYPE_BOOLEAN, IN_active, G_TYPE_INVALID, G_TYPE_INVALID);
2548 }
2549 
2550 typedef void (*org_atheme_audacious_equalizer_activate_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
2551 
2552 static void
2553 org_atheme_audacious_equalizer_activate_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
2554 {
2555  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
2556  GError *error = NULL;
2557  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
2558  (*(org_atheme_audacious_equalizer_activate_reply)data->cb) (proxy, error, data->userdata);
2559  return;
2560 }
2561 
2562 static
2563 #ifdef G_HAVE_INLINE
2564 inline
2565 #endif
2566 DBusGProxyCall*
2567 org_atheme_audacious_equalizer_activate_async (DBusGProxy *proxy, const gboolean IN_active, org_atheme_audacious_equalizer_activate_reply callback, gpointer userdata)
2568 
2569 {
2570  DBusGAsyncData *stuff;
2571  stuff = g_slice_new (DBusGAsyncData);
2572  stuff->cb = G_CALLBACK (callback);
2573  stuff->userdata = userdata;
2574  return dbus_g_proxy_begin_call (proxy, "EqualizerActivate", org_atheme_audacious_equalizer_activate_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_BOOLEAN, IN_active, G_TYPE_INVALID);
2575 }
2576 static
2577 #ifdef G_HAVE_INLINE
2578 inline
2579 #endif
2580 gboolean
2581 org_atheme_audacious_get_active_playlist_name (DBusGProxy *proxy, char ** OUT_plname, GError **error)
2582 
2583 {
2584  return dbus_g_proxy_call (proxy, "GetActivePlaylistName", error, G_TYPE_INVALID, G_TYPE_STRING, OUT_plname, G_TYPE_INVALID);
2585 }
2586 
2587 typedef void (*org_atheme_audacious_get_active_playlist_name_reply) (DBusGProxy *proxy, char * OUT_plname, GError *error, gpointer userdata);
2588 
2589 static void
2590 org_atheme_audacious_get_active_playlist_name_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
2591 {
2592  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
2593  GError *error = NULL;
2594  char * OUT_plname;
2595  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_STRING, &OUT_plname, G_TYPE_INVALID);
2596  (*(org_atheme_audacious_get_active_playlist_name_reply)data->cb) (proxy, OUT_plname, error, data->userdata);
2597  return;
2598 }
2599 
2600 static
2601 #ifdef G_HAVE_INLINE
2602 inline
2603 #endif
2604 DBusGProxyCall*
2606 
2607 {
2608  DBusGAsyncData *stuff;
2609  stuff = g_slice_new (DBusGAsyncData);
2610  stuff->cb = G_CALLBACK (callback);
2611  stuff->userdata = userdata;
2612  return dbus_g_proxy_begin_call (proxy, "GetActivePlaylistName", org_atheme_audacious_get_active_playlist_name_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
2613 }
2614 #endif /* defined DBUS_GLIB_CLIENT_WRAPPERS_org_atheme_audacious */
2615 
2616 G_END_DECLS
static void org_atheme_audacious_set_volume_async_callback(DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
static gboolean org_atheme_audacious_add_list(DBusGProxy *proxy, const char **IN_filenames, GError **error)
static void org_atheme_audacious_open_list_async_callback(DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
static gboolean org_atheme_audacious_playlist_ins_url_string(DBusGProxy *proxy, const char *IN_url, const gint IN_pos, GError **error)
static DBusGProxyCall * org_atheme_audacious_reverse_async(DBusGProxy *proxy, org_atheme_audacious_reverse_reply callback, gpointer userdata)
static DBusGProxyCall * org_atheme_audacious_set_eq_async(DBusGProxy *proxy, const gdouble IN_preamp, const GArray *IN_bands, org_atheme_audacious_set_eq_reply callback, gpointer userdata)
static gboolean org_atheme_audacious_get_playqueue_length(DBusGProxy *proxy, gint *OUT_length, GError **error)
static gboolean org_atheme_audacious_status(DBusGProxy *proxy, char **OUT_status, GError **error)
void(* org_atheme_audacious_song_filename_reply)(DBusGProxy *proxy, char *OUT_filename, GError *error, gpointer userdata)
static void org_atheme_audacious_queue_get_queue_pos_async_callback(DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
static DBusGProxyCall * org_atheme_audacious_shuffle_async(DBusGProxy *proxy, org_atheme_audacious_shuffle_reply callback, gpointer userdata)
static void org_atheme_audacious_position_async_callback(DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
static gboolean org_atheme_audacious_get_eq_band(DBusGProxy *proxy, const gint IN_band, gdouble *OUT_value, GError **error)
static void org_atheme_audacious_play_pause_async_callback(DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
static DBusGProxyCall * org_atheme_audacious_toggle_aot_async(DBusGProxy *proxy, const gboolean IN_ontop, org_atheme_audacious_toggle_aot_reply callback, gpointer userdata)
static gboolean org_atheme_audacious_pause(DBusGProxy *proxy, GError **error)
static gboolean org_atheme_audacious_set_eq_band(DBusGProxy *proxy, const gint IN_band, const gdouble IN_value, GError **error)
void(* org_atheme_audacious_repeat_reply)(DBusGProxy *proxy, gboolean OUT_is_repeat, GError *error, gpointer userdata)
static gboolean org_atheme_audacious_toggle_auto_advance(DBusGProxy *proxy, GError **error)
static DBusGProxyCall * org_atheme_audacious_main_win_visible_async(DBusGProxy *proxy, org_atheme_audacious_main_win_visible_reply callback, gpointer userdata)
static gboolean org_atheme_audacious_playing(DBusGProxy *proxy, gboolean *OUT_is_playing, GError **error)
static gboolean org_atheme_audacious_queue_get_queue_pos(DBusGProxy *proxy, const guint IN_pos, guint *OUT_qpos, GError **error)
void(* org_atheme_audacious_show_prefs_box_reply)(DBusGProxy *proxy, GError *error, gpointer userdata)
void(* org_atheme_audacious_info_reply)(DBusGProxy *proxy, gint OUT_rate, gint OUT_freq, gint OUT_nch, GError *error, gpointer userdata)
static void org_atheme_audacious_seek_async_callback(DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
void(* org_atheme_audacious_playing_reply)(DBusGProxy *proxy, gboolean OUT_is_playing, GError *error, gpointer userdata)
void(* org_atheme_audacious_position_reply)(DBusGProxy *proxy, guint OUT_pos, GError *error, gpointer userdata)
static gboolean org_atheme_audacious_seek(DBusGProxy *proxy, const guint IN_pos, GError **error)
static gboolean org_atheme_audacious_playlist_enqueue_to_temp(DBusGProxy *proxy, const char *IN_url, GError **error)
static gboolean org_atheme_audacious_show_jtf_box(DBusGProxy *proxy, const gboolean IN_show, GError **error)
static gboolean org_atheme_audacious_toggle_stop_after(DBusGProxy *proxy, GError **error)
static void org_atheme_audacious_show_about_box_async_callback(DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
static DBusGProxyCall * org_atheme_audacious_open_list_async(DBusGProxy *proxy, const char **IN_filenames, org_atheme_audacious_open_list_reply callback, gpointer userdata)
void(* org_atheme_audacious_main_win_visible_reply)(DBusGProxy *proxy, gboolean OUT_is_main_win, GError *error, gpointer userdata)
static void org_atheme_audacious_reverse_async_callback(DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
static gboolean org_atheme_audacious_delete(DBusGProxy *proxy, const guint IN_pos, GError **error)
void(* org_atheme_audacious_show_about_box_reply)(DBusGProxy *proxy, GError *error, gpointer userdata)
static gboolean org_atheme_audacious_paused(DBusGProxy *proxy, gboolean *OUT_is_paused, GError **error)
static DBusGProxyCall * org_atheme_audacious_seek_async(DBusGProxy *proxy, const guint IN_pos, org_atheme_audacious_seek_reply callback, gpointer userdata)
static gboolean org_atheme_audacious_set_eq_preamp(DBusGProxy *proxy, const gdouble IN_preamp, GError **error)
void(* org_atheme_audacious_get_active_playlist_name_reply)(DBusGProxy *proxy, char *OUT_plname, GError *error, gpointer userdata)
static gboolean org_atheme_audacious_open_list_to_temp(DBusGProxy *proxy, const char **IN_filenames, GError **error)
static gboolean org_atheme_audacious_advance(DBusGProxy *proxy, GError **error)
static void org_atheme_audacious_show_filebrowser_async_callback(DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
static DBusGProxyCall * org_atheme_audacious_get_info_async(DBusGProxy *proxy, org_atheme_audacious_get_info_reply callback, gpointer userdata)
static void org_atheme_audacious_info_async_callback(DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
void(* org_atheme_audacious_get_playqueue_length_reply)(DBusGProxy *proxy, gint OUT_length, GError *error, gpointer userdata)
static gboolean org_atheme_audacious_stop_after(DBusGProxy *proxy, gboolean *OUT_is_stopping, GError **error)
static void org_atheme_audacious_advance_async_callback(DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
static DBusGProxyCall * org_atheme_audacious_volume_async(DBusGProxy *proxy, org_atheme_audacious_volume_reply callback, gpointer userdata)
void(* org_atheme_audacious_song_frames_reply)(DBusGProxy *proxy, gint OUT_length, GError *error, gpointer userdata)
static DBusGProxyCall * org_atheme_audacious_playqueue_clear_async(DBusGProxy *proxy, org_atheme_audacious_playqueue_clear_reply callback, gpointer userdata)
static void org_atheme_audacious_show_prefs_box_async_callback(DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
static gboolean org_atheme_audacious_playqueue_add(DBusGProxy *proxy, const gint IN_pos, GError **error)
static void org_atheme_audacious_stop_async_callback(DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
static DBusGProxyCall * org_atheme_audacious_status_async(DBusGProxy *proxy, org_atheme_audacious_status_reply callback, gpointer userdata)
static DBusGProxyCall * org_atheme_audacious_song_title_async(DBusGProxy *proxy, const guint IN_pos, org_atheme_audacious_song_title_reply callback, gpointer userdata)
static void org_atheme_audacious_toggle_aot_async_callback(DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
static DBusGProxyCall * org_atheme_audacious_add_list_async(DBusGProxy *proxy, const char **IN_filenames, org_atheme_audacious_add_list_reply callback, gpointer userdata)
static void org_atheme_audacious_open_list_to_temp_async_callback(DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
static gboolean org_atheme_audacious_play_pause(DBusGProxy *proxy, GError **error)
static void org_atheme_audacious_stopped_async_callback(DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
void(* org_atheme_audacious_toggle_aot_reply)(DBusGProxy *proxy, GError *error, gpointer userdata)
void(* org_atheme_audacious_advance_reply)(DBusGProxy *proxy, GError *error, gpointer userdata)
static gboolean org_atheme_audacious_toggle_aot(DBusGProxy *proxy, const gboolean IN_ontop, GError **error)
static gboolean org_atheme_audacious_version(DBusGProxy *proxy, char **OUT_version, GError **error)
void(* org_atheme_audacious_length_reply)(DBusGProxy *proxy, gint OUT_length, GError *error, gpointer userdata)
void(* org_atheme_audacious_open_list_to_temp_reply)(DBusGProxy *proxy, GError *error, gpointer userdata)
static gboolean org_atheme_audacious_playlist_add(DBusGProxy *proxy, const char *IN_list, GError **error)
void(* org_atheme_audacious_playlist_enqueue_to_temp_reply)(DBusGProxy *proxy, GError *error, gpointer userdata)
void(* org_atheme_audacious_set_eq_preamp_reply)(DBusGProxy *proxy, GError *error, gpointer userdata)
static void org_atheme_audacious_playqueue_remove_async_callback(DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
void(* org_atheme_audacious_toggle_shuffle_reply)(DBusGProxy *proxy, GError *error, gpointer userdata)
static void org_atheme_audacious_song_frames_async_callback(DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
void(* org_atheme_audacious_playqueue_is_queued_reply)(DBusGProxy *proxy, gboolean OUT_is_queued, GError *error, gpointer userdata)
static void org_atheme_audacious_delete_async_callback(DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
void(* org_atheme_audacious_play_pause_reply)(DBusGProxy *proxy, GError *error, gpointer userdata)
static void org_atheme_audacious_toggle_auto_advance_async_callback(DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
static gboolean org_atheme_audacious_show_filebrowser(DBusGProxy *proxy, const gboolean IN_show, GError **error)
static gboolean org_atheme_audacious_playqueue_is_queued(DBusGProxy *proxy, const gint IN_pos, gboolean *OUT_is_queued, GError **error)
void(* org_atheme_audacious_stopped_reply)(DBusGProxy *proxy, gboolean OUT_is_stopped, GError *error, gpointer userdata)
static void org_atheme_audacious_jump_async_callback(DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
static void org_atheme_audacious_set_eq_preamp_async_callback(DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
void(* org_atheme_audacious_toggle_auto_advance_reply)(DBusGProxy *proxy, GError *error, gpointer userdata)
static void org_atheme_audacious_add_url_async_callback(DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
static DBusGProxyCall * org_atheme_audacious_jump_async(DBusGProxy *proxy, const guint IN_pos, org_atheme_audacious_jump_reply callback, gpointer userdata)
static void org_atheme_audacious_song_title_async_callback(DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
void(* org_atheme_audacious_playqueue_remove_reply)(DBusGProxy *proxy, GError *error, gpointer userdata)
void(* org_atheme_audacious_song_tuple_reply)(DBusGProxy *proxy, GValue OUT_value, GError *error, gpointer userdata)
void(* org_atheme_audacious_time_reply)(DBusGProxy *proxy, guint OUT_time, GError *error, gpointer userdata)
static gboolean org_atheme_audacious_main_win_visible(DBusGProxy *proxy, gboolean *OUT_is_main_win, GError **error)
static void org_atheme_audacious_get_eq_preamp_async_callback(DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
static DBusGProxyCall * org_atheme_audacious_show_prefs_box_async(DBusGProxy *proxy, const gboolean IN_show, org_atheme_audacious_show_prefs_box_reply callback, gpointer userdata)
void(* org_atheme_audacious_show_jtf_box_reply)(DBusGProxy *proxy, GError *error, gpointer userdata)
static void org_atheme_audacious_add_list_async_callback(DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
void(* org_atheme_audacious_stop_reply)(DBusGProxy *proxy, GError *error, gpointer userdata)
static gboolean org_atheme_audacious_add(DBusGProxy *proxy, const char *IN_file, GError **error)
static void org_atheme_audacious_status_async_callback(DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
static void org_atheme_audacious_volume_async_callback(DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
void(* org_atheme_audacious_pause_reply)(DBusGProxy *proxy, GError *error, gpointer userdata)
void(* org_atheme_audacious_auto_advance_reply)(DBusGProxy *proxy, gboolean OUT_is_advance, GError *error, gpointer userdata)
void(* org_atheme_audacious_equalizer_activate_reply)(DBusGProxy *proxy, GError *error, gpointer userdata)
static gboolean org_atheme_audacious_get_tuple_fields(DBusGProxy *proxy, char ***OUT_fields, GError **error)
static DBusGProxyCall * org_atheme_audacious_toggle_stop_after_async(DBusGProxy *proxy, org_atheme_audacious_toggle_stop_after_reply callback, gpointer userdata)
static void org_atheme_audacious_get_info_async_callback(DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
static DBusGProxyCall * org_atheme_audacious_get_eq_preamp_async(DBusGProxy *proxy, org_atheme_audacious_get_eq_preamp_reply callback, gpointer userdata)
static DBusGProxyCall * org_atheme_audacious_song_filename_async(DBusGProxy *proxy, const guint IN_pos, org_atheme_audacious_song_filename_reply callback, gpointer userdata)
static DBusGProxyCall * org_atheme_audacious_length_async(DBusGProxy *proxy, org_atheme_audacious_length_reply callback, gpointer userdata)
static void org_atheme_audacious_paused_async_callback(DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
void(* org_atheme_audacious_volume_reply)(DBusGProxy *proxy, gint OUT_vl, gint OUT_vr, GError *error, gpointer userdata)
void(* org_atheme_audacious_get_info_reply)(DBusGProxy *proxy, gint OUT_rate, gint OUT_freq, gint OUT_nch, GError *error, gpointer userdata)
static DBusGProxyCall * org_atheme_audacious_show_filebrowser_async(DBusGProxy *proxy, const gboolean IN_show, org_atheme_audacious_show_filebrowser_reply callback, gpointer userdata)
static void org_atheme_audacious_pause_async_callback(DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
static DBusGProxyCall * org_atheme_audacious_set_eq_band_async(DBusGProxy *proxy, const gint IN_band, const gdouble IN_value, org_atheme_audacious_set_eq_band_reply callback, gpointer userdata)
static DBusGProxyCall * org_atheme_audacious_song_frames_async(DBusGProxy *proxy, const guint IN_pos, org_atheme_audacious_song_frames_reply callback, gpointer userdata)
void(* org_atheme_audacious_queue_get_list_pos_reply)(DBusGProxy *proxy, guint OUT_pos, GError *error, gpointer userdata)
static gboolean org_atheme_audacious_song_length(DBusGProxy *proxy, const guint IN_pos, gint *OUT_length, GError **error)
static DBusGProxyCall * org_atheme_audacious_playlist_enqueue_to_temp_async(DBusGProxy *proxy, const char *IN_url, org_atheme_audacious_playlist_enqueue_to_temp_reply callback, gpointer userdata)
static DBusGProxyCall * org_atheme_audacious_play_pause_async(DBusGProxy *proxy, org_atheme_audacious_play_pause_reply callback, gpointer userdata)
static gboolean org_atheme_audacious_stopped(DBusGProxy *proxy, gboolean *OUT_is_stopped, GError **error)
static DBusGProxyCall * org_atheme_audacious_get_active_playlist_name_async(DBusGProxy *proxy, org_atheme_audacious_get_active_playlist_name_reply callback, gpointer userdata)
static void org_atheme_audacious_toggle_stop_after_async_callback(DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
static DBusGProxyCall * org_atheme_audacious_playqueue_remove_async(DBusGProxy *proxy, const gint IN_pos, org_atheme_audacious_playqueue_remove_reply callback, gpointer userdata)
static gboolean org_atheme_audacious_show_prefs_box(DBusGProxy *proxy, const gboolean IN_show, GError **error)
#define NULL
Definition: core.h:27
static DBusGProxyCall * org_atheme_audacious_stop_after_async(DBusGProxy *proxy, org_atheme_audacious_stop_after_reply callback, gpointer userdata)
static gboolean org_atheme_audacious_jump(DBusGProxy *proxy, const guint IN_pos, GError **error)
static DBusGProxyCall * org_atheme_audacious_song_length_async(DBusGProxy *proxy, const guint IN_pos, org_atheme_audacious_song_length_reply callback, gpointer userdata)
static void org_atheme_audacious_version_async_callback(DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
static gboolean org_atheme_audacious_set_eq(DBusGProxy *proxy, const gdouble IN_preamp, const GArray *IN_bands, GError **error)
static void org_atheme_audacious_show_main_win_async_callback(DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
void(* org_atheme_audacious_stop_after_reply)(DBusGProxy *proxy, gboolean OUT_is_stopping, GError *error, gpointer userdata)
void(* org_atheme_audacious_delete_reply)(DBusGProxy *proxy, GError *error, gpointer userdata)
static GError * error
Definition: audctrl.c:30
void(* org_atheme_audacious_set_eq_band_reply)(DBusGProxy *proxy, GError *error, gpointer userdata)
static gboolean org_atheme_audacious_get_active_playlist_name(DBusGProxy *proxy, char **OUT_plname, GError **error)
static void org_atheme_audacious_eject_async_callback(DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
static DBusGProxyCall * org_atheme_audacious_queue_get_queue_pos_async(DBusGProxy *proxy, const guint IN_pos, org_atheme_audacious_queue_get_queue_pos_reply callback, gpointer userdata)
void(* org_atheme_audacious_queue_get_queue_pos_reply)(DBusGProxy *proxy, guint OUT_qpos, GError *error, gpointer userdata)
void(* org_atheme_audacious_song_title_reply)(DBusGProxy *proxy, char *OUT_title, GError *error, gpointer userdata)
void(* org_atheme_audacious_status_reply)(DBusGProxy *proxy, char *OUT_status, GError *error, gpointer userdata)
static DBusGProxyCall * org_atheme_audacious_playlist_add_async(DBusGProxy *proxy, const char *IN_list, org_atheme_audacious_playlist_add_reply callback, gpointer userdata)
static DBusGProxyCall * org_atheme_audacious_open_list_to_temp_async(DBusGProxy *proxy, const char **IN_filenames, org_atheme_audacious_open_list_to_temp_reply callback, gpointer userdata)
static DBusGProxyCall * org_atheme_audacious_eject_async(DBusGProxy *proxy, org_atheme_audacious_eject_reply callback, gpointer userdata)
void(* org_atheme_audacious_get_tuple_fields_reply)(DBusGProxy *proxy, char **OUT_fields, GError *error, gpointer userdata)
void(* org_atheme_audacious_play_reply)(DBusGProxy *proxy, GError *error, gpointer userdata)
static void org_atheme_audacious_playlist_enqueue_to_temp_async_callback(DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
static gboolean org_atheme_audacious_position(DBusGProxy *proxy, guint *OUT_pos, GError **error)
static DBusGProxyCall * org_atheme_audacious_song_tuple_async(DBusGProxy *proxy, const guint IN_pos, const char *IN_tuple, org_atheme_audacious_song_tuple_reply callback, gpointer userdata)
static void org_atheme_audacious_repeat_async_callback(DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
static void org_atheme_audacious_time_async_callback(DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
static void org_atheme_audacious_shuffle_async_callback(DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
static void org_atheme_audacious_toggle_shuffle_async_callback(DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
static void org_atheme_audacious_playlist_add_async_callback(DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
static gboolean org_atheme_audacious_queue_get_list_pos(DBusGProxy *proxy, const guint IN_qpos, guint *OUT_pos, GError **error)
static gboolean org_atheme_audacious_length(DBusGProxy *proxy, gint *OUT_length, GError **error)
static void org_atheme_audacious_set_eq_async_callback(DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
static DBusGProxyCall * org_atheme_audacious_show_jtf_box_async(DBusGProxy *proxy, const gboolean IN_show, org_atheme_audacious_show_jtf_box_reply callback, gpointer userdata)
static DBusGProxyCall * org_atheme_audacious_get_playqueue_length_async(DBusGProxy *proxy, org_atheme_audacious_get_playqueue_length_reply callback, gpointer userdata)
static gboolean org_atheme_audacious_auto_advance(DBusGProxy *proxy, gboolean *OUT_is_advance, GError **error)
static DBusGProxyCall * org_atheme_audacious_equalizer_activate_async(DBusGProxy *proxy, const gboolean IN_active, org_atheme_audacious_equalizer_activate_reply callback, gpointer userdata)
static gboolean org_atheme_audacious_toggle_shuffle(DBusGProxy *proxy, GError **error)
void(* org_atheme_audacious_version_reply)(DBusGProxy *proxy, char *OUT_version, GError *error, gpointer userdata)
void(* org_atheme_audacious_playqueue_clear_reply)(DBusGProxy *proxy, GError *error, gpointer userdata)
static gboolean org_atheme_audacious_equalizer_activate(DBusGProxy *proxy, const gboolean IN_active, GError **error)
static gboolean org_atheme_audacious_volume(DBusGProxy *proxy, gint *OUT_vl, gint *OUT_vr, GError **error)
static DBusGProxyCall * org_atheme_audacious_set_eq_preamp_async(DBusGProxy *proxy, const gdouble IN_preamp, org_atheme_audacious_set_eq_preamp_reply callback, gpointer userdata)
static void org_atheme_audacious_get_active_playlist_name_async_callback(DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
static void org_atheme_audacious_song_filename_async_callback(DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
void(* org_atheme_audacious_song_length_reply)(DBusGProxy *proxy, gint OUT_length, GError *error, gpointer userdata)
static void org_atheme_audacious_length_async_callback(DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
static DBusGProxyCall * org_atheme_audacious_toggle_shuffle_async(DBusGProxy *proxy, org_atheme_audacious_toggle_shuffle_reply callback, gpointer userdata)
static void org_atheme_audacious_playing_async_callback(DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
static void org_atheme_audacious_main_win_visible_async_callback(DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
static gboolean org_atheme_audacious_play(DBusGProxy *proxy, GError **error)
static gboolean org_atheme_audacious_playqueue_remove(DBusGProxy *proxy, const gint IN_pos, GError **error)
static gboolean org_atheme_audacious_stop(DBusGProxy *proxy, GError **error)
static gboolean org_atheme_audacious_song_filename(DBusGProxy *proxy, const guint IN_pos, char **OUT_filename, GError **error)
void(* org_atheme_audacious_get_eq_reply)(DBusGProxy *proxy, gdouble OUT_preamp, GArray *OUT_bands, GError *error, gpointer userdata)
static gboolean org_atheme_audacious_song_tuple(DBusGProxy *proxy, const guint IN_pos, const char *IN_tuple, GValue *OUT_value, GError **error)
static gboolean org_atheme_audacious_quit(DBusGProxy *proxy, GError **error)
void(* org_atheme_audacious_show_main_win_reply)(DBusGProxy *proxy, GError *error, gpointer userdata)
static DBusGProxyCall * org_atheme_audacious_info_async(DBusGProxy *proxy, org_atheme_audacious_info_reply callback, gpointer userdata)
static void org_atheme_audacious_queue_get_list_pos_async_callback(DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
static gboolean org_atheme_audacious_clear(DBusGProxy *proxy, GError **error)
static DBusGProxyCall * org_atheme_audacious_advance_async(DBusGProxy *proxy, org_atheme_audacious_advance_reply callback, gpointer userdata)
static void org_atheme_audacious_quit_async_callback(DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
void(* org_atheme_audacious_balance_reply)(DBusGProxy *proxy, gint OUT_balance, GError *error, gpointer userdata)
static DBusGProxyCall * org_atheme_audacious_playqueue_is_queued_async(DBusGProxy *proxy, const gint IN_pos, org_atheme_audacious_playqueue_is_queued_reply callback, gpointer userdata)
static DBusGProxyCall * org_atheme_audacious_get_eq_band_async(DBusGProxy *proxy, const gint IN_band, org_atheme_audacious_get_eq_band_reply callback, gpointer userdata)
static void org_atheme_audacious_show_jtf_box_async_callback(DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
static void org_atheme_audacious_equalizer_activate_async_callback(DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
static gboolean org_atheme_audacious_eject(DBusGProxy *proxy, GError **error)
void(* org_atheme_audacious_shuffle_reply)(DBusGProxy *proxy, gboolean OUT_is_shuffle, GError *error, gpointer userdata)
static gboolean org_atheme_audacious_balance(DBusGProxy *proxy, gint *OUT_balance, GError **error)
static void org_atheme_audacious_song_length_async_callback(DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
static gboolean org_atheme_audacious_playqueue_clear(DBusGProxy *proxy, GError **error)
static DBusGProxyCall * org_atheme_audacious_stop_async(DBusGProxy *proxy, org_atheme_audacious_stop_reply callback, gpointer userdata)
static gboolean org_atheme_audacious_toggle_repeat(DBusGProxy *proxy, GError **error)
void(* org_atheme_audacious_set_volume_reply)(DBusGProxy *proxy, GError *error, gpointer userdata)
static void org_atheme_audacious_play_async_callback(DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
static DBusGProxyCall * org_atheme_audacious_stopped_async(DBusGProxy *proxy, org_atheme_audacious_stopped_reply callback, gpointer userdata)
static DBusGProxyCall * org_atheme_audacious_get_eq_async(DBusGProxy *proxy, org_atheme_audacious_get_eq_reply callback, gpointer userdata)
static DBusGProxyCall * org_atheme_audacious_time_async(DBusGProxy *proxy, org_atheme_audacious_time_reply callback, gpointer userdata)
void(* org_atheme_audacious_set_eq_reply)(DBusGProxy *proxy, GError *error, gpointer userdata)
static gboolean org_atheme_audacious_show_main_win(DBusGProxy *proxy, const gboolean IN_show, GError **error)
static DBusGProxyCall * org_atheme_audacious_show_main_win_async(DBusGProxy *proxy, const gboolean IN_show, org_atheme_audacious_show_main_win_reply callback, gpointer userdata)
static DBusGProxyCall * org_atheme_audacious_queue_get_list_pos_async(DBusGProxy *proxy, const guint IN_qpos, org_atheme_audacious_queue_get_list_pos_reply callback, gpointer userdata)
void(* org_atheme_audacious_eject_reply)(DBusGProxy *proxy, GError *error, gpointer userdata)
void(* org_atheme_audacious_add_list_reply)(DBusGProxy *proxy, GError *error, gpointer userdata)
static void org_atheme_audacious_get_eq_band_async_callback(DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
static void org_atheme_audacious_playqueue_is_queued_async_callback(DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
static void org_atheme_audacious_set_eq_band_async_callback(DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
static DBusGProxyCall * org_atheme_audacious_playlist_ins_url_string_async(DBusGProxy *proxy, const char *IN_url, const gint IN_pos, org_atheme_audacious_playlist_ins_url_string_reply callback, gpointer userdata)
void(* org_atheme_audacious_playlist_add_reply)(DBusGProxy *proxy, GError *error, gpointer userdata)
static gboolean org_atheme_audacious_shuffle(DBusGProxy *proxy, gboolean *OUT_is_shuffle, GError **error)
static void org_atheme_audacious_balance_async_callback(DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
static void org_atheme_audacious_playqueue_add_async_callback(DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
static DBusGProxyCall * org_atheme_audacious_paused_async(DBusGProxy *proxy, org_atheme_audacious_paused_reply callback, gpointer userdata)
static gboolean org_atheme_audacious_song_title(DBusGProxy *proxy, const guint IN_pos, char **OUT_title, GError **error)
static DBusGProxyCall * org_atheme_audacious_clear_async(DBusGProxy *proxy, org_atheme_audacious_clear_reply callback, gpointer userdata)
void(* org_atheme_audacious_add_url_reply)(DBusGProxy *proxy, GError *error, gpointer userdata)
static gboolean org_atheme_audacious_get_eq(DBusGProxy *proxy, gdouble *OUT_preamp, GArray **OUT_bands, GError **error)
static DBusGProxyCall * org_atheme_audacious_get_tuple_fields_async(DBusGProxy *proxy, org_atheme_audacious_get_tuple_fields_reply callback, gpointer userdata)
static void org_atheme_audacious_get_playqueue_length_async_callback(DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
static gboolean org_atheme_audacious_get_info(DBusGProxy *proxy, gint *OUT_rate, gint *OUT_freq, gint *OUT_nch, GError **error)
void(* org_atheme_audacious_paused_reply)(DBusGProxy *proxy, gboolean OUT_is_paused, GError *error, gpointer userdata)
static void org_atheme_audacious_playqueue_clear_async_callback(DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
static DBusGProxyCall * org_atheme_audacious_auto_advance_async(DBusGProxy *proxy, org_atheme_audacious_auto_advance_reply callback, gpointer userdata)
void(* org_atheme_audacious_open_list_reply)(DBusGProxy *proxy, GError *error, gpointer userdata)
static DBusGProxyCall * org_atheme_audacious_set_volume_async(DBusGProxy *proxy, const gint IN_vl, const gint IN_vr, org_atheme_audacious_set_volume_reply callback, gpointer userdata)
void(* org_atheme_audacious_toggle_stop_after_reply)(DBusGProxy *proxy, GError *error, gpointer userdata)
static void org_atheme_audacious_add_async_callback(DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
static DBusGProxyCall * org_atheme_audacious_add_url_async(DBusGProxy *proxy, const char *IN_url, org_atheme_audacious_add_url_reply callback, gpointer userdata)
static void org_atheme_audacious_song_tuple_async_callback(DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
void(* org_atheme_audacious_playqueue_add_reply)(DBusGProxy *proxy, GError *error, gpointer userdata)
static void org_atheme_audacious_auto_advance_async_callback(DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
static DBusGProxyCall * org_atheme_audacious_toggle_repeat_async(DBusGProxy *proxy, org_atheme_audacious_toggle_repeat_reply callback, gpointer userdata)
void(* org_atheme_audacious_seek_reply)(DBusGProxy *proxy, GError *error, gpointer userdata)
void(* org_atheme_audacious_jump_reply)(DBusGProxy *proxy, GError *error, gpointer userdata)
void(* org_atheme_audacious_reverse_reply)(DBusGProxy *proxy, GError *error, gpointer userdata)
static gboolean org_atheme_audacious_info(DBusGProxy *proxy, gint *OUT_rate, gint *OUT_freq, gint *OUT_nch, GError **error)
static void org_atheme_audacious_playlist_ins_url_string_async_callback(DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
static G_BEGIN_DECLS void _dbus_glib_async_data_free(gpointer stuff)
static DBusGProxyCall * org_atheme_audacious_add_async(DBusGProxy *proxy, const char *IN_file, org_atheme_audacious_add_reply callback, gpointer userdata)
static gboolean org_atheme_audacious_show_about_box(DBusGProxy *proxy, const gboolean IN_show, GError **error)
static void org_atheme_audacious_get_eq_async_callback(DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
static gboolean org_atheme_audacious_set_volume(DBusGProxy *proxy, const gint IN_vl, const gint IN_vr, GError **error)
static DBusGProxyCall * org_atheme_audacious_show_about_box_async(DBusGProxy *proxy, const gboolean IN_show, org_atheme_audacious_show_about_box_reply callback, gpointer userdata)
static void org_atheme_audacious_toggle_repeat_async_callback(DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
static DBusGProxyCall * org_atheme_audacious_play_async(DBusGProxy *proxy, org_atheme_audacious_play_reply callback, gpointer userdata)
static gboolean org_atheme_audacious_open_list(DBusGProxy *proxy, const char **IN_filenames, GError **error)
static DBusGProxyCall * org_atheme_audacious_toggle_auto_advance_async(DBusGProxy *proxy, org_atheme_audacious_toggle_auto_advance_reply callback, gpointer userdata)
void(* org_atheme_audacious_get_eq_band_reply)(DBusGProxy *proxy, gdouble OUT_value, GError *error, gpointer userdata)
static gboolean org_atheme_audacious_reverse(DBusGProxy *proxy, GError **error)
void(* org_atheme_audacious_playlist_ins_url_string_reply)(DBusGProxy *proxy, GError *error, gpointer userdata)
void(* org_atheme_audacious_get_eq_preamp_reply)(DBusGProxy *proxy, gdouble OUT_preamp, GError *error, gpointer userdata)
static DBusGProxyCall * org_atheme_audacious_balance_async(DBusGProxy *proxy, org_atheme_audacious_balance_reply callback, gpointer userdata)
static void org_atheme_audacious_clear_async_callback(DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
static DBusGProxyCall * org_atheme_audacious_delete_async(DBusGProxy *proxy, const guint IN_pos, org_atheme_audacious_delete_reply callback, gpointer userdata)
void(* org_atheme_audacious_add_reply)(DBusGProxy *proxy, GError *error, gpointer userdata)
static DBusGProxyCall * org_atheme_audacious_repeat_async(DBusGProxy *proxy, org_atheme_audacious_repeat_reply callback, gpointer userdata)
static DBusGProxyCall * org_atheme_audacious_playqueue_add_async(DBusGProxy *proxy, const gint IN_pos, org_atheme_audacious_playqueue_add_reply callback, gpointer userdata)
static DBusGProxyCall * org_atheme_audacious_playing_async(DBusGProxy *proxy, org_atheme_audacious_playing_reply callback, gpointer userdata)
static gboolean org_atheme_audacious_repeat(DBusGProxy *proxy, gboolean *OUT_is_repeat, GError **error)
static gboolean org_atheme_audacious_add_url(DBusGProxy *proxy, const char *IN_url, GError **error)
static gboolean org_atheme_audacious_time(DBusGProxy *proxy, guint *OUT_time, GError **error)
static void org_atheme_audacious_get_tuple_fields_async_callback(DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
void(* org_atheme_audacious_quit_reply)(DBusGProxy *proxy, GError *error, gpointer userdata)
static void org_atheme_audacious_stop_after_async_callback(DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
static DBusGProxyCall * org_atheme_audacious_pause_async(DBusGProxy *proxy, org_atheme_audacious_pause_reply callback, gpointer userdata)
void(* org_atheme_audacious_clear_reply)(DBusGProxy *proxy, GError *error, gpointer userdata)
static DBusGProxyCall * org_atheme_audacious_quit_async(DBusGProxy *proxy, org_atheme_audacious_quit_reply callback, gpointer userdata)
static gboolean org_atheme_audacious_get_eq_preamp(DBusGProxy *proxy, gdouble *OUT_preamp, GError **error)
void(* org_atheme_audacious_toggle_repeat_reply)(DBusGProxy *proxy, GError *error, gpointer userdata)
static DBusGProxyCall * org_atheme_audacious_position_async(DBusGProxy *proxy, org_atheme_audacious_position_reply callback, gpointer userdata)
void(* org_atheme_audacious_show_filebrowser_reply)(DBusGProxy *proxy, GError *error, gpointer userdata)
static gboolean org_atheme_audacious_song_frames(DBusGProxy *proxy, const guint IN_pos, gint *OUT_length, GError **error)
static DBusGProxyCall * org_atheme_audacious_version_async(DBusGProxy *proxy, org_atheme_audacious_version_reply callback, gpointer userdata)