00001
00002
00003 #include <glib.h>
00004 #include <dbus/dbus-glib.h>
00005
00006 G_BEGIN_DECLS
00007
00008 #ifndef _DBUS_GLIB_ASYNC_DATA_FREE
00009 #define _DBUS_GLIB_ASYNC_DATA_FREE
00010 static
00011 #ifdef G_HAVE_INLINE
00012 inline
00013 #endif
00014 void
00015 _dbus_glib_async_data_free (gpointer stuff)
00016 {
00017 g_slice_free (DBusGAsyncData, stuff);
00018 }
00019 #endif
00020
00021 #ifndef DBUS_GLIB_CLIENT_WRAPPERS_org_atheme_audacious
00022 #define DBUS_GLIB_CLIENT_WRAPPERS_org_atheme_audacious
00023
00024 static
00025 #ifdef G_HAVE_INLINE
00026 inline
00027 #endif
00028 gboolean
00029 org_atheme_audacious_version (DBusGProxy *proxy, char ** OUT_version, GError **error)
00030
00031 {
00032 return dbus_g_proxy_call (proxy, "Version", error, G_TYPE_INVALID, G_TYPE_STRING, OUT_version, G_TYPE_INVALID);
00033 }
00034
00035 typedef void (*org_atheme_audacious_version_reply) (DBusGProxy *proxy, char * OUT_version, GError *error, gpointer userdata);
00036
00037 static void
00038 org_atheme_audacious_version_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
00039 {
00040 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
00041 GError *error = NULL;
00042 char * OUT_version;
00043 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_STRING, &OUT_version, G_TYPE_INVALID);
00044 (*(org_atheme_audacious_version_reply)data->cb) (proxy, OUT_version, error, data->userdata);
00045 return;
00046 }
00047
00048 static
00049 #ifdef G_HAVE_INLINE
00050 inline
00051 #endif
00052 DBusGProxyCall*
00053 org_atheme_audacious_version_async (DBusGProxy *proxy, org_atheme_audacious_version_reply callback, gpointer userdata)
00054
00055 {
00056 DBusGAsyncData *stuff;
00057 stuff = g_slice_new (DBusGAsyncData);
00058 stuff->cb = G_CALLBACK (callback);
00059 stuff->userdata = userdata;
00060 return dbus_g_proxy_begin_call (proxy, "Version", org_atheme_audacious_version_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
00061 }
00062 static
00063 #ifdef G_HAVE_INLINE
00064 inline
00065 #endif
00066 gboolean
00067 org_atheme_audacious_quit (DBusGProxy *proxy, GError **error)
00068
00069 {
00070 return dbus_g_proxy_call (proxy, "Quit", error, G_TYPE_INVALID, G_TYPE_INVALID);
00071 }
00072
00073 typedef void (*org_atheme_audacious_quit_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
00074
00075 static void
00076 org_atheme_audacious_quit_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
00077 {
00078 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
00079 GError *error = NULL;
00080 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
00081 (*(org_atheme_audacious_quit_reply)data->cb) (proxy, error, data->userdata);
00082 return;
00083 }
00084
00085 static
00086 #ifdef G_HAVE_INLINE
00087 inline
00088 #endif
00089 DBusGProxyCall*
00090 org_atheme_audacious_quit_async (DBusGProxy *proxy, org_atheme_audacious_quit_reply callback, gpointer userdata)
00091
00092 {
00093 DBusGAsyncData *stuff;
00094 stuff = g_slice_new (DBusGAsyncData);
00095 stuff->cb = G_CALLBACK (callback);
00096 stuff->userdata = userdata;
00097 return dbus_g_proxy_begin_call (proxy, "Quit", org_atheme_audacious_quit_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
00098 }
00099 static
00100 #ifdef G_HAVE_INLINE
00101 inline
00102 #endif
00103 gboolean
00104 org_atheme_audacious_eject (DBusGProxy *proxy, GError **error)
00105
00106 {
00107 return dbus_g_proxy_call (proxy, "Eject", error, G_TYPE_INVALID, G_TYPE_INVALID);
00108 }
00109
00110 typedef void (*org_atheme_audacious_eject_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
00111
00112 static void
00113 org_atheme_audacious_eject_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
00114 {
00115 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
00116 GError *error = NULL;
00117 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
00118 (*(org_atheme_audacious_eject_reply)data->cb) (proxy, error, data->userdata);
00119 return;
00120 }
00121
00122 static
00123 #ifdef G_HAVE_INLINE
00124 inline
00125 #endif
00126 DBusGProxyCall*
00127 org_atheme_audacious_eject_async (DBusGProxy *proxy, org_atheme_audacious_eject_reply callback, gpointer userdata)
00128
00129 {
00130 DBusGAsyncData *stuff;
00131 stuff = g_slice_new (DBusGAsyncData);
00132 stuff->cb = G_CALLBACK (callback);
00133 stuff->userdata = userdata;
00134 return dbus_g_proxy_begin_call (proxy, "Eject", org_atheme_audacious_eject_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
00135 }
00136 static
00137 #ifdef G_HAVE_INLINE
00138 inline
00139 #endif
00140 gboolean
00141 org_atheme_audacious_main_win_visible (DBusGProxy *proxy, gboolean* OUT_is_main_win, GError **error)
00142
00143 {
00144 return dbus_g_proxy_call (proxy, "MainWinVisible", error, G_TYPE_INVALID, G_TYPE_BOOLEAN, OUT_is_main_win, G_TYPE_INVALID);
00145 }
00146
00147 typedef void (*org_atheme_audacious_main_win_visible_reply) (DBusGProxy *proxy, gboolean OUT_is_main_win, GError *error, gpointer userdata);
00148
00149 static void
00150 org_atheme_audacious_main_win_visible_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
00151 {
00152 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
00153 GError *error = NULL;
00154 gboolean OUT_is_main_win;
00155 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_BOOLEAN, &OUT_is_main_win, G_TYPE_INVALID);
00156 (*(org_atheme_audacious_main_win_visible_reply)data->cb) (proxy, OUT_is_main_win, error, data->userdata);
00157 return;
00158 }
00159
00160 static
00161 #ifdef G_HAVE_INLINE
00162 inline
00163 #endif
00164 DBusGProxyCall*
00165 org_atheme_audacious_main_win_visible_async (DBusGProxy *proxy, org_atheme_audacious_main_win_visible_reply callback, gpointer userdata)
00166
00167 {
00168 DBusGAsyncData *stuff;
00169 stuff = g_slice_new (DBusGAsyncData);
00170 stuff->cb = G_CALLBACK (callback);
00171 stuff->userdata = userdata;
00172 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);
00173 }
00174 static
00175 #ifdef G_HAVE_INLINE
00176 inline
00177 #endif
00178 gboolean
00179 org_atheme_audacious_show_main_win (DBusGProxy *proxy, const gboolean IN_show, GError **error)
00180
00181 {
00182 return dbus_g_proxy_call (proxy, "ShowMainWin", error, G_TYPE_BOOLEAN, IN_show, G_TYPE_INVALID, G_TYPE_INVALID);
00183 }
00184
00185 typedef void (*org_atheme_audacious_show_main_win_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
00186
00187 static void
00188 org_atheme_audacious_show_main_win_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
00189 {
00190 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
00191 GError *error = NULL;
00192 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
00193 (*(org_atheme_audacious_show_main_win_reply)data->cb) (proxy, error, data->userdata);
00194 return;
00195 }
00196
00197 static
00198 #ifdef G_HAVE_INLINE
00199 inline
00200 #endif
00201 DBusGProxyCall*
00202 org_atheme_audacious_show_main_win_async (DBusGProxy *proxy, const gboolean IN_show, org_atheme_audacious_show_main_win_reply callback, gpointer userdata)
00203
00204 {
00205 DBusGAsyncData *stuff;
00206 stuff = g_slice_new (DBusGAsyncData);
00207 stuff->cb = G_CALLBACK (callback);
00208 stuff->userdata = userdata;
00209 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);
00210 }
00211 static
00212 #ifdef G_HAVE_INLINE
00213 inline
00214 #endif
00215 gboolean
00216 org_atheme_audacious_equalizer_visible (DBusGProxy *proxy, gboolean* OUT_is_eq_win, GError **error)
00217
00218 {
00219 return dbus_g_proxy_call (proxy, "EqualizerVisible", error, G_TYPE_INVALID, G_TYPE_BOOLEAN, OUT_is_eq_win, G_TYPE_INVALID);
00220 }
00221
00222 typedef void (*org_atheme_audacious_equalizer_visible_reply) (DBusGProxy *proxy, gboolean OUT_is_eq_win, GError *error, gpointer userdata);
00223
00224 static void
00225 org_atheme_audacious_equalizer_visible_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
00226 {
00227 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
00228 GError *error = NULL;
00229 gboolean OUT_is_eq_win;
00230 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_BOOLEAN, &OUT_is_eq_win, G_TYPE_INVALID);
00231 (*(org_atheme_audacious_equalizer_visible_reply)data->cb) (proxy, OUT_is_eq_win, error, data->userdata);
00232 return;
00233 }
00234
00235 static
00236 #ifdef G_HAVE_INLINE
00237 inline
00238 #endif
00239 DBusGProxyCall*
00240 org_atheme_audacious_equalizer_visible_async (DBusGProxy *proxy, org_atheme_audacious_equalizer_visible_reply callback, gpointer userdata)
00241
00242 {
00243 DBusGAsyncData *stuff;
00244 stuff = g_slice_new (DBusGAsyncData);
00245 stuff->cb = G_CALLBACK (callback);
00246 stuff->userdata = userdata;
00247 return dbus_g_proxy_begin_call (proxy, "EqualizerVisible", org_atheme_audacious_equalizer_visible_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
00248 }
00249 static
00250 #ifdef G_HAVE_INLINE
00251 inline
00252 #endif
00253 gboolean
00254 org_atheme_audacious_show_equalizer (DBusGProxy *proxy, const gboolean IN_show, GError **error)
00255
00256 {
00257 return dbus_g_proxy_call (proxy, "ShowEqualizer", error, G_TYPE_BOOLEAN, IN_show, G_TYPE_INVALID, G_TYPE_INVALID);
00258 }
00259
00260 typedef void (*org_atheme_audacious_show_equalizer_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
00261
00262 static void
00263 org_atheme_audacious_show_equalizer_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
00264 {
00265 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
00266 GError *error = NULL;
00267 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
00268 (*(org_atheme_audacious_show_equalizer_reply)data->cb) (proxy, error, data->userdata);
00269 return;
00270 }
00271
00272 static
00273 #ifdef G_HAVE_INLINE
00274 inline
00275 #endif
00276 DBusGProxyCall*
00277 org_atheme_audacious_show_equalizer_async (DBusGProxy *proxy, const gboolean IN_show, org_atheme_audacious_show_equalizer_reply callback, gpointer userdata)
00278
00279 {
00280 DBusGAsyncData *stuff;
00281 stuff = g_slice_new (DBusGAsyncData);
00282 stuff->cb = G_CALLBACK (callback);
00283 stuff->userdata = userdata;
00284 return dbus_g_proxy_begin_call (proxy, "ShowEqualizer", org_atheme_audacious_show_equalizer_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_BOOLEAN, IN_show, G_TYPE_INVALID);
00285 }
00286 static
00287 #ifdef G_HAVE_INLINE
00288 inline
00289 #endif
00290 gboolean
00291 org_atheme_audacious_playlist_visible (DBusGProxy *proxy, gboolean* OUT_is_pl_win, GError **error)
00292
00293 {
00294 return dbus_g_proxy_call (proxy, "PlaylistVisible", error, G_TYPE_INVALID, G_TYPE_BOOLEAN, OUT_is_pl_win, G_TYPE_INVALID);
00295 }
00296
00297 typedef void (*org_atheme_audacious_playlist_visible_reply) (DBusGProxy *proxy, gboolean OUT_is_pl_win, GError *error, gpointer userdata);
00298
00299 static void
00300 org_atheme_audacious_playlist_visible_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
00301 {
00302 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
00303 GError *error = NULL;
00304 gboolean OUT_is_pl_win;
00305 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_BOOLEAN, &OUT_is_pl_win, G_TYPE_INVALID);
00306 (*(org_atheme_audacious_playlist_visible_reply)data->cb) (proxy, OUT_is_pl_win, error, data->userdata);
00307 return;
00308 }
00309
00310 static
00311 #ifdef G_HAVE_INLINE
00312 inline
00313 #endif
00314 DBusGProxyCall*
00315 org_atheme_audacious_playlist_visible_async (DBusGProxy *proxy, org_atheme_audacious_playlist_visible_reply callback, gpointer userdata)
00316
00317 {
00318 DBusGAsyncData *stuff;
00319 stuff = g_slice_new (DBusGAsyncData);
00320 stuff->cb = G_CALLBACK (callback);
00321 stuff->userdata = userdata;
00322 return dbus_g_proxy_begin_call (proxy, "PlaylistVisible", org_atheme_audacious_playlist_visible_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
00323 }
00324 static
00325 #ifdef G_HAVE_INLINE
00326 inline
00327 #endif
00328 gboolean
00329 org_atheme_audacious_show_playlist (DBusGProxy *proxy, const gboolean IN_show, GError **error)
00330
00331 {
00332 return dbus_g_proxy_call (proxy, "ShowPlaylist", error, G_TYPE_BOOLEAN, IN_show, G_TYPE_INVALID, G_TYPE_INVALID);
00333 }
00334
00335 typedef void (*org_atheme_audacious_show_playlist_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
00336
00337 static void
00338 org_atheme_audacious_show_playlist_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
00339 {
00340 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
00341 GError *error = NULL;
00342 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
00343 (*(org_atheme_audacious_show_playlist_reply)data->cb) (proxy, error, data->userdata);
00344 return;
00345 }
00346
00347 static
00348 #ifdef G_HAVE_INLINE
00349 inline
00350 #endif
00351 DBusGProxyCall*
00352 org_atheme_audacious_show_playlist_async (DBusGProxy *proxy, const gboolean IN_show, org_atheme_audacious_show_playlist_reply callback, gpointer userdata)
00353
00354 {
00355 DBusGAsyncData *stuff;
00356 stuff = g_slice_new (DBusGAsyncData);
00357 stuff->cb = G_CALLBACK (callback);
00358 stuff->userdata = userdata;
00359 return dbus_g_proxy_begin_call (proxy, "ShowPlaylist", org_atheme_audacious_show_playlist_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_BOOLEAN, IN_show, G_TYPE_INVALID);
00360 }
00361 static
00362 #ifdef G_HAVE_INLINE
00363 inline
00364 #endif
00365 gboolean
00366 org_atheme_audacious_get_tuple_fields (DBusGProxy *proxy, char *** OUT_fields, GError **error)
00367
00368 {
00369 return dbus_g_proxy_call (proxy, "GetTupleFields", error, G_TYPE_INVALID, G_TYPE_STRV, OUT_fields, G_TYPE_INVALID);
00370 }
00371
00372 typedef void (*org_atheme_audacious_get_tuple_fields_reply) (DBusGProxy *proxy, char * *OUT_fields, GError *error, gpointer userdata);
00373
00374 static void
00375 org_atheme_audacious_get_tuple_fields_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
00376 {
00377 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
00378 GError *error = NULL;
00379 char ** OUT_fields;
00380 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_STRV, &OUT_fields, G_TYPE_INVALID);
00381 (*(org_atheme_audacious_get_tuple_fields_reply)data->cb) (proxy, OUT_fields, error, data->userdata);
00382 return;
00383 }
00384
00385 static
00386 #ifdef G_HAVE_INLINE
00387 inline
00388 #endif
00389 DBusGProxyCall*
00390 org_atheme_audacious_get_tuple_fields_async (DBusGProxy *proxy, org_atheme_audacious_get_tuple_fields_reply callback, gpointer userdata)
00391
00392 {
00393 DBusGAsyncData *stuff;
00394 stuff = g_slice_new (DBusGAsyncData);
00395 stuff->cb = G_CALLBACK (callback);
00396 stuff->userdata = userdata;
00397 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);
00398 }
00399 static
00400 #ifdef G_HAVE_INLINE
00401 inline
00402 #endif
00403 gboolean
00404 org_atheme_audacious_play (DBusGProxy *proxy, GError **error)
00405
00406 {
00407 return dbus_g_proxy_call (proxy, "Play", error, G_TYPE_INVALID, G_TYPE_INVALID);
00408 }
00409
00410 typedef void (*org_atheme_audacious_play_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
00411
00412 static void
00413 org_atheme_audacious_play_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
00414 {
00415 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
00416 GError *error = NULL;
00417 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
00418 (*(org_atheme_audacious_play_reply)data->cb) (proxy, error, data->userdata);
00419 return;
00420 }
00421
00422 static
00423 #ifdef G_HAVE_INLINE
00424 inline
00425 #endif
00426 DBusGProxyCall*
00427 org_atheme_audacious_play_async (DBusGProxy *proxy, org_atheme_audacious_play_reply callback, gpointer userdata)
00428
00429 {
00430 DBusGAsyncData *stuff;
00431 stuff = g_slice_new (DBusGAsyncData);
00432 stuff->cb = G_CALLBACK (callback);
00433 stuff->userdata = userdata;
00434 return dbus_g_proxy_begin_call (proxy, "Play", org_atheme_audacious_play_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
00435 }
00436 static
00437 #ifdef G_HAVE_INLINE
00438 inline
00439 #endif
00440 gboolean
00441 org_atheme_audacious_pause (DBusGProxy *proxy, GError **error)
00442
00443 {
00444 return dbus_g_proxy_call (proxy, "Pause", error, G_TYPE_INVALID, G_TYPE_INVALID);
00445 }
00446
00447 typedef void (*org_atheme_audacious_pause_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
00448
00449 static void
00450 org_atheme_audacious_pause_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
00451 {
00452 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
00453 GError *error = NULL;
00454 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
00455 (*(org_atheme_audacious_pause_reply)data->cb) (proxy, error, data->userdata);
00456 return;
00457 }
00458
00459 static
00460 #ifdef G_HAVE_INLINE
00461 inline
00462 #endif
00463 DBusGProxyCall*
00464 org_atheme_audacious_pause_async (DBusGProxy *proxy, org_atheme_audacious_pause_reply callback, gpointer userdata)
00465
00466 {
00467 DBusGAsyncData *stuff;
00468 stuff = g_slice_new (DBusGAsyncData);
00469 stuff->cb = G_CALLBACK (callback);
00470 stuff->userdata = userdata;
00471 return dbus_g_proxy_begin_call (proxy, "Pause", org_atheme_audacious_pause_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
00472 }
00473 static
00474 #ifdef G_HAVE_INLINE
00475 inline
00476 #endif
00477 gboolean
00478 org_atheme_audacious_stop (DBusGProxy *proxy, GError **error)
00479
00480 {
00481 return dbus_g_proxy_call (proxy, "Stop", error, G_TYPE_INVALID, G_TYPE_INVALID);
00482 }
00483
00484 typedef void (*org_atheme_audacious_stop_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
00485
00486 static void
00487 org_atheme_audacious_stop_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
00488 {
00489 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
00490 GError *error = NULL;
00491 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
00492 (*(org_atheme_audacious_stop_reply)data->cb) (proxy, error, data->userdata);
00493 return;
00494 }
00495
00496 static
00497 #ifdef G_HAVE_INLINE
00498 inline
00499 #endif
00500 DBusGProxyCall*
00501 org_atheme_audacious_stop_async (DBusGProxy *proxy, org_atheme_audacious_stop_reply callback, gpointer userdata)
00502
00503 {
00504 DBusGAsyncData *stuff;
00505 stuff = g_slice_new (DBusGAsyncData);
00506 stuff->cb = G_CALLBACK (callback);
00507 stuff->userdata = userdata;
00508 return dbus_g_proxy_begin_call (proxy, "Stop", org_atheme_audacious_stop_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
00509 }
00510 static
00511 #ifdef G_HAVE_INLINE
00512 inline
00513 #endif
00514 gboolean
00515 org_atheme_audacious_playing (DBusGProxy *proxy, gboolean* OUT_is_playing, GError **error)
00516
00517 {
00518 return dbus_g_proxy_call (proxy, "Playing", error, G_TYPE_INVALID, G_TYPE_BOOLEAN, OUT_is_playing, G_TYPE_INVALID);
00519 }
00520
00521 typedef void (*org_atheme_audacious_playing_reply) (DBusGProxy *proxy, gboolean OUT_is_playing, GError *error, gpointer userdata);
00522
00523 static void
00524 org_atheme_audacious_playing_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
00525 {
00526 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
00527 GError *error = NULL;
00528 gboolean OUT_is_playing;
00529 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_BOOLEAN, &OUT_is_playing, G_TYPE_INVALID);
00530 (*(org_atheme_audacious_playing_reply)data->cb) (proxy, OUT_is_playing, error, data->userdata);
00531 return;
00532 }
00533
00534 static
00535 #ifdef G_HAVE_INLINE
00536 inline
00537 #endif
00538 DBusGProxyCall*
00539 org_atheme_audacious_playing_async (DBusGProxy *proxy, org_atheme_audacious_playing_reply callback, gpointer userdata)
00540
00541 {
00542 DBusGAsyncData *stuff;
00543 stuff = g_slice_new (DBusGAsyncData);
00544 stuff->cb = G_CALLBACK (callback);
00545 stuff->userdata = userdata;
00546 return dbus_g_proxy_begin_call (proxy, "Playing", org_atheme_audacious_playing_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
00547 }
00548 static
00549 #ifdef G_HAVE_INLINE
00550 inline
00551 #endif
00552 gboolean
00553 org_atheme_audacious_paused (DBusGProxy *proxy, gboolean* OUT_is_paused, GError **error)
00554
00555 {
00556 return dbus_g_proxy_call (proxy, "Paused", error, G_TYPE_INVALID, G_TYPE_BOOLEAN, OUT_is_paused, G_TYPE_INVALID);
00557 }
00558
00559 typedef void (*org_atheme_audacious_paused_reply) (DBusGProxy *proxy, gboolean OUT_is_paused, GError *error, gpointer userdata);
00560
00561 static void
00562 org_atheme_audacious_paused_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
00563 {
00564 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
00565 GError *error = NULL;
00566 gboolean OUT_is_paused;
00567 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_BOOLEAN, &OUT_is_paused, G_TYPE_INVALID);
00568 (*(org_atheme_audacious_paused_reply)data->cb) (proxy, OUT_is_paused, error, data->userdata);
00569 return;
00570 }
00571
00572 static
00573 #ifdef G_HAVE_INLINE
00574 inline
00575 #endif
00576 DBusGProxyCall*
00577 org_atheme_audacious_paused_async (DBusGProxy *proxy, org_atheme_audacious_paused_reply callback, gpointer userdata)
00578
00579 {
00580 DBusGAsyncData *stuff;
00581 stuff = g_slice_new (DBusGAsyncData);
00582 stuff->cb = G_CALLBACK (callback);
00583 stuff->userdata = userdata;
00584 return dbus_g_proxy_begin_call (proxy, "Paused", org_atheme_audacious_paused_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
00585 }
00586 static
00587 #ifdef G_HAVE_INLINE
00588 inline
00589 #endif
00590 gboolean
00591 org_atheme_audacious_stopped (DBusGProxy *proxy, gboolean* OUT_is_stopped, GError **error)
00592
00593 {
00594 return dbus_g_proxy_call (proxy, "Stopped", error, G_TYPE_INVALID, G_TYPE_BOOLEAN, OUT_is_stopped, G_TYPE_INVALID);
00595 }
00596
00597 typedef void (*org_atheme_audacious_stopped_reply) (DBusGProxy *proxy, gboolean OUT_is_stopped, GError *error, gpointer userdata);
00598
00599 static void
00600 org_atheme_audacious_stopped_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
00601 {
00602 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
00603 GError *error = NULL;
00604 gboolean OUT_is_stopped;
00605 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_BOOLEAN, &OUT_is_stopped, G_TYPE_INVALID);
00606 (*(org_atheme_audacious_stopped_reply)data->cb) (proxy, OUT_is_stopped, error, data->userdata);
00607 return;
00608 }
00609
00610 static
00611 #ifdef G_HAVE_INLINE
00612 inline
00613 #endif
00614 DBusGProxyCall*
00615 org_atheme_audacious_stopped_async (DBusGProxy *proxy, org_atheme_audacious_stopped_reply callback, gpointer userdata)
00616
00617 {
00618 DBusGAsyncData *stuff;
00619 stuff = g_slice_new (DBusGAsyncData);
00620 stuff->cb = G_CALLBACK (callback);
00621 stuff->userdata = userdata;
00622 return dbus_g_proxy_begin_call (proxy, "Stopped", org_atheme_audacious_stopped_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
00623 }
00624 static
00625 #ifdef G_HAVE_INLINE
00626 inline
00627 #endif
00628 gboolean
00629 org_atheme_audacious_status (DBusGProxy *proxy, char ** OUT_status, GError **error)
00630
00631 {
00632 return dbus_g_proxy_call (proxy, "Status", error, G_TYPE_INVALID, G_TYPE_STRING, OUT_status, G_TYPE_INVALID);
00633 }
00634
00635 typedef void (*org_atheme_audacious_status_reply) (DBusGProxy *proxy, char * OUT_status, GError *error, gpointer userdata);
00636
00637 static void
00638 org_atheme_audacious_status_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
00639 {
00640 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
00641 GError *error = NULL;
00642 char * OUT_status;
00643 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_STRING, &OUT_status, G_TYPE_INVALID);
00644 (*(org_atheme_audacious_status_reply)data->cb) (proxy, OUT_status, error, data->userdata);
00645 return;
00646 }
00647
00648 static
00649 #ifdef G_HAVE_INLINE
00650 inline
00651 #endif
00652 DBusGProxyCall*
00653 org_atheme_audacious_status_async (DBusGProxy *proxy, org_atheme_audacious_status_reply callback, gpointer userdata)
00654
00655 {
00656 DBusGAsyncData *stuff;
00657 stuff = g_slice_new (DBusGAsyncData);
00658 stuff->cb = G_CALLBACK (callback);
00659 stuff->userdata = userdata;
00660 return dbus_g_proxy_begin_call (proxy, "Status", org_atheme_audacious_status_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
00661 }
00662 static
00663 #ifdef G_HAVE_INLINE
00664 inline
00665 #endif
00666 gboolean
00667 org_atheme_audacious_info (DBusGProxy *proxy, gint* OUT_rate, gint* OUT_freq, gint* OUT_nch, GError **error)
00668
00669 {
00670 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);
00671 }
00672
00673 typedef void (*org_atheme_audacious_info_reply) (DBusGProxy *proxy, gint OUT_rate, gint OUT_freq, gint OUT_nch, GError *error, gpointer userdata);
00674
00675 static void
00676 org_atheme_audacious_info_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
00677 {
00678 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
00679 GError *error = NULL;
00680 gint OUT_rate;
00681 gint OUT_freq;
00682 gint OUT_nch;
00683 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);
00684 (*(org_atheme_audacious_info_reply)data->cb) (proxy, OUT_rate, OUT_freq, OUT_nch, error, data->userdata);
00685 return;
00686 }
00687
00688 static
00689 #ifdef G_HAVE_INLINE
00690 inline
00691 #endif
00692 DBusGProxyCall*
00693 org_atheme_audacious_info_async (DBusGProxy *proxy, org_atheme_audacious_info_reply callback, gpointer userdata)
00694
00695 {
00696 DBusGAsyncData *stuff;
00697 stuff = g_slice_new (DBusGAsyncData);
00698 stuff->cb = G_CALLBACK (callback);
00699 stuff->userdata = userdata;
00700 return dbus_g_proxy_begin_call (proxy, "Info", org_atheme_audacious_info_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
00701 }
00702 static
00703 #ifdef G_HAVE_INLINE
00704 inline
00705 #endif
00706 gboolean
00707 org_atheme_audacious_time (DBusGProxy *proxy, guint* OUT_time, GError **error)
00708
00709 {
00710 return dbus_g_proxy_call (proxy, "Time", error, G_TYPE_INVALID, G_TYPE_UINT, OUT_time, G_TYPE_INVALID);
00711 }
00712
00713 typedef void (*org_atheme_audacious_time_reply) (DBusGProxy *proxy, guint OUT_time, GError *error, gpointer userdata);
00714
00715 static void
00716 org_atheme_audacious_time_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
00717 {
00718 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
00719 GError *error = NULL;
00720 guint OUT_time;
00721 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_UINT, &OUT_time, G_TYPE_INVALID);
00722 (*(org_atheme_audacious_time_reply)data->cb) (proxy, OUT_time, error, data->userdata);
00723 return;
00724 }
00725
00726 static
00727 #ifdef G_HAVE_INLINE
00728 inline
00729 #endif
00730 DBusGProxyCall*
00731 org_atheme_audacious_time_async (DBusGProxy *proxy, org_atheme_audacious_time_reply callback, gpointer userdata)
00732
00733 {
00734 DBusGAsyncData *stuff;
00735 stuff = g_slice_new (DBusGAsyncData);
00736 stuff->cb = G_CALLBACK (callback);
00737 stuff->userdata = userdata;
00738 return dbus_g_proxy_begin_call (proxy, "Time", org_atheme_audacious_time_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
00739 }
00740 static
00741 #ifdef G_HAVE_INLINE
00742 inline
00743 #endif
00744 gboolean
00745 org_atheme_audacious_seek (DBusGProxy *proxy, const guint IN_pos, GError **error)
00746
00747 {
00748 return dbus_g_proxy_call (proxy, "Seek", error, G_TYPE_UINT, IN_pos, G_TYPE_INVALID, G_TYPE_INVALID);
00749 }
00750
00751 typedef void (*org_atheme_audacious_seek_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
00752
00753 static void
00754 org_atheme_audacious_seek_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
00755 {
00756 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
00757 GError *error = NULL;
00758 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
00759 (*(org_atheme_audacious_seek_reply)data->cb) (proxy, error, data->userdata);
00760 return;
00761 }
00762
00763 static
00764 #ifdef G_HAVE_INLINE
00765 inline
00766 #endif
00767 DBusGProxyCall*
00768 org_atheme_audacious_seek_async (DBusGProxy *proxy, const guint IN_pos, org_atheme_audacious_seek_reply callback, gpointer userdata)
00769
00770 {
00771 DBusGAsyncData *stuff;
00772 stuff = g_slice_new (DBusGAsyncData);
00773 stuff->cb = G_CALLBACK (callback);
00774 stuff->userdata = userdata;
00775 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);
00776 }
00777 static
00778 #ifdef G_HAVE_INLINE
00779 inline
00780 #endif
00781 gboolean
00782 org_atheme_audacious_volume (DBusGProxy *proxy, gint* OUT_vl, gint* OUT_vr, GError **error)
00783
00784 {
00785 return dbus_g_proxy_call (proxy, "Volume", error, G_TYPE_INVALID, G_TYPE_INT, OUT_vl, G_TYPE_INT, OUT_vr, G_TYPE_INVALID);
00786 }
00787
00788 typedef void (*org_atheme_audacious_volume_reply) (DBusGProxy *proxy, gint OUT_vl, gint OUT_vr, GError *error, gpointer userdata);
00789
00790 static void
00791 org_atheme_audacious_volume_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
00792 {
00793 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
00794 GError *error = NULL;
00795 gint OUT_vl;
00796 gint OUT_vr;
00797 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INT, &OUT_vl, G_TYPE_INT, &OUT_vr, G_TYPE_INVALID);
00798 (*(org_atheme_audacious_volume_reply)data->cb) (proxy, OUT_vl, OUT_vr, error, data->userdata);
00799 return;
00800 }
00801
00802 static
00803 #ifdef G_HAVE_INLINE
00804 inline
00805 #endif
00806 DBusGProxyCall*
00807 org_atheme_audacious_volume_async (DBusGProxy *proxy, org_atheme_audacious_volume_reply callback, gpointer userdata)
00808
00809 {
00810 DBusGAsyncData *stuff;
00811 stuff = g_slice_new (DBusGAsyncData);
00812 stuff->cb = G_CALLBACK (callback);
00813 stuff->userdata = userdata;
00814 return dbus_g_proxy_begin_call (proxy, "Volume", org_atheme_audacious_volume_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
00815 }
00816 static
00817 #ifdef G_HAVE_INLINE
00818 inline
00819 #endif
00820 gboolean
00821 org_atheme_audacious_set_volume (DBusGProxy *proxy, const gint IN_vl, const gint IN_vr, GError **error)
00822
00823 {
00824 return dbus_g_proxy_call (proxy, "SetVolume", error, G_TYPE_INT, IN_vl, G_TYPE_INT, IN_vr, G_TYPE_INVALID, G_TYPE_INVALID);
00825 }
00826
00827 typedef void (*org_atheme_audacious_set_volume_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
00828
00829 static void
00830 org_atheme_audacious_set_volume_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
00831 {
00832 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
00833 GError *error = NULL;
00834 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
00835 (*(org_atheme_audacious_set_volume_reply)data->cb) (proxy, error, data->userdata);
00836 return;
00837 }
00838
00839 static
00840 #ifdef G_HAVE_INLINE
00841 inline
00842 #endif
00843 DBusGProxyCall*
00844 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)
00845
00846 {
00847 DBusGAsyncData *stuff;
00848 stuff = g_slice_new (DBusGAsyncData);
00849 stuff->cb = G_CALLBACK (callback);
00850 stuff->userdata = userdata;
00851 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);
00852 }
00853 static
00854 #ifdef G_HAVE_INLINE
00855 inline
00856 #endif
00857 gboolean
00858 org_atheme_audacious_balance (DBusGProxy *proxy, gint* OUT_balance, GError **error)
00859
00860 {
00861 return dbus_g_proxy_call (proxy, "Balance", error, G_TYPE_INVALID, G_TYPE_INT, OUT_balance, G_TYPE_INVALID);
00862 }
00863
00864 typedef void (*org_atheme_audacious_balance_reply) (DBusGProxy *proxy, gint OUT_balance, GError *error, gpointer userdata);
00865
00866 static void
00867 org_atheme_audacious_balance_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
00868 {
00869 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
00870 GError *error = NULL;
00871 gint OUT_balance;
00872 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INT, &OUT_balance, G_TYPE_INVALID);
00873 (*(org_atheme_audacious_balance_reply)data->cb) (proxy, OUT_balance, error, data->userdata);
00874 return;
00875 }
00876
00877 static
00878 #ifdef G_HAVE_INLINE
00879 inline
00880 #endif
00881 DBusGProxyCall*
00882 org_atheme_audacious_balance_async (DBusGProxy *proxy, org_atheme_audacious_balance_reply callback, gpointer userdata)
00883
00884 {
00885 DBusGAsyncData *stuff;
00886 stuff = g_slice_new (DBusGAsyncData);
00887 stuff->cb = G_CALLBACK (callback);
00888 stuff->userdata = userdata;
00889 return dbus_g_proxy_begin_call (proxy, "Balance", org_atheme_audacious_balance_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
00890 }
00891 static
00892 #ifdef G_HAVE_INLINE
00893 inline
00894 #endif
00895 gboolean
00896 org_atheme_audacious_position (DBusGProxy *proxy, guint* OUT_pos, GError **error)
00897
00898 {
00899 return dbus_g_proxy_call (proxy, "Position", error, G_TYPE_INVALID, G_TYPE_UINT, OUT_pos, G_TYPE_INVALID);
00900 }
00901
00902 typedef void (*org_atheme_audacious_position_reply) (DBusGProxy *proxy, guint OUT_pos, GError *error, gpointer userdata);
00903
00904 static void
00905 org_atheme_audacious_position_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
00906 {
00907 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
00908 GError *error = NULL;
00909 guint OUT_pos;
00910 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_UINT, &OUT_pos, G_TYPE_INVALID);
00911 (*(org_atheme_audacious_position_reply)data->cb) (proxy, OUT_pos, error, data->userdata);
00912 return;
00913 }
00914
00915 static
00916 #ifdef G_HAVE_INLINE
00917 inline
00918 #endif
00919 DBusGProxyCall*
00920 org_atheme_audacious_position_async (DBusGProxy *proxy, org_atheme_audacious_position_reply callback, gpointer userdata)
00921
00922 {
00923 DBusGAsyncData *stuff;
00924 stuff = g_slice_new (DBusGAsyncData);
00925 stuff->cb = G_CALLBACK (callback);
00926 stuff->userdata = userdata;
00927 return dbus_g_proxy_begin_call (proxy, "Position", org_atheme_audacious_position_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
00928 }
00929 static
00930 #ifdef G_HAVE_INLINE
00931 inline
00932 #endif
00933 gboolean
00934 org_atheme_audacious_advance (DBusGProxy *proxy, GError **error)
00935
00936 {
00937 return dbus_g_proxy_call (proxy, "Advance", error, G_TYPE_INVALID, G_TYPE_INVALID);
00938 }
00939
00940 typedef void (*org_atheme_audacious_advance_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
00941
00942 static void
00943 org_atheme_audacious_advance_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
00944 {
00945 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
00946 GError *error = NULL;
00947 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
00948 (*(org_atheme_audacious_advance_reply)data->cb) (proxy, error, data->userdata);
00949 return;
00950 }
00951
00952 static
00953 #ifdef G_HAVE_INLINE
00954 inline
00955 #endif
00956 DBusGProxyCall*
00957 org_atheme_audacious_advance_async (DBusGProxy *proxy, org_atheme_audacious_advance_reply callback, gpointer userdata)
00958
00959 {
00960 DBusGAsyncData *stuff;
00961 stuff = g_slice_new (DBusGAsyncData);
00962 stuff->cb = G_CALLBACK (callback);
00963 stuff->userdata = userdata;
00964 return dbus_g_proxy_begin_call (proxy, "Advance", org_atheme_audacious_advance_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
00965 }
00966 static
00967 #ifdef G_HAVE_INLINE
00968 inline
00969 #endif
00970 gboolean
00971 org_atheme_audacious_reverse (DBusGProxy *proxy, GError **error)
00972
00973 {
00974 return dbus_g_proxy_call (proxy, "Reverse", error, G_TYPE_INVALID, G_TYPE_INVALID);
00975 }
00976
00977 typedef void (*org_atheme_audacious_reverse_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
00978
00979 static void
00980 org_atheme_audacious_reverse_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
00981 {
00982 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
00983 GError *error = NULL;
00984 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
00985 (*(org_atheme_audacious_reverse_reply)data->cb) (proxy, error, data->userdata);
00986 return;
00987 }
00988
00989 static
00990 #ifdef G_HAVE_INLINE
00991 inline
00992 #endif
00993 DBusGProxyCall*
00994 org_atheme_audacious_reverse_async (DBusGProxy *proxy, org_atheme_audacious_reverse_reply callback, gpointer userdata)
00995
00996 {
00997 DBusGAsyncData *stuff;
00998 stuff = g_slice_new (DBusGAsyncData);
00999 stuff->cb = G_CALLBACK (callback);
01000 stuff->userdata = userdata;
01001 return dbus_g_proxy_begin_call (proxy, "Reverse", org_atheme_audacious_reverse_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
01002 }
01003 static
01004 #ifdef G_HAVE_INLINE
01005 inline
01006 #endif
01007 gboolean
01008 org_atheme_audacious_length (DBusGProxy *proxy, gint* OUT_length, GError **error)
01009
01010 {
01011 return dbus_g_proxy_call (proxy, "Length", error, G_TYPE_INVALID, G_TYPE_INT, OUT_length, G_TYPE_INVALID);
01012 }
01013
01014 typedef void (*org_atheme_audacious_length_reply) (DBusGProxy *proxy, gint OUT_length, GError *error, gpointer userdata);
01015
01016 static void
01017 org_atheme_audacious_length_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01018 {
01019 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01020 GError *error = NULL;
01021 gint OUT_length;
01022 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INT, &OUT_length, G_TYPE_INVALID);
01023 (*(org_atheme_audacious_length_reply)data->cb) (proxy, OUT_length, error, data->userdata);
01024 return;
01025 }
01026
01027 static
01028 #ifdef G_HAVE_INLINE
01029 inline
01030 #endif
01031 DBusGProxyCall*
01032 org_atheme_audacious_length_async (DBusGProxy *proxy, org_atheme_audacious_length_reply callback, gpointer userdata)
01033
01034 {
01035 DBusGAsyncData *stuff;
01036 stuff = g_slice_new (DBusGAsyncData);
01037 stuff->cb = G_CALLBACK (callback);
01038 stuff->userdata = userdata;
01039 return dbus_g_proxy_begin_call (proxy, "Length", org_atheme_audacious_length_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
01040 }
01041 static
01042 #ifdef G_HAVE_INLINE
01043 inline
01044 #endif
01045 gboolean
01046 org_atheme_audacious_song_title (DBusGProxy *proxy, const guint IN_pos, char ** OUT_title, GError **error)
01047
01048 {
01049 return dbus_g_proxy_call (proxy, "SongTitle", error, G_TYPE_UINT, IN_pos, G_TYPE_INVALID, G_TYPE_STRING, OUT_title, G_TYPE_INVALID);
01050 }
01051
01052 typedef void (*org_atheme_audacious_song_title_reply) (DBusGProxy *proxy, char * OUT_title, GError *error, gpointer userdata);
01053
01054 static void
01055 org_atheme_audacious_song_title_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01056 {
01057 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01058 GError *error = NULL;
01059 char * OUT_title;
01060 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_STRING, &OUT_title, G_TYPE_INVALID);
01061 (*(org_atheme_audacious_song_title_reply)data->cb) (proxy, OUT_title, error, data->userdata);
01062 return;
01063 }
01064
01065 static
01066 #ifdef G_HAVE_INLINE
01067 inline
01068 #endif
01069 DBusGProxyCall*
01070 org_atheme_audacious_song_title_async (DBusGProxy *proxy, const guint IN_pos, org_atheme_audacious_song_title_reply callback, gpointer userdata)
01071
01072 {
01073 DBusGAsyncData *stuff;
01074 stuff = g_slice_new (DBusGAsyncData);
01075 stuff->cb = G_CALLBACK (callback);
01076 stuff->userdata = userdata;
01077 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);
01078 }
01079 static
01080 #ifdef G_HAVE_INLINE
01081 inline
01082 #endif
01083 gboolean
01084 org_atheme_audacious_song_filename (DBusGProxy *proxy, const guint IN_pos, char ** OUT_filename, GError **error)
01085
01086 {
01087 return dbus_g_proxy_call (proxy, "SongFilename", error, G_TYPE_UINT, IN_pos, G_TYPE_INVALID, G_TYPE_STRING, OUT_filename, G_TYPE_INVALID);
01088 }
01089
01090 typedef void (*org_atheme_audacious_song_filename_reply) (DBusGProxy *proxy, char * OUT_filename, GError *error, gpointer userdata);
01091
01092 static void
01093 org_atheme_audacious_song_filename_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01094 {
01095 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01096 GError *error = NULL;
01097 char * OUT_filename;
01098 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_STRING, &OUT_filename, G_TYPE_INVALID);
01099 (*(org_atheme_audacious_song_filename_reply)data->cb) (proxy, OUT_filename, error, data->userdata);
01100 return;
01101 }
01102
01103 static
01104 #ifdef G_HAVE_INLINE
01105 inline
01106 #endif
01107 DBusGProxyCall*
01108 org_atheme_audacious_song_filename_async (DBusGProxy *proxy, const guint IN_pos, org_atheme_audacious_song_filename_reply callback, gpointer userdata)
01109
01110 {
01111 DBusGAsyncData *stuff;
01112 stuff = g_slice_new (DBusGAsyncData);
01113 stuff->cb = G_CALLBACK (callback);
01114 stuff->userdata = userdata;
01115 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);
01116 }
01117 static
01118 #ifdef G_HAVE_INLINE
01119 inline
01120 #endif
01121 gboolean
01122 org_atheme_audacious_song_length (DBusGProxy *proxy, const guint IN_pos, gint* OUT_length, GError **error)
01123
01124 {
01125 return dbus_g_proxy_call (proxy, "SongLength", error, G_TYPE_UINT, IN_pos, G_TYPE_INVALID, G_TYPE_INT, OUT_length, G_TYPE_INVALID);
01126 }
01127
01128 typedef void (*org_atheme_audacious_song_length_reply) (DBusGProxy *proxy, gint OUT_length, GError *error, gpointer userdata);
01129
01130 static void
01131 org_atheme_audacious_song_length_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01132 {
01133 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01134 GError *error = NULL;
01135 gint OUT_length;
01136 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INT, &OUT_length, G_TYPE_INVALID);
01137 (*(org_atheme_audacious_song_length_reply)data->cb) (proxy, OUT_length, error, data->userdata);
01138 return;
01139 }
01140
01141 static
01142 #ifdef G_HAVE_INLINE
01143 inline
01144 #endif
01145 DBusGProxyCall*
01146 org_atheme_audacious_song_length_async (DBusGProxy *proxy, const guint IN_pos, org_atheme_audacious_song_length_reply callback, gpointer userdata)
01147
01148 {
01149 DBusGAsyncData *stuff;
01150 stuff = g_slice_new (DBusGAsyncData);
01151 stuff->cb = G_CALLBACK (callback);
01152 stuff->userdata = userdata;
01153 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);
01154 }
01155 static
01156 #ifdef G_HAVE_INLINE
01157 inline
01158 #endif
01159 gboolean
01160 org_atheme_audacious_song_frames (DBusGProxy *proxy, const guint IN_pos, gint* OUT_length, GError **error)
01161
01162 {
01163 return dbus_g_proxy_call (proxy, "SongFrames", error, G_TYPE_UINT, IN_pos, G_TYPE_INVALID, G_TYPE_INT, OUT_length, G_TYPE_INVALID);
01164 }
01165
01166 typedef void (*org_atheme_audacious_song_frames_reply) (DBusGProxy *proxy, gint OUT_length, GError *error, gpointer userdata);
01167
01168 static void
01169 org_atheme_audacious_song_frames_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01170 {
01171 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01172 GError *error = NULL;
01173 gint OUT_length;
01174 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INT, &OUT_length, G_TYPE_INVALID);
01175 (*(org_atheme_audacious_song_frames_reply)data->cb) (proxy, OUT_length, error, data->userdata);
01176 return;
01177 }
01178
01179 static
01180 #ifdef G_HAVE_INLINE
01181 inline
01182 #endif
01183 DBusGProxyCall*
01184 org_atheme_audacious_song_frames_async (DBusGProxy *proxy, const guint IN_pos, org_atheme_audacious_song_frames_reply callback, gpointer userdata)
01185
01186 {
01187 DBusGAsyncData *stuff;
01188 stuff = g_slice_new (DBusGAsyncData);
01189 stuff->cb = G_CALLBACK (callback);
01190 stuff->userdata = userdata;
01191 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);
01192 }
01193 static
01194 #ifdef G_HAVE_INLINE
01195 inline
01196 #endif
01197 gboolean
01198 org_atheme_audacious_song_tuple (DBusGProxy *proxy, const guint IN_pos, const char * IN_tuple, GValue* OUT_value, GError **error)
01199
01200 {
01201 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);
01202 }
01203
01204 typedef void (*org_atheme_audacious_song_tuple_reply) (DBusGProxy *proxy, GValue OUT_value, GError *error, gpointer userdata);
01205
01206 static void
01207 org_atheme_audacious_song_tuple_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01208 {
01209 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01210 GError *error = NULL;
01211 GValue OUT_value = { 0, };
01212 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_VALUE, &OUT_value, G_TYPE_INVALID);
01213 (*(org_atheme_audacious_song_tuple_reply)data->cb) (proxy, OUT_value, error, data->userdata);
01214 return;
01215 }
01216
01217 static
01218 #ifdef G_HAVE_INLINE
01219 inline
01220 #endif
01221 DBusGProxyCall*
01222 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)
01223
01224 {
01225 DBusGAsyncData *stuff;
01226 stuff = g_slice_new (DBusGAsyncData);
01227 stuff->cb = G_CALLBACK (callback);
01228 stuff->userdata = userdata;
01229 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);
01230 }
01231 static
01232 #ifdef G_HAVE_INLINE
01233 inline
01234 #endif
01235 gboolean
01236 org_atheme_audacious_jump (DBusGProxy *proxy, const guint IN_pos, GError **error)
01237
01238 {
01239 return dbus_g_proxy_call (proxy, "Jump", error, G_TYPE_UINT, IN_pos, G_TYPE_INVALID, G_TYPE_INVALID);
01240 }
01241
01242 typedef void (*org_atheme_audacious_jump_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
01243
01244 static void
01245 org_atheme_audacious_jump_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01246 {
01247 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01248 GError *error = NULL;
01249 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
01250 (*(org_atheme_audacious_jump_reply)data->cb) (proxy, error, data->userdata);
01251 return;
01252 }
01253
01254 static
01255 #ifdef G_HAVE_INLINE
01256 inline
01257 #endif
01258 DBusGProxyCall*
01259 org_atheme_audacious_jump_async (DBusGProxy *proxy, const guint IN_pos, org_atheme_audacious_jump_reply callback, gpointer userdata)
01260
01261 {
01262 DBusGAsyncData *stuff;
01263 stuff = g_slice_new (DBusGAsyncData);
01264 stuff->cb = G_CALLBACK (callback);
01265 stuff->userdata = userdata;
01266 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);
01267 }
01268 static
01269 #ifdef G_HAVE_INLINE
01270 inline
01271 #endif
01272 gboolean
01273 org_atheme_audacious_add (DBusGProxy *proxy, const char * IN_file, GError **error)
01274
01275 {
01276 return dbus_g_proxy_call (proxy, "Add", error, G_TYPE_STRING, IN_file, G_TYPE_INVALID, G_TYPE_INVALID);
01277 }
01278
01279 typedef void (*org_atheme_audacious_add_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
01280
01281 static void
01282 org_atheme_audacious_add_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01283 {
01284 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01285 GError *error = NULL;
01286 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
01287 (*(org_atheme_audacious_add_reply)data->cb) (proxy, error, data->userdata);
01288 return;
01289 }
01290
01291 static
01292 #ifdef G_HAVE_INLINE
01293 inline
01294 #endif
01295 DBusGProxyCall*
01296 org_atheme_audacious_add_async (DBusGProxy *proxy, const char * IN_file, org_atheme_audacious_add_reply callback, gpointer userdata)
01297
01298 {
01299 DBusGAsyncData *stuff;
01300 stuff = g_slice_new (DBusGAsyncData);
01301 stuff->cb = G_CALLBACK (callback);
01302 stuff->userdata = userdata;
01303 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);
01304 }
01305 static
01306 #ifdef G_HAVE_INLINE
01307 inline
01308 #endif
01309 gboolean
01310 org_atheme_audacious_add_url (DBusGProxy *proxy, const char * IN_url, GError **error)
01311
01312 {
01313 return dbus_g_proxy_call (proxy, "AddUrl", error, G_TYPE_STRING, IN_url, G_TYPE_INVALID, G_TYPE_INVALID);
01314 }
01315
01316 typedef void (*org_atheme_audacious_add_url_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
01317
01318 static void
01319 org_atheme_audacious_add_url_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01320 {
01321 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01322 GError *error = NULL;
01323 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
01324 (*(org_atheme_audacious_add_url_reply)data->cb) (proxy, error, data->userdata);
01325 return;
01326 }
01327
01328 static
01329 #ifdef G_HAVE_INLINE
01330 inline
01331 #endif
01332 DBusGProxyCall*
01333 org_atheme_audacious_add_url_async (DBusGProxy *proxy, const char * IN_url, org_atheme_audacious_add_url_reply callback, gpointer userdata)
01334
01335 {
01336 DBusGAsyncData *stuff;
01337 stuff = g_slice_new (DBusGAsyncData);
01338 stuff->cb = G_CALLBACK (callback);
01339 stuff->userdata = userdata;
01340 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);
01341 }
01342 static
01343 #ifdef G_HAVE_INLINE
01344 inline
01345 #endif
01346 gboolean
01347 org_atheme_audacious_add_list (DBusGProxy *proxy, const char ** IN_filenames, GError **error)
01348
01349 {
01350 return dbus_g_proxy_call (proxy, "AddList", error, G_TYPE_STRV, IN_filenames, G_TYPE_INVALID, G_TYPE_INVALID);
01351 }
01352
01353 typedef void (*org_atheme_audacious_add_list_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
01354
01355 static void
01356 org_atheme_audacious_add_list_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01357 {
01358 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01359 GError *error = NULL;
01360 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
01361 (*(org_atheme_audacious_add_list_reply)data->cb) (proxy, error, data->userdata);
01362 return;
01363 }
01364
01365 static
01366 #ifdef G_HAVE_INLINE
01367 inline
01368 #endif
01369 DBusGProxyCall*
01370 org_atheme_audacious_add_list_async (DBusGProxy *proxy, const char ** IN_filenames, org_atheme_audacious_add_list_reply callback, gpointer userdata)
01371
01372 {
01373 DBusGAsyncData *stuff;
01374 stuff = g_slice_new (DBusGAsyncData);
01375 stuff->cb = G_CALLBACK (callback);
01376 stuff->userdata = userdata;
01377 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);
01378 }
01379 static
01380 #ifdef G_HAVE_INLINE
01381 inline
01382 #endif
01383 gboolean
01384 org_atheme_audacious_open_list (DBusGProxy *proxy, const char ** IN_filenames, GError **error)
01385
01386 {
01387 return dbus_g_proxy_call (proxy, "OpenList", error, G_TYPE_STRV, IN_filenames, G_TYPE_INVALID, G_TYPE_INVALID);
01388 }
01389
01390 typedef void (*org_atheme_audacious_open_list_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
01391
01392 static void
01393 org_atheme_audacious_open_list_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01394 {
01395 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01396 GError *error = NULL;
01397 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
01398 (*(org_atheme_audacious_open_list_reply)data->cb) (proxy, error, data->userdata);
01399 return;
01400 }
01401
01402 static
01403 #ifdef G_HAVE_INLINE
01404 inline
01405 #endif
01406 DBusGProxyCall*
01407 org_atheme_audacious_open_list_async (DBusGProxy *proxy, const char ** IN_filenames, org_atheme_audacious_open_list_reply callback, gpointer userdata)
01408
01409 {
01410 DBusGAsyncData *stuff;
01411 stuff = g_slice_new (DBusGAsyncData);
01412 stuff->cb = G_CALLBACK (callback);
01413 stuff->userdata = userdata;
01414 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);
01415 }
01416 static
01417 #ifdef G_HAVE_INLINE
01418 inline
01419 #endif
01420 gboolean
01421 org_atheme_audacious_open_list_to_temp (DBusGProxy *proxy, const char ** IN_filenames, GError **error)
01422
01423 {
01424 return dbus_g_proxy_call (proxy, "OpenListToTemp", error, G_TYPE_STRV, IN_filenames, G_TYPE_INVALID, G_TYPE_INVALID);
01425 }
01426
01427 typedef void (*org_atheme_audacious_open_list_to_temp_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
01428
01429 static void
01430 org_atheme_audacious_open_list_to_temp_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01431 {
01432 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01433 GError *error = NULL;
01434 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
01435 (*(org_atheme_audacious_open_list_to_temp_reply)data->cb) (proxy, error, data->userdata);
01436 return;
01437 }
01438
01439 static
01440 #ifdef G_HAVE_INLINE
01441 inline
01442 #endif
01443 DBusGProxyCall*
01444 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)
01445
01446 {
01447 DBusGAsyncData *stuff;
01448 stuff = g_slice_new (DBusGAsyncData);
01449 stuff->cb = G_CALLBACK (callback);
01450 stuff->userdata = userdata;
01451 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);
01452 }
01453 static
01454 #ifdef G_HAVE_INLINE
01455 inline
01456 #endif
01457 gboolean
01458 org_atheme_audacious_delete (DBusGProxy *proxy, const guint IN_pos, GError **error)
01459
01460 {
01461 return dbus_g_proxy_call (proxy, "Delete", error, G_TYPE_UINT, IN_pos, G_TYPE_INVALID, G_TYPE_INVALID);
01462 }
01463
01464 typedef void (*org_atheme_audacious_delete_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
01465
01466 static void
01467 org_atheme_audacious_delete_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01468 {
01469 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01470 GError *error = NULL;
01471 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
01472 (*(org_atheme_audacious_delete_reply)data->cb) (proxy, error, data->userdata);
01473 return;
01474 }
01475
01476 static
01477 #ifdef G_HAVE_INLINE
01478 inline
01479 #endif
01480 DBusGProxyCall*
01481 org_atheme_audacious_delete_async (DBusGProxy *proxy, const guint IN_pos, org_atheme_audacious_delete_reply callback, gpointer userdata)
01482
01483 {
01484 DBusGAsyncData *stuff;
01485 stuff = g_slice_new (DBusGAsyncData);
01486 stuff->cb = G_CALLBACK (callback);
01487 stuff->userdata = userdata;
01488 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);
01489 }
01490 static
01491 #ifdef G_HAVE_INLINE
01492 inline
01493 #endif
01494 gboolean
01495 org_atheme_audacious_clear (DBusGProxy *proxy, GError **error)
01496
01497 {
01498 return dbus_g_proxy_call (proxy, "Clear", error, G_TYPE_INVALID, G_TYPE_INVALID);
01499 }
01500
01501 typedef void (*org_atheme_audacious_clear_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
01502
01503 static void
01504 org_atheme_audacious_clear_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01505 {
01506 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01507 GError *error = NULL;
01508 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
01509 (*(org_atheme_audacious_clear_reply)data->cb) (proxy, error, data->userdata);
01510 return;
01511 }
01512
01513 static
01514 #ifdef G_HAVE_INLINE
01515 inline
01516 #endif
01517 DBusGProxyCall*
01518 org_atheme_audacious_clear_async (DBusGProxy *proxy, org_atheme_audacious_clear_reply callback, gpointer userdata)
01519
01520 {
01521 DBusGAsyncData *stuff;
01522 stuff = g_slice_new (DBusGAsyncData);
01523 stuff->cb = G_CALLBACK (callback);
01524 stuff->userdata = userdata;
01525 return dbus_g_proxy_begin_call (proxy, "Clear", org_atheme_audacious_clear_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
01526 }
01527 static
01528 #ifdef G_HAVE_INLINE
01529 inline
01530 #endif
01531 gboolean
01532 org_atheme_audacious_auto_advance (DBusGProxy *proxy, gboolean* OUT_is_advance, GError **error)
01533
01534 {
01535 return dbus_g_proxy_call (proxy, "AutoAdvance", error, G_TYPE_INVALID, G_TYPE_BOOLEAN, OUT_is_advance, G_TYPE_INVALID);
01536 }
01537
01538 typedef void (*org_atheme_audacious_auto_advance_reply) (DBusGProxy *proxy, gboolean OUT_is_advance, GError *error, gpointer userdata);
01539
01540 static void
01541 org_atheme_audacious_auto_advance_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01542 {
01543 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01544 GError *error = NULL;
01545 gboolean OUT_is_advance;
01546 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_BOOLEAN, &OUT_is_advance, G_TYPE_INVALID);
01547 (*(org_atheme_audacious_auto_advance_reply)data->cb) (proxy, OUT_is_advance, error, data->userdata);
01548 return;
01549 }
01550
01551 static
01552 #ifdef G_HAVE_INLINE
01553 inline
01554 #endif
01555 DBusGProxyCall*
01556 org_atheme_audacious_auto_advance_async (DBusGProxy *proxy, org_atheme_audacious_auto_advance_reply callback, gpointer userdata)
01557
01558 {
01559 DBusGAsyncData *stuff;
01560 stuff = g_slice_new (DBusGAsyncData);
01561 stuff->cb = G_CALLBACK (callback);
01562 stuff->userdata = userdata;
01563 return dbus_g_proxy_begin_call (proxy, "AutoAdvance", org_atheme_audacious_auto_advance_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
01564 }
01565 static
01566 #ifdef G_HAVE_INLINE
01567 inline
01568 #endif
01569 gboolean
01570 org_atheme_audacious_toggle_auto_advance (DBusGProxy *proxy, GError **error)
01571
01572 {
01573 return dbus_g_proxy_call (proxy, "ToggleAutoAdvance", error, G_TYPE_INVALID, G_TYPE_INVALID);
01574 }
01575
01576 typedef void (*org_atheme_audacious_toggle_auto_advance_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
01577
01578 static void
01579 org_atheme_audacious_toggle_auto_advance_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01580 {
01581 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01582 GError *error = NULL;
01583 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
01584 (*(org_atheme_audacious_toggle_auto_advance_reply)data->cb) (proxy, error, data->userdata);
01585 return;
01586 }
01587
01588 static
01589 #ifdef G_HAVE_INLINE
01590 inline
01591 #endif
01592 DBusGProxyCall*
01593 org_atheme_audacious_toggle_auto_advance_async (DBusGProxy *proxy, org_atheme_audacious_toggle_auto_advance_reply callback, gpointer userdata)
01594
01595 {
01596 DBusGAsyncData *stuff;
01597 stuff = g_slice_new (DBusGAsyncData);
01598 stuff->cb = G_CALLBACK (callback);
01599 stuff->userdata = userdata;
01600 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);
01601 }
01602 static
01603 #ifdef G_HAVE_INLINE
01604 inline
01605 #endif
01606 gboolean
01607 org_atheme_audacious_repeat (DBusGProxy *proxy, gboolean* OUT_is_repeat, GError **error)
01608
01609 {
01610 return dbus_g_proxy_call (proxy, "Repeat", error, G_TYPE_INVALID, G_TYPE_BOOLEAN, OUT_is_repeat, G_TYPE_INVALID);
01611 }
01612
01613 typedef void (*org_atheme_audacious_repeat_reply) (DBusGProxy *proxy, gboolean OUT_is_repeat, GError *error, gpointer userdata);
01614
01615 static void
01616 org_atheme_audacious_repeat_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01617 {
01618 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01619 GError *error = NULL;
01620 gboolean OUT_is_repeat;
01621 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_BOOLEAN, &OUT_is_repeat, G_TYPE_INVALID);
01622 (*(org_atheme_audacious_repeat_reply)data->cb) (proxy, OUT_is_repeat, error, data->userdata);
01623 return;
01624 }
01625
01626 static
01627 #ifdef G_HAVE_INLINE
01628 inline
01629 #endif
01630 DBusGProxyCall*
01631 org_atheme_audacious_repeat_async (DBusGProxy *proxy, org_atheme_audacious_repeat_reply callback, gpointer userdata)
01632
01633 {
01634 DBusGAsyncData *stuff;
01635 stuff = g_slice_new (DBusGAsyncData);
01636 stuff->cb = G_CALLBACK (callback);
01637 stuff->userdata = userdata;
01638 return dbus_g_proxy_begin_call (proxy, "Repeat", org_atheme_audacious_repeat_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
01639 }
01640 static
01641 #ifdef G_HAVE_INLINE
01642 inline
01643 #endif
01644 gboolean
01645 org_atheme_audacious_toggle_repeat (DBusGProxy *proxy, GError **error)
01646
01647 {
01648 return dbus_g_proxy_call (proxy, "ToggleRepeat", error, G_TYPE_INVALID, G_TYPE_INVALID);
01649 }
01650
01651 typedef void (*org_atheme_audacious_toggle_repeat_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
01652
01653 static void
01654 org_atheme_audacious_toggle_repeat_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01655 {
01656 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01657 GError *error = NULL;
01658 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
01659 (*(org_atheme_audacious_toggle_repeat_reply)data->cb) (proxy, error, data->userdata);
01660 return;
01661 }
01662
01663 static
01664 #ifdef G_HAVE_INLINE
01665 inline
01666 #endif
01667 DBusGProxyCall*
01668 org_atheme_audacious_toggle_repeat_async (DBusGProxy *proxy, org_atheme_audacious_toggle_repeat_reply callback, gpointer userdata)
01669
01670 {
01671 DBusGAsyncData *stuff;
01672 stuff = g_slice_new (DBusGAsyncData);
01673 stuff->cb = G_CALLBACK (callback);
01674 stuff->userdata = userdata;
01675 return dbus_g_proxy_begin_call (proxy, "ToggleRepeat", org_atheme_audacious_toggle_repeat_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
01676 }
01677 static
01678 #ifdef G_HAVE_INLINE
01679 inline
01680 #endif
01681 gboolean
01682 org_atheme_audacious_shuffle (DBusGProxy *proxy, gboolean* OUT_is_shuffle, GError **error)
01683
01684 {
01685 return dbus_g_proxy_call (proxy, "Shuffle", error, G_TYPE_INVALID, G_TYPE_BOOLEAN, OUT_is_shuffle, G_TYPE_INVALID);
01686 }
01687
01688 typedef void (*org_atheme_audacious_shuffle_reply) (DBusGProxy *proxy, gboolean OUT_is_shuffle, GError *error, gpointer userdata);
01689
01690 static void
01691 org_atheme_audacious_shuffle_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01692 {
01693 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01694 GError *error = NULL;
01695 gboolean OUT_is_shuffle;
01696 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_BOOLEAN, &OUT_is_shuffle, G_TYPE_INVALID);
01697 (*(org_atheme_audacious_shuffle_reply)data->cb) (proxy, OUT_is_shuffle, error, data->userdata);
01698 return;
01699 }
01700
01701 static
01702 #ifdef G_HAVE_INLINE
01703 inline
01704 #endif
01705 DBusGProxyCall*
01706 org_atheme_audacious_shuffle_async (DBusGProxy *proxy, org_atheme_audacious_shuffle_reply callback, gpointer userdata)
01707
01708 {
01709 DBusGAsyncData *stuff;
01710 stuff = g_slice_new (DBusGAsyncData);
01711 stuff->cb = G_CALLBACK (callback);
01712 stuff->userdata = userdata;
01713 return dbus_g_proxy_begin_call (proxy, "Shuffle", org_atheme_audacious_shuffle_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
01714 }
01715 static
01716 #ifdef G_HAVE_INLINE
01717 inline
01718 #endif
01719 gboolean
01720 org_atheme_audacious_toggle_shuffle (DBusGProxy *proxy, GError **error)
01721
01722 {
01723 return dbus_g_proxy_call (proxy, "ToggleShuffle", error, G_TYPE_INVALID, G_TYPE_INVALID);
01724 }
01725
01726 typedef void (*org_atheme_audacious_toggle_shuffle_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
01727
01728 static void
01729 org_atheme_audacious_toggle_shuffle_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01730 {
01731 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01732 GError *error = NULL;
01733 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
01734 (*(org_atheme_audacious_toggle_shuffle_reply)data->cb) (proxy, error, data->userdata);
01735 return;
01736 }
01737
01738 static
01739 #ifdef G_HAVE_INLINE
01740 inline
01741 #endif
01742 DBusGProxyCall*
01743 org_atheme_audacious_toggle_shuffle_async (DBusGProxy *proxy, org_atheme_audacious_toggle_shuffle_reply callback, gpointer userdata)
01744
01745 {
01746 DBusGAsyncData *stuff;
01747 stuff = g_slice_new (DBusGAsyncData);
01748 stuff->cb = G_CALLBACK (callback);
01749 stuff->userdata = userdata;
01750 return dbus_g_proxy_begin_call (proxy, "ToggleShuffle", org_atheme_audacious_toggle_shuffle_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
01751 }
01752 static
01753 #ifdef G_HAVE_INLINE
01754 inline
01755 #endif
01756 gboolean
01757 org_atheme_audacious_show_prefs_box (DBusGProxy *proxy, const gboolean IN_show, GError **error)
01758
01759 {
01760 return dbus_g_proxy_call (proxy, "ShowPrefsBox", error, G_TYPE_BOOLEAN, IN_show, G_TYPE_INVALID, G_TYPE_INVALID);
01761 }
01762
01763 typedef void (*org_atheme_audacious_show_prefs_box_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
01764
01765 static void
01766 org_atheme_audacious_show_prefs_box_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01767 {
01768 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01769 GError *error = NULL;
01770 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
01771 (*(org_atheme_audacious_show_prefs_box_reply)data->cb) (proxy, error, data->userdata);
01772 return;
01773 }
01774
01775 static
01776 #ifdef G_HAVE_INLINE
01777 inline
01778 #endif
01779 DBusGProxyCall*
01780 org_atheme_audacious_show_prefs_box_async (DBusGProxy *proxy, const gboolean IN_show, org_atheme_audacious_show_prefs_box_reply callback, gpointer userdata)
01781
01782 {
01783 DBusGAsyncData *stuff;
01784 stuff = g_slice_new (DBusGAsyncData);
01785 stuff->cb = G_CALLBACK (callback);
01786 stuff->userdata = userdata;
01787 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);
01788 }
01789 static
01790 #ifdef G_HAVE_INLINE
01791 inline
01792 #endif
01793 gboolean
01794 org_atheme_audacious_show_about_box (DBusGProxy *proxy, const gboolean IN_show, GError **error)
01795
01796 {
01797 return dbus_g_proxy_call (proxy, "ShowAboutBox", error, G_TYPE_BOOLEAN, IN_show, G_TYPE_INVALID, G_TYPE_INVALID);
01798 }
01799
01800 typedef void (*org_atheme_audacious_show_about_box_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
01801
01802 static void
01803 org_atheme_audacious_show_about_box_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01804 {
01805 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01806 GError *error = NULL;
01807 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
01808 (*(org_atheme_audacious_show_about_box_reply)data->cb) (proxy, error, data->userdata);
01809 return;
01810 }
01811
01812 static
01813 #ifdef G_HAVE_INLINE
01814 inline
01815 #endif
01816 DBusGProxyCall*
01817 org_atheme_audacious_show_about_box_async (DBusGProxy *proxy, const gboolean IN_show, org_atheme_audacious_show_about_box_reply callback, gpointer userdata)
01818
01819 {
01820 DBusGAsyncData *stuff;
01821 stuff = g_slice_new (DBusGAsyncData);
01822 stuff->cb = G_CALLBACK (callback);
01823 stuff->userdata = userdata;
01824 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);
01825 }
01826 static
01827 #ifdef G_HAVE_INLINE
01828 inline
01829 #endif
01830 gboolean
01831 org_atheme_audacious_show_jtf_box (DBusGProxy *proxy, const gboolean IN_show, GError **error)
01832
01833 {
01834 return dbus_g_proxy_call (proxy, "ShowJtfBox", error, G_TYPE_BOOLEAN, IN_show, G_TYPE_INVALID, G_TYPE_INVALID);
01835 }
01836
01837 typedef void (*org_atheme_audacious_show_jtf_box_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
01838
01839 static void
01840 org_atheme_audacious_show_jtf_box_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01841 {
01842 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01843 GError *error = NULL;
01844 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
01845 (*(org_atheme_audacious_show_jtf_box_reply)data->cb) (proxy, error, data->userdata);
01846 return;
01847 }
01848
01849 static
01850 #ifdef G_HAVE_INLINE
01851 inline
01852 #endif
01853 DBusGProxyCall*
01854 org_atheme_audacious_show_jtf_box_async (DBusGProxy *proxy, const gboolean IN_show, org_atheme_audacious_show_jtf_box_reply callback, gpointer userdata)
01855
01856 {
01857 DBusGAsyncData *stuff;
01858 stuff = g_slice_new (DBusGAsyncData);
01859 stuff->cb = G_CALLBACK (callback);
01860 stuff->userdata = userdata;
01861 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);
01862 }
01863 static
01864 #ifdef G_HAVE_INLINE
01865 inline
01866 #endif
01867 gboolean
01868 org_atheme_audacious_show_filebrowser (DBusGProxy *proxy, const gboolean IN_show, GError **error)
01869
01870 {
01871 return dbus_g_proxy_call (proxy, "ShowFilebrowser", error, G_TYPE_BOOLEAN, IN_show, G_TYPE_INVALID, G_TYPE_INVALID);
01872 }
01873
01874 typedef void (*org_atheme_audacious_show_filebrowser_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
01875
01876 static void
01877 org_atheme_audacious_show_filebrowser_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01878 {
01879 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01880 GError *error = NULL;
01881 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
01882 (*(org_atheme_audacious_show_filebrowser_reply)data->cb) (proxy, error, data->userdata);
01883 return;
01884 }
01885
01886 static
01887 #ifdef G_HAVE_INLINE
01888 inline
01889 #endif
01890 DBusGProxyCall*
01891 org_atheme_audacious_show_filebrowser_async (DBusGProxy *proxy, const gboolean IN_show, org_atheme_audacious_show_filebrowser_reply callback, gpointer userdata)
01892
01893 {
01894 DBusGAsyncData *stuff;
01895 stuff = g_slice_new (DBusGAsyncData);
01896 stuff->cb = G_CALLBACK (callback);
01897 stuff->userdata = userdata;
01898 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);
01899 }
01900 static
01901 #ifdef G_HAVE_INLINE
01902 inline
01903 #endif
01904 gboolean
01905 org_atheme_audacious_play_pause (DBusGProxy *proxy, GError **error)
01906
01907 {
01908 return dbus_g_proxy_call (proxy, "PlayPause", error, G_TYPE_INVALID, G_TYPE_INVALID);
01909 }
01910
01911 typedef void (*org_atheme_audacious_play_pause_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
01912
01913 static void
01914 org_atheme_audacious_play_pause_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01915 {
01916 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01917 GError *error = NULL;
01918 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
01919 (*(org_atheme_audacious_play_pause_reply)data->cb) (proxy, error, data->userdata);
01920 return;
01921 }
01922
01923 static
01924 #ifdef G_HAVE_INLINE
01925 inline
01926 #endif
01927 DBusGProxyCall*
01928 org_atheme_audacious_play_pause_async (DBusGProxy *proxy, org_atheme_audacious_play_pause_reply callback, gpointer userdata)
01929
01930 {
01931 DBusGAsyncData *stuff;
01932 stuff = g_slice_new (DBusGAsyncData);
01933 stuff->cb = G_CALLBACK (callback);
01934 stuff->userdata = userdata;
01935 return dbus_g_proxy_begin_call (proxy, "PlayPause", org_atheme_audacious_play_pause_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
01936 }
01937 static
01938 #ifdef G_HAVE_INLINE
01939 inline
01940 #endif
01941 gboolean
01942 org_atheme_audacious_activate (DBusGProxy *proxy, GError **error)
01943
01944 {
01945 return dbus_g_proxy_call (proxy, "Activate", error, G_TYPE_INVALID, G_TYPE_INVALID);
01946 }
01947
01948 typedef void (*org_atheme_audacious_activate_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
01949
01950 static void
01951 org_atheme_audacious_activate_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01952 {
01953 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01954 GError *error = NULL;
01955 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
01956 (*(org_atheme_audacious_activate_reply)data->cb) (proxy, error, data->userdata);
01957 return;
01958 }
01959
01960 static
01961 #ifdef G_HAVE_INLINE
01962 inline
01963 #endif
01964 DBusGProxyCall*
01965 org_atheme_audacious_activate_async (DBusGProxy *proxy, org_atheme_audacious_activate_reply callback, gpointer userdata)
01966
01967 {
01968 DBusGAsyncData *stuff;
01969 stuff = g_slice_new (DBusGAsyncData);
01970 stuff->cb = G_CALLBACK (callback);
01971 stuff->userdata = userdata;
01972 return dbus_g_proxy_begin_call (proxy, "Activate", org_atheme_audacious_activate_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
01973 }
01974 static
01975 #ifdef G_HAVE_INLINE
01976 inline
01977 #endif
01978 gboolean
01979 org_atheme_audacious_queue_get_list_pos (DBusGProxy *proxy, const guint IN_qpos, guint* OUT_pos, GError **error)
01980
01981 {
01982 return dbus_g_proxy_call (proxy, "QueueGetListPos", error, G_TYPE_UINT, IN_qpos, G_TYPE_INVALID, G_TYPE_UINT, OUT_pos, G_TYPE_INVALID);
01983 }
01984
01985 typedef void (*org_atheme_audacious_queue_get_list_pos_reply) (DBusGProxy *proxy, guint OUT_pos, GError *error, gpointer userdata);
01986
01987 static void
01988 org_atheme_audacious_queue_get_list_pos_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01989 {
01990 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01991 GError *error = NULL;
01992 guint OUT_pos;
01993 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_UINT, &OUT_pos, G_TYPE_INVALID);
01994 (*(org_atheme_audacious_queue_get_list_pos_reply)data->cb) (proxy, OUT_pos, error, data->userdata);
01995 return;
01996 }
01997
01998 static
01999 #ifdef G_HAVE_INLINE
02000 inline
02001 #endif
02002 DBusGProxyCall*
02003 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)
02004
02005 {
02006 DBusGAsyncData *stuff;
02007 stuff = g_slice_new (DBusGAsyncData);
02008 stuff->cb = G_CALLBACK (callback);
02009 stuff->userdata = userdata;
02010 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);
02011 }
02012 static
02013 #ifdef G_HAVE_INLINE
02014 inline
02015 #endif
02016 gboolean
02017 org_atheme_audacious_queue_get_queue_pos (DBusGProxy *proxy, const guint IN_pos, guint* OUT_qpos, GError **error)
02018
02019 {
02020 return dbus_g_proxy_call (proxy, "QueueGetQueuePos", error, G_TYPE_UINT, IN_pos, G_TYPE_INVALID, G_TYPE_UINT, OUT_qpos, G_TYPE_INVALID);
02021 }
02022
02023 typedef void (*org_atheme_audacious_queue_get_queue_pos_reply) (DBusGProxy *proxy, guint OUT_qpos, GError *error, gpointer userdata);
02024
02025 static void
02026 org_atheme_audacious_queue_get_queue_pos_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
02027 {
02028 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
02029 GError *error = NULL;
02030 guint OUT_qpos;
02031 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_UINT, &OUT_qpos, G_TYPE_INVALID);
02032 (*(org_atheme_audacious_queue_get_queue_pos_reply)data->cb) (proxy, OUT_qpos, error, data->userdata);
02033 return;
02034 }
02035
02036 static
02037 #ifdef G_HAVE_INLINE
02038 inline
02039 #endif
02040 DBusGProxyCall*
02041 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)
02042
02043 {
02044 DBusGAsyncData *stuff;
02045 stuff = g_slice_new (DBusGAsyncData);
02046 stuff->cb = G_CALLBACK (callback);
02047 stuff->userdata = userdata;
02048 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);
02049 }
02050 static
02051 #ifdef G_HAVE_INLINE
02052 inline
02053 #endif
02054 gboolean
02055 org_atheme_audacious_get_info (DBusGProxy *proxy, gint* OUT_rate, gint* OUT_freq, gint* OUT_nch, GError **error)
02056
02057 {
02058 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);
02059 }
02060
02061 typedef void (*org_atheme_audacious_get_info_reply) (DBusGProxy *proxy, gint OUT_rate, gint OUT_freq, gint OUT_nch, GError *error, gpointer userdata);
02062
02063 static void
02064 org_atheme_audacious_get_info_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
02065 {
02066 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
02067 GError *error = NULL;
02068 gint OUT_rate;
02069 gint OUT_freq;
02070 gint OUT_nch;
02071 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);
02072 (*(org_atheme_audacious_get_info_reply)data->cb) (proxy, OUT_rate, OUT_freq, OUT_nch, error, data->userdata);
02073 return;
02074 }
02075
02076 static
02077 #ifdef G_HAVE_INLINE
02078 inline
02079 #endif
02080 DBusGProxyCall*
02081 org_atheme_audacious_get_info_async (DBusGProxy *proxy, org_atheme_audacious_get_info_reply callback, gpointer userdata)
02082
02083 {
02084 DBusGAsyncData *stuff;
02085 stuff = g_slice_new (DBusGAsyncData);
02086 stuff->cb = G_CALLBACK (callback);
02087 stuff->userdata = userdata;
02088 return dbus_g_proxy_begin_call (proxy, "GetInfo", org_atheme_audacious_get_info_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
02089 }
02090 static
02091 #ifdef G_HAVE_INLINE
02092 inline
02093 #endif
02094 gboolean
02095 org_atheme_audacious_toggle_aot (DBusGProxy *proxy, const gboolean IN_ontop, GError **error)
02096
02097 {
02098 return dbus_g_proxy_call (proxy, "ToggleAot", error, G_TYPE_BOOLEAN, IN_ontop, G_TYPE_INVALID, G_TYPE_INVALID);
02099 }
02100
02101 typedef void (*org_atheme_audacious_toggle_aot_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
02102
02103 static void
02104 org_atheme_audacious_toggle_aot_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
02105 {
02106 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
02107 GError *error = NULL;
02108 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
02109 (*(org_atheme_audacious_toggle_aot_reply)data->cb) (proxy, error, data->userdata);
02110 return;
02111 }
02112
02113 static
02114 #ifdef G_HAVE_INLINE
02115 inline
02116 #endif
02117 DBusGProxyCall*
02118 org_atheme_audacious_toggle_aot_async (DBusGProxy *proxy, const gboolean IN_ontop, org_atheme_audacious_toggle_aot_reply callback, gpointer userdata)
02119
02120 {
02121 DBusGAsyncData *stuff;
02122 stuff = g_slice_new (DBusGAsyncData);
02123 stuff->cb = G_CALLBACK (callback);
02124 stuff->userdata = userdata;
02125 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);
02126 }
02127 static
02128 #ifdef G_HAVE_INLINE
02129 inline
02130 #endif
02131 gboolean
02132 org_atheme_audacious_get_playqueue_length (DBusGProxy *proxy, gint* OUT_length, GError **error)
02133
02134 {
02135 return dbus_g_proxy_call (proxy, "GetPlayqueueLength", error, G_TYPE_INVALID, G_TYPE_INT, OUT_length, G_TYPE_INVALID);
02136 }
02137
02138 typedef void (*org_atheme_audacious_get_playqueue_length_reply) (DBusGProxy *proxy, gint OUT_length, GError *error, gpointer userdata);
02139
02140 static void
02141 org_atheme_audacious_get_playqueue_length_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
02142 {
02143 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
02144 GError *error = NULL;
02145 gint OUT_length;
02146 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INT, &OUT_length, G_TYPE_INVALID);
02147 (*(org_atheme_audacious_get_playqueue_length_reply)data->cb) (proxy, OUT_length, error, data->userdata);
02148 return;
02149 }
02150
02151 static
02152 #ifdef G_HAVE_INLINE
02153 inline
02154 #endif
02155 DBusGProxyCall*
02156 org_atheme_audacious_get_playqueue_length_async (DBusGProxy *proxy, org_atheme_audacious_get_playqueue_length_reply callback, gpointer userdata)
02157
02158 {
02159 DBusGAsyncData *stuff;
02160 stuff = g_slice_new (DBusGAsyncData);
02161 stuff->cb = G_CALLBACK (callback);
02162 stuff->userdata = userdata;
02163 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);
02164 }
02165 static
02166 #ifdef G_HAVE_INLINE
02167 inline
02168 #endif
02169 gboolean
02170 org_atheme_audacious_playlist_ins_url_string (DBusGProxy *proxy, const char * IN_url, const gint IN_pos, GError **error)
02171
02172 {
02173 return dbus_g_proxy_call (proxy, "PlaylistInsUrlString", error, G_TYPE_STRING, IN_url, G_TYPE_INT, IN_pos, G_TYPE_INVALID, G_TYPE_INVALID);
02174 }
02175
02176 typedef void (*org_atheme_audacious_playlist_ins_url_string_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
02177
02178 static void
02179 org_atheme_audacious_playlist_ins_url_string_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
02180 {
02181 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
02182 GError *error = NULL;
02183 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
02184 (*(org_atheme_audacious_playlist_ins_url_string_reply)data->cb) (proxy, error, data->userdata);
02185 return;
02186 }
02187
02188 static
02189 #ifdef G_HAVE_INLINE
02190 inline
02191 #endif
02192 DBusGProxyCall*
02193 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)
02194
02195 {
02196 DBusGAsyncData *stuff;
02197 stuff = g_slice_new (DBusGAsyncData);
02198 stuff->cb = G_CALLBACK (callback);
02199 stuff->userdata = userdata;
02200 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);
02201 }
02202 static
02203 #ifdef G_HAVE_INLINE
02204 inline
02205 #endif
02206 gboolean
02207 org_atheme_audacious_playlist_add (DBusGProxy *proxy, const char * IN_list, GError **error)
02208
02209 {
02210 return dbus_g_proxy_call (proxy, "PlaylistAdd", error, G_TYPE_STRING, IN_list, G_TYPE_INVALID, G_TYPE_INVALID);
02211 }
02212
02213 typedef void (*org_atheme_audacious_playlist_add_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
02214
02215 static void
02216 org_atheme_audacious_playlist_add_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
02217 {
02218 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
02219 GError *error = NULL;
02220 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
02221 (*(org_atheme_audacious_playlist_add_reply)data->cb) (proxy, error, data->userdata);
02222 return;
02223 }
02224
02225 static
02226 #ifdef G_HAVE_INLINE
02227 inline
02228 #endif
02229 DBusGProxyCall*
02230 org_atheme_audacious_playlist_add_async (DBusGProxy *proxy, const char * IN_list, org_atheme_audacious_playlist_add_reply callback, gpointer userdata)
02231
02232 {
02233 DBusGAsyncData *stuff;
02234 stuff = g_slice_new (DBusGAsyncData);
02235 stuff->cb = G_CALLBACK (callback);
02236 stuff->userdata = userdata;
02237 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);
02238 }
02239 static
02240 #ifdef G_HAVE_INLINE
02241 inline
02242 #endif
02243 gboolean
02244 org_atheme_audacious_playqueue_add (DBusGProxy *proxy, const gint IN_pos, GError **error)
02245
02246 {
02247 return dbus_g_proxy_call (proxy, "PlayqueueAdd", error, G_TYPE_INT, IN_pos, G_TYPE_INVALID, G_TYPE_INVALID);
02248 }
02249
02250 typedef void (*org_atheme_audacious_playqueue_add_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
02251
02252 static void
02253 org_atheme_audacious_playqueue_add_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
02254 {
02255 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
02256 GError *error = NULL;
02257 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
02258 (*(org_atheme_audacious_playqueue_add_reply)data->cb) (proxy, error, data->userdata);
02259 return;
02260 }
02261
02262 static
02263 #ifdef G_HAVE_INLINE
02264 inline
02265 #endif
02266 DBusGProxyCall*
02267 org_atheme_audacious_playqueue_add_async (DBusGProxy *proxy, const gint IN_pos, org_atheme_audacious_playqueue_add_reply callback, gpointer userdata)
02268
02269 {
02270 DBusGAsyncData *stuff;
02271 stuff = g_slice_new (DBusGAsyncData);
02272 stuff->cb = G_CALLBACK (callback);
02273 stuff->userdata = userdata;
02274 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);
02275 }
02276 static
02277 #ifdef G_HAVE_INLINE
02278 inline
02279 #endif
02280 gboolean
02281 org_atheme_audacious_playqueue_remove (DBusGProxy *proxy, const gint IN_pos, GError **error)
02282
02283 {
02284 return dbus_g_proxy_call (proxy, "PlayqueueRemove", error, G_TYPE_INT, IN_pos, G_TYPE_INVALID, G_TYPE_INVALID);
02285 }
02286
02287 typedef void (*org_atheme_audacious_playqueue_remove_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
02288
02289 static void
02290 org_atheme_audacious_playqueue_remove_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
02291 {
02292 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
02293 GError *error = NULL;
02294 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
02295 (*(org_atheme_audacious_playqueue_remove_reply)data->cb) (proxy, error, data->userdata);
02296 return;
02297 }
02298
02299 static
02300 #ifdef G_HAVE_INLINE
02301 inline
02302 #endif
02303 DBusGProxyCall*
02304 org_atheme_audacious_playqueue_remove_async (DBusGProxy *proxy, const gint IN_pos, org_atheme_audacious_playqueue_remove_reply callback, gpointer userdata)
02305
02306 {
02307 DBusGAsyncData *stuff;
02308 stuff = g_slice_new (DBusGAsyncData);
02309 stuff->cb = G_CALLBACK (callback);
02310 stuff->userdata = userdata;
02311 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);
02312 }
02313 static
02314 #ifdef G_HAVE_INLINE
02315 inline
02316 #endif
02317 gboolean
02318 org_atheme_audacious_playqueue_clear (DBusGProxy *proxy, GError **error)
02319
02320 {
02321 return dbus_g_proxy_call (proxy, "PlayqueueClear", error, G_TYPE_INVALID, G_TYPE_INVALID);
02322 }
02323
02324 typedef void (*org_atheme_audacious_playqueue_clear_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
02325
02326 static void
02327 org_atheme_audacious_playqueue_clear_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
02328 {
02329 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
02330 GError *error = NULL;
02331 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
02332 (*(org_atheme_audacious_playqueue_clear_reply)data->cb) (proxy, error, data->userdata);
02333 return;
02334 }
02335
02336 static
02337 #ifdef G_HAVE_INLINE
02338 inline
02339 #endif
02340 DBusGProxyCall*
02341 org_atheme_audacious_playqueue_clear_async (DBusGProxy *proxy, org_atheme_audacious_playqueue_clear_reply callback, gpointer userdata)
02342
02343 {
02344 DBusGAsyncData *stuff;
02345 stuff = g_slice_new (DBusGAsyncData);
02346 stuff->cb = G_CALLBACK (callback);
02347 stuff->userdata = userdata;
02348 return dbus_g_proxy_begin_call (proxy, "PlayqueueClear", org_atheme_audacious_playqueue_clear_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
02349 }
02350 static
02351 #ifdef G_HAVE_INLINE
02352 inline
02353 #endif
02354 gboolean
02355 org_atheme_audacious_playqueue_is_queued (DBusGProxy *proxy, const gint IN_pos, gboolean* OUT_is_queued, GError **error)
02356
02357 {
02358 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);
02359 }
02360
02361 typedef void (*org_atheme_audacious_playqueue_is_queued_reply) (DBusGProxy *proxy, gboolean OUT_is_queued, GError *error, gpointer userdata);
02362
02363 static void
02364 org_atheme_audacious_playqueue_is_queued_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
02365 {
02366 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
02367 GError *error = NULL;
02368 gboolean OUT_is_queued;
02369 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_BOOLEAN, &OUT_is_queued, G_TYPE_INVALID);
02370 (*(org_atheme_audacious_playqueue_is_queued_reply)data->cb) (proxy, OUT_is_queued, error, data->userdata);
02371 return;
02372 }
02373
02374 static
02375 #ifdef G_HAVE_INLINE
02376 inline
02377 #endif
02378 DBusGProxyCall*
02379 org_atheme_audacious_playqueue_is_queued_async (DBusGProxy *proxy, const gint IN_pos, org_atheme_audacious_playqueue_is_queued_reply callback, gpointer userdata)
02380
02381 {
02382 DBusGAsyncData *stuff;
02383 stuff = g_slice_new (DBusGAsyncData);
02384 stuff->cb = G_CALLBACK (callback);
02385 stuff->userdata = userdata;
02386 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);
02387 }
02388 static
02389 #ifdef G_HAVE_INLINE
02390 inline
02391 #endif
02392 gboolean
02393 org_atheme_audacious_playlist_enqueue_to_temp (DBusGProxy *proxy, const char * IN_url, GError **error)
02394
02395 {
02396 return dbus_g_proxy_call (proxy, "PlaylistEnqueueToTemp", error, G_TYPE_STRING, IN_url, G_TYPE_INVALID, G_TYPE_INVALID);
02397 }
02398
02399 typedef void (*org_atheme_audacious_playlist_enqueue_to_temp_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
02400
02401 static void
02402 org_atheme_audacious_playlist_enqueue_to_temp_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
02403 {
02404 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
02405 GError *error = NULL;
02406 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
02407 (*(org_atheme_audacious_playlist_enqueue_to_temp_reply)data->cb) (proxy, error, data->userdata);
02408 return;
02409 }
02410
02411 static
02412 #ifdef G_HAVE_INLINE
02413 inline
02414 #endif
02415 DBusGProxyCall*
02416 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)
02417
02418 {
02419 DBusGAsyncData *stuff;
02420 stuff = g_slice_new (DBusGAsyncData);
02421 stuff->cb = G_CALLBACK (callback);
02422 stuff->userdata = userdata;
02423 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);
02424 }
02425 static
02426 #ifdef G_HAVE_INLINE
02427 inline
02428 #endif
02429 gboolean
02430 org_atheme_audacious_get_eq (DBusGProxy *proxy, gdouble* OUT_preamp, GArray** OUT_bands, GError **error)
02431
02432 {
02433 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);
02434 }
02435
02436 typedef void (*org_atheme_audacious_get_eq_reply) (DBusGProxy *proxy, gdouble OUT_preamp, GArray *OUT_bands, GError *error, gpointer userdata);
02437
02438 static void
02439 org_atheme_audacious_get_eq_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
02440 {
02441 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
02442 GError *error = NULL;
02443 gdouble OUT_preamp;
02444 GArray* OUT_bands;
02445 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);
02446 (*(org_atheme_audacious_get_eq_reply)data->cb) (proxy, OUT_preamp, OUT_bands, error, data->userdata);
02447 return;
02448 }
02449
02450 static
02451 #ifdef G_HAVE_INLINE
02452 inline
02453 #endif
02454 DBusGProxyCall*
02455 org_atheme_audacious_get_eq_async (DBusGProxy *proxy, org_atheme_audacious_get_eq_reply callback, gpointer userdata)
02456
02457 {
02458 DBusGAsyncData *stuff;
02459 stuff = g_slice_new (DBusGAsyncData);
02460 stuff->cb = G_CALLBACK (callback);
02461 stuff->userdata = userdata;
02462 return dbus_g_proxy_begin_call (proxy, "GetEq", org_atheme_audacious_get_eq_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
02463 }
02464 static
02465 #ifdef G_HAVE_INLINE
02466 inline
02467 #endif
02468 gboolean
02469 org_atheme_audacious_get_eq_preamp (DBusGProxy *proxy, gdouble* OUT_preamp, GError **error)
02470
02471 {
02472 return dbus_g_proxy_call (proxy, "GetEqPreamp", error, G_TYPE_INVALID, G_TYPE_DOUBLE, OUT_preamp, G_TYPE_INVALID);
02473 }
02474
02475 typedef void (*org_atheme_audacious_get_eq_preamp_reply) (DBusGProxy *proxy, gdouble OUT_preamp, GError *error, gpointer userdata);
02476
02477 static void
02478 org_atheme_audacious_get_eq_preamp_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
02479 {
02480 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
02481 GError *error = NULL;
02482 gdouble OUT_preamp;
02483 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_DOUBLE, &OUT_preamp, G_TYPE_INVALID);
02484 (*(org_atheme_audacious_get_eq_preamp_reply)data->cb) (proxy, OUT_preamp, error, data->userdata);
02485 return;
02486 }
02487
02488 static
02489 #ifdef G_HAVE_INLINE
02490 inline
02491 #endif
02492 DBusGProxyCall*
02493 org_atheme_audacious_get_eq_preamp_async (DBusGProxy *proxy, org_atheme_audacious_get_eq_preamp_reply callback, gpointer userdata)
02494
02495 {
02496 DBusGAsyncData *stuff;
02497 stuff = g_slice_new (DBusGAsyncData);
02498 stuff->cb = G_CALLBACK (callback);
02499 stuff->userdata = userdata;
02500 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);
02501 }
02502 static
02503 #ifdef G_HAVE_INLINE
02504 inline
02505 #endif
02506 gboolean
02507 org_atheme_audacious_get_eq_band (DBusGProxy *proxy, const gint IN_band, gdouble* OUT_value, GError **error)
02508
02509 {
02510 return dbus_g_proxy_call (proxy, "GetEqBand", error, G_TYPE_INT, IN_band, G_TYPE_INVALID, G_TYPE_DOUBLE, OUT_value, G_TYPE_INVALID);
02511 }
02512
02513 typedef void (*org_atheme_audacious_get_eq_band_reply) (DBusGProxy *proxy, gdouble OUT_value, GError *error, gpointer userdata);
02514
02515 static void
02516 org_atheme_audacious_get_eq_band_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
02517 {
02518 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
02519 GError *error = NULL;
02520 gdouble OUT_value;
02521 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_DOUBLE, &OUT_value, G_TYPE_INVALID);
02522 (*(org_atheme_audacious_get_eq_band_reply)data->cb) (proxy, OUT_value, error, data->userdata);
02523 return;
02524 }
02525
02526 static
02527 #ifdef G_HAVE_INLINE
02528 inline
02529 #endif
02530 DBusGProxyCall*
02531 org_atheme_audacious_get_eq_band_async (DBusGProxy *proxy, const gint IN_band, org_atheme_audacious_get_eq_band_reply callback, gpointer userdata)
02532
02533 {
02534 DBusGAsyncData *stuff;
02535 stuff = g_slice_new (DBusGAsyncData);
02536 stuff->cb = G_CALLBACK (callback);
02537 stuff->userdata = userdata;
02538 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);
02539 }
02540 static
02541 #ifdef G_HAVE_INLINE
02542 inline
02543 #endif
02544 gboolean
02545 org_atheme_audacious_set_eq (DBusGProxy *proxy, const gdouble IN_preamp, const GArray* IN_bands, GError **error)
02546
02547 {
02548 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);
02549 }
02550
02551 typedef void (*org_atheme_audacious_set_eq_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
02552
02553 static void
02554 org_atheme_audacious_set_eq_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
02555 {
02556 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
02557 GError *error = NULL;
02558 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
02559 (*(org_atheme_audacious_set_eq_reply)data->cb) (proxy, error, data->userdata);
02560 return;
02561 }
02562
02563 static
02564 #ifdef G_HAVE_INLINE
02565 inline
02566 #endif
02567 DBusGProxyCall*
02568 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)
02569
02570 {
02571 DBusGAsyncData *stuff;
02572 stuff = g_slice_new (DBusGAsyncData);
02573 stuff->cb = G_CALLBACK (callback);
02574 stuff->userdata = userdata;
02575 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);
02576 }
02577 static
02578 #ifdef G_HAVE_INLINE
02579 inline
02580 #endif
02581 gboolean
02582 org_atheme_audacious_set_eq_preamp (DBusGProxy *proxy, const gdouble IN_preamp, GError **error)
02583
02584 {
02585 return dbus_g_proxy_call (proxy, "SetEqPreamp", error, G_TYPE_DOUBLE, IN_preamp, G_TYPE_INVALID, G_TYPE_INVALID);
02586 }
02587
02588 typedef void (*org_atheme_audacious_set_eq_preamp_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
02589
02590 static void
02591 org_atheme_audacious_set_eq_preamp_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
02592 {
02593 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
02594 GError *error = NULL;
02595 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
02596 (*(org_atheme_audacious_set_eq_preamp_reply)data->cb) (proxy, error, data->userdata);
02597 return;
02598 }
02599
02600 static
02601 #ifdef G_HAVE_INLINE
02602 inline
02603 #endif
02604 DBusGProxyCall*
02605 org_atheme_audacious_set_eq_preamp_async (DBusGProxy *proxy, const gdouble IN_preamp, org_atheme_audacious_set_eq_preamp_reply callback, gpointer userdata)
02606
02607 {
02608 DBusGAsyncData *stuff;
02609 stuff = g_slice_new (DBusGAsyncData);
02610 stuff->cb = G_CALLBACK (callback);
02611 stuff->userdata = userdata;
02612 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);
02613 }
02614 static
02615 #ifdef G_HAVE_INLINE
02616 inline
02617 #endif
02618 gboolean
02619 org_atheme_audacious_set_eq_band (DBusGProxy *proxy, const gint IN_band, const gdouble IN_value, GError **error)
02620
02621 {
02622 return dbus_g_proxy_call (proxy, "SetEqBand", error, G_TYPE_INT, IN_band, G_TYPE_DOUBLE, IN_value, G_TYPE_INVALID, G_TYPE_INVALID);
02623 }
02624
02625 typedef void (*org_atheme_audacious_set_eq_band_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
02626
02627 static void
02628 org_atheme_audacious_set_eq_band_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
02629 {
02630 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
02631 GError *error = NULL;
02632 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
02633 (*(org_atheme_audacious_set_eq_band_reply)data->cb) (proxy, error, data->userdata);
02634 return;
02635 }
02636
02637 static
02638 #ifdef G_HAVE_INLINE
02639 inline
02640 #endif
02641 DBusGProxyCall*
02642 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)
02643
02644 {
02645 DBusGAsyncData *stuff;
02646 stuff = g_slice_new (DBusGAsyncData);
02647 stuff->cb = G_CALLBACK (callback);
02648 stuff->userdata = userdata;
02649 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);
02650 }
02651 static
02652 #ifdef G_HAVE_INLINE
02653 inline
02654 #endif
02655 gboolean
02656 org_atheme_audacious_equalizer_activate (DBusGProxy *proxy, const gboolean IN_active, GError **error)
02657
02658 {
02659 return dbus_g_proxy_call (proxy, "EqualizerActivate", error, G_TYPE_BOOLEAN, IN_active, G_TYPE_INVALID, G_TYPE_INVALID);
02660 }
02661
02662 typedef void (*org_atheme_audacious_equalizer_activate_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
02663
02664 static void
02665 org_atheme_audacious_equalizer_activate_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
02666 {
02667 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
02668 GError *error = NULL;
02669 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
02670 (*(org_atheme_audacious_equalizer_activate_reply)data->cb) (proxy, error, data->userdata);
02671 return;
02672 }
02673
02674 static
02675 #ifdef G_HAVE_INLINE
02676 inline
02677 #endif
02678 DBusGProxyCall*
02679 org_atheme_audacious_equalizer_activate_async (DBusGProxy *proxy, const gboolean IN_active, org_atheme_audacious_equalizer_activate_reply callback, gpointer userdata)
02680
02681 {
02682 DBusGAsyncData *stuff;
02683 stuff = g_slice_new (DBusGAsyncData);
02684 stuff->cb = G_CALLBACK (callback);
02685 stuff->userdata = userdata;
02686 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);
02687 }
02688 static
02689 #ifdef G_HAVE_INLINE
02690 inline
02691 #endif
02692 gboolean
02693 org_atheme_audacious_get_active_playlist_name (DBusGProxy *proxy, char ** OUT_plname, GError **error)
02694
02695 {
02696 return dbus_g_proxy_call (proxy, "GetActivePlaylistName", error, G_TYPE_INVALID, G_TYPE_STRING, OUT_plname, G_TYPE_INVALID);
02697 }
02698
02699 typedef void (*org_atheme_audacious_get_active_playlist_name_reply) (DBusGProxy *proxy, char * OUT_plname, GError *error, gpointer userdata);
02700
02701 static void
02702 org_atheme_audacious_get_active_playlist_name_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
02703 {
02704 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
02705 GError *error = NULL;
02706 char * OUT_plname;
02707 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_STRING, &OUT_plname, G_TYPE_INVALID);
02708 (*(org_atheme_audacious_get_active_playlist_name_reply)data->cb) (proxy, OUT_plname, error, data->userdata);
02709 return;
02710 }
02711
02712 static
02713 #ifdef G_HAVE_INLINE
02714 inline
02715 #endif
02716 DBusGProxyCall*
02717 org_atheme_audacious_get_active_playlist_name_async (DBusGProxy *proxy, org_atheme_audacious_get_active_playlist_name_reply callback, gpointer userdata)
02718
02719 {
02720 DBusGAsyncData *stuff;
02721 stuff = g_slice_new (DBusGAsyncData);
02722 stuff->cb = G_CALLBACK (callback);
02723 stuff->userdata = userdata;
02724 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);
02725 }
02726 #endif
02727
02728 G_END_DECLS