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_get_tuple_fields (DBusGProxy *proxy, char *** OUT_fields, GError **error)
00217
00218 {
00219 return dbus_g_proxy_call (proxy, "GetTupleFields", error, G_TYPE_INVALID, G_TYPE_STRV, OUT_fields, G_TYPE_INVALID);
00220 }
00221
00222 typedef void (*org_atheme_audacious_get_tuple_fields_reply) (DBusGProxy *proxy, char * *OUT_fields, GError *error, gpointer userdata);
00223
00224 static void
00225 org_atheme_audacious_get_tuple_fields_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
00226 {
00227 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
00228 GError *error = NULL;
00229 char ** OUT_fields;
00230 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_STRV, &OUT_fields, G_TYPE_INVALID);
00231 (*(org_atheme_audacious_get_tuple_fields_reply)data->cb) (proxy, OUT_fields, error, data->userdata);
00232 return;
00233 }
00234
00235 static
00236 #ifdef G_HAVE_INLINE
00237 inline
00238 #endif
00239 DBusGProxyCall*
00240 org_atheme_audacious_get_tuple_fields_async (DBusGProxy *proxy, org_atheme_audacious_get_tuple_fields_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, "GetTupleFields", org_atheme_audacious_get_tuple_fields_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_play (DBusGProxy *proxy, GError **error)
00255
00256 {
00257 return dbus_g_proxy_call (proxy, "Play", error, G_TYPE_INVALID, G_TYPE_INVALID);
00258 }
00259
00260 typedef void (*org_atheme_audacious_play_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
00261
00262 static void
00263 org_atheme_audacious_play_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_play_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_play_async (DBusGProxy *proxy, org_atheme_audacious_play_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, "Play", org_atheme_audacious_play_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
00285 }
00286 static
00287 #ifdef G_HAVE_INLINE
00288 inline
00289 #endif
00290 gboolean
00291 org_atheme_audacious_pause (DBusGProxy *proxy, GError **error)
00292
00293 {
00294 return dbus_g_proxy_call (proxy, "Pause", error, G_TYPE_INVALID, G_TYPE_INVALID);
00295 }
00296
00297 typedef void (*org_atheme_audacious_pause_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
00298
00299 static void
00300 org_atheme_audacious_pause_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
00301 {
00302 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
00303 GError *error = NULL;
00304 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
00305 (*(org_atheme_audacious_pause_reply)data->cb) (proxy, error, data->userdata);
00306 return;
00307 }
00308
00309 static
00310 #ifdef G_HAVE_INLINE
00311 inline
00312 #endif
00313 DBusGProxyCall*
00314 org_atheme_audacious_pause_async (DBusGProxy *proxy, org_atheme_audacious_pause_reply callback, gpointer userdata)
00315
00316 {
00317 DBusGAsyncData *stuff;
00318 stuff = g_slice_new (DBusGAsyncData);
00319 stuff->cb = G_CALLBACK (callback);
00320 stuff->userdata = userdata;
00321 return dbus_g_proxy_begin_call (proxy, "Pause", org_atheme_audacious_pause_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
00322 }
00323 static
00324 #ifdef G_HAVE_INLINE
00325 inline
00326 #endif
00327 gboolean
00328 org_atheme_audacious_stop (DBusGProxy *proxy, GError **error)
00329
00330 {
00331 return dbus_g_proxy_call (proxy, "Stop", error, G_TYPE_INVALID, G_TYPE_INVALID);
00332 }
00333
00334 typedef void (*org_atheme_audacious_stop_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
00335
00336 static void
00337 org_atheme_audacious_stop_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
00338 {
00339 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
00340 GError *error = NULL;
00341 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
00342 (*(org_atheme_audacious_stop_reply)data->cb) (proxy, error, data->userdata);
00343 return;
00344 }
00345
00346 static
00347 #ifdef G_HAVE_INLINE
00348 inline
00349 #endif
00350 DBusGProxyCall*
00351 org_atheme_audacious_stop_async (DBusGProxy *proxy, org_atheme_audacious_stop_reply callback, gpointer userdata)
00352
00353 {
00354 DBusGAsyncData *stuff;
00355 stuff = g_slice_new (DBusGAsyncData);
00356 stuff->cb = G_CALLBACK (callback);
00357 stuff->userdata = userdata;
00358 return dbus_g_proxy_begin_call (proxy, "Stop", org_atheme_audacious_stop_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
00359 }
00360 static
00361 #ifdef G_HAVE_INLINE
00362 inline
00363 #endif
00364 gboolean
00365 org_atheme_audacious_playing (DBusGProxy *proxy, gboolean* OUT_is_playing, GError **error)
00366
00367 {
00368 return dbus_g_proxy_call (proxy, "Playing", error, G_TYPE_INVALID, G_TYPE_BOOLEAN, OUT_is_playing, G_TYPE_INVALID);
00369 }
00370
00371 typedef void (*org_atheme_audacious_playing_reply) (DBusGProxy *proxy, gboolean OUT_is_playing, GError *error, gpointer userdata);
00372
00373 static void
00374 org_atheme_audacious_playing_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
00375 {
00376 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
00377 GError *error = NULL;
00378 gboolean OUT_is_playing;
00379 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_BOOLEAN, &OUT_is_playing, G_TYPE_INVALID);
00380 (*(org_atheme_audacious_playing_reply)data->cb) (proxy, OUT_is_playing, error, data->userdata);
00381 return;
00382 }
00383
00384 static
00385 #ifdef G_HAVE_INLINE
00386 inline
00387 #endif
00388 DBusGProxyCall*
00389 org_atheme_audacious_playing_async (DBusGProxy *proxy, org_atheme_audacious_playing_reply callback, gpointer userdata)
00390
00391 {
00392 DBusGAsyncData *stuff;
00393 stuff = g_slice_new (DBusGAsyncData);
00394 stuff->cb = G_CALLBACK (callback);
00395 stuff->userdata = userdata;
00396 return dbus_g_proxy_begin_call (proxy, "Playing", org_atheme_audacious_playing_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
00397 }
00398 static
00399 #ifdef G_HAVE_INLINE
00400 inline
00401 #endif
00402 gboolean
00403 org_atheme_audacious_paused (DBusGProxy *proxy, gboolean* OUT_is_paused, GError **error)
00404
00405 {
00406 return dbus_g_proxy_call (proxy, "Paused", error, G_TYPE_INVALID, G_TYPE_BOOLEAN, OUT_is_paused, G_TYPE_INVALID);
00407 }
00408
00409 typedef void (*org_atheme_audacious_paused_reply) (DBusGProxy *proxy, gboolean OUT_is_paused, GError *error, gpointer userdata);
00410
00411 static void
00412 org_atheme_audacious_paused_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
00413 {
00414 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
00415 GError *error = NULL;
00416 gboolean OUT_is_paused;
00417 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_BOOLEAN, &OUT_is_paused, G_TYPE_INVALID);
00418 (*(org_atheme_audacious_paused_reply)data->cb) (proxy, OUT_is_paused, error, data->userdata);
00419 return;
00420 }
00421
00422 static
00423 #ifdef G_HAVE_INLINE
00424 inline
00425 #endif
00426 DBusGProxyCall*
00427 org_atheme_audacious_paused_async (DBusGProxy *proxy, org_atheme_audacious_paused_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, "Paused", org_atheme_audacious_paused_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_stopped (DBusGProxy *proxy, gboolean* OUT_is_stopped, GError **error)
00442
00443 {
00444 return dbus_g_proxy_call (proxy, "Stopped", error, G_TYPE_INVALID, G_TYPE_BOOLEAN, OUT_is_stopped, G_TYPE_INVALID);
00445 }
00446
00447 typedef void (*org_atheme_audacious_stopped_reply) (DBusGProxy *proxy, gboolean OUT_is_stopped, GError *error, gpointer userdata);
00448
00449 static void
00450 org_atheme_audacious_stopped_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
00451 {
00452 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
00453 GError *error = NULL;
00454 gboolean OUT_is_stopped;
00455 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_BOOLEAN, &OUT_is_stopped, G_TYPE_INVALID);
00456 (*(org_atheme_audacious_stopped_reply)data->cb) (proxy, OUT_is_stopped, error, data->userdata);
00457 return;
00458 }
00459
00460 static
00461 #ifdef G_HAVE_INLINE
00462 inline
00463 #endif
00464 DBusGProxyCall*
00465 org_atheme_audacious_stopped_async (DBusGProxy *proxy, org_atheme_audacious_stopped_reply callback, gpointer userdata)
00466
00467 {
00468 DBusGAsyncData *stuff;
00469 stuff = g_slice_new (DBusGAsyncData);
00470 stuff->cb = G_CALLBACK (callback);
00471 stuff->userdata = userdata;
00472 return dbus_g_proxy_begin_call (proxy, "Stopped", org_atheme_audacious_stopped_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
00473 }
00474 static
00475 #ifdef G_HAVE_INLINE
00476 inline
00477 #endif
00478 gboolean
00479 org_atheme_audacious_status (DBusGProxy *proxy, char ** OUT_status, GError **error)
00480
00481 {
00482 return dbus_g_proxy_call (proxy, "Status", error, G_TYPE_INVALID, G_TYPE_STRING, OUT_status, G_TYPE_INVALID);
00483 }
00484
00485 typedef void (*org_atheme_audacious_status_reply) (DBusGProxy *proxy, char * OUT_status, GError *error, gpointer userdata);
00486
00487 static void
00488 org_atheme_audacious_status_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
00489 {
00490 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
00491 GError *error = NULL;
00492 char * OUT_status;
00493 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_STRING, &OUT_status, G_TYPE_INVALID);
00494 (*(org_atheme_audacious_status_reply)data->cb) (proxy, OUT_status, error, data->userdata);
00495 return;
00496 }
00497
00498 static
00499 #ifdef G_HAVE_INLINE
00500 inline
00501 #endif
00502 DBusGProxyCall*
00503 org_atheme_audacious_status_async (DBusGProxy *proxy, org_atheme_audacious_status_reply callback, gpointer userdata)
00504
00505 {
00506 DBusGAsyncData *stuff;
00507 stuff = g_slice_new (DBusGAsyncData);
00508 stuff->cb = G_CALLBACK (callback);
00509 stuff->userdata = userdata;
00510 return dbus_g_proxy_begin_call (proxy, "Status", org_atheme_audacious_status_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
00511 }
00512 static
00513 #ifdef G_HAVE_INLINE
00514 inline
00515 #endif
00516 gboolean
00517 org_atheme_audacious_info (DBusGProxy *proxy, gint* OUT_rate, gint* OUT_freq, gint* OUT_nch, GError **error)
00518
00519 {
00520 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);
00521 }
00522
00523 typedef void (*org_atheme_audacious_info_reply) (DBusGProxy *proxy, gint OUT_rate, gint OUT_freq, gint OUT_nch, GError *error, gpointer userdata);
00524
00525 static void
00526 org_atheme_audacious_info_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
00527 {
00528 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
00529 GError *error = NULL;
00530 gint OUT_rate;
00531 gint OUT_freq;
00532 gint OUT_nch;
00533 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);
00534 (*(org_atheme_audacious_info_reply)data->cb) (proxy, OUT_rate, OUT_freq, OUT_nch, error, data->userdata);
00535 return;
00536 }
00537
00538 static
00539 #ifdef G_HAVE_INLINE
00540 inline
00541 #endif
00542 DBusGProxyCall*
00543 org_atheme_audacious_info_async (DBusGProxy *proxy, org_atheme_audacious_info_reply callback, gpointer userdata)
00544
00545 {
00546 DBusGAsyncData *stuff;
00547 stuff = g_slice_new (DBusGAsyncData);
00548 stuff->cb = G_CALLBACK (callback);
00549 stuff->userdata = userdata;
00550 return dbus_g_proxy_begin_call (proxy, "Info", org_atheme_audacious_info_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
00551 }
00552 static
00553 #ifdef G_HAVE_INLINE
00554 inline
00555 #endif
00556 gboolean
00557 org_atheme_audacious_time (DBusGProxy *proxy, guint* OUT_time, GError **error)
00558
00559 {
00560 return dbus_g_proxy_call (proxy, "Time", error, G_TYPE_INVALID, G_TYPE_UINT, OUT_time, G_TYPE_INVALID);
00561 }
00562
00563 typedef void (*org_atheme_audacious_time_reply) (DBusGProxy *proxy, guint OUT_time, GError *error, gpointer userdata);
00564
00565 static void
00566 org_atheme_audacious_time_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
00567 {
00568 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
00569 GError *error = NULL;
00570 guint OUT_time;
00571 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_UINT, &OUT_time, G_TYPE_INVALID);
00572 (*(org_atheme_audacious_time_reply)data->cb) (proxy, OUT_time, error, data->userdata);
00573 return;
00574 }
00575
00576 static
00577 #ifdef G_HAVE_INLINE
00578 inline
00579 #endif
00580 DBusGProxyCall*
00581 org_atheme_audacious_time_async (DBusGProxy *proxy, org_atheme_audacious_time_reply callback, gpointer userdata)
00582
00583 {
00584 DBusGAsyncData *stuff;
00585 stuff = g_slice_new (DBusGAsyncData);
00586 stuff->cb = G_CALLBACK (callback);
00587 stuff->userdata = userdata;
00588 return dbus_g_proxy_begin_call (proxy, "Time", org_atheme_audacious_time_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
00589 }
00590 static
00591 #ifdef G_HAVE_INLINE
00592 inline
00593 #endif
00594 gboolean
00595 org_atheme_audacious_seek (DBusGProxy *proxy, const guint IN_pos, GError **error)
00596
00597 {
00598 return dbus_g_proxy_call (proxy, "Seek", error, G_TYPE_UINT, IN_pos, G_TYPE_INVALID, G_TYPE_INVALID);
00599 }
00600
00601 typedef void (*org_atheme_audacious_seek_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
00602
00603 static void
00604 org_atheme_audacious_seek_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
00605 {
00606 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
00607 GError *error = NULL;
00608 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
00609 (*(org_atheme_audacious_seek_reply)data->cb) (proxy, error, data->userdata);
00610 return;
00611 }
00612
00613 static
00614 #ifdef G_HAVE_INLINE
00615 inline
00616 #endif
00617 DBusGProxyCall*
00618 org_atheme_audacious_seek_async (DBusGProxy *proxy, const guint IN_pos, org_atheme_audacious_seek_reply callback, gpointer userdata)
00619
00620 {
00621 DBusGAsyncData *stuff;
00622 stuff = g_slice_new (DBusGAsyncData);
00623 stuff->cb = G_CALLBACK (callback);
00624 stuff->userdata = userdata;
00625 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);
00626 }
00627 static
00628 #ifdef G_HAVE_INLINE
00629 inline
00630 #endif
00631 gboolean
00632 org_atheme_audacious_volume (DBusGProxy *proxy, gint* OUT_vl, gint* OUT_vr, GError **error)
00633
00634 {
00635 return dbus_g_proxy_call (proxy, "Volume", error, G_TYPE_INVALID, G_TYPE_INT, OUT_vl, G_TYPE_INT, OUT_vr, G_TYPE_INVALID);
00636 }
00637
00638 typedef void (*org_atheme_audacious_volume_reply) (DBusGProxy *proxy, gint OUT_vl, gint OUT_vr, GError *error, gpointer userdata);
00639
00640 static void
00641 org_atheme_audacious_volume_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
00642 {
00643 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
00644 GError *error = NULL;
00645 gint OUT_vl;
00646 gint OUT_vr;
00647 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INT, &OUT_vl, G_TYPE_INT, &OUT_vr, G_TYPE_INVALID);
00648 (*(org_atheme_audacious_volume_reply)data->cb) (proxy, OUT_vl, OUT_vr, error, data->userdata);
00649 return;
00650 }
00651
00652 static
00653 #ifdef G_HAVE_INLINE
00654 inline
00655 #endif
00656 DBusGProxyCall*
00657 org_atheme_audacious_volume_async (DBusGProxy *proxy, org_atheme_audacious_volume_reply callback, gpointer userdata)
00658
00659 {
00660 DBusGAsyncData *stuff;
00661 stuff = g_slice_new (DBusGAsyncData);
00662 stuff->cb = G_CALLBACK (callback);
00663 stuff->userdata = userdata;
00664 return dbus_g_proxy_begin_call (proxy, "Volume", org_atheme_audacious_volume_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
00665 }
00666 static
00667 #ifdef G_HAVE_INLINE
00668 inline
00669 #endif
00670 gboolean
00671 org_atheme_audacious_set_volume (DBusGProxy *proxy, const gint IN_vl, const gint IN_vr, GError **error)
00672
00673 {
00674 return dbus_g_proxy_call (proxy, "SetVolume", error, G_TYPE_INT, IN_vl, G_TYPE_INT, IN_vr, G_TYPE_INVALID, G_TYPE_INVALID);
00675 }
00676
00677 typedef void (*org_atheme_audacious_set_volume_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
00678
00679 static void
00680 org_atheme_audacious_set_volume_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
00681 {
00682 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
00683 GError *error = NULL;
00684 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
00685 (*(org_atheme_audacious_set_volume_reply)data->cb) (proxy, error, data->userdata);
00686 return;
00687 }
00688
00689 static
00690 #ifdef G_HAVE_INLINE
00691 inline
00692 #endif
00693 DBusGProxyCall*
00694 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)
00695
00696 {
00697 DBusGAsyncData *stuff;
00698 stuff = g_slice_new (DBusGAsyncData);
00699 stuff->cb = G_CALLBACK (callback);
00700 stuff->userdata = userdata;
00701 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);
00702 }
00703 static
00704 #ifdef G_HAVE_INLINE
00705 inline
00706 #endif
00707 gboolean
00708 org_atheme_audacious_balance (DBusGProxy *proxy, gint* OUT_balance, GError **error)
00709
00710 {
00711 return dbus_g_proxy_call (proxy, "Balance", error, G_TYPE_INVALID, G_TYPE_INT, OUT_balance, G_TYPE_INVALID);
00712 }
00713
00714 typedef void (*org_atheme_audacious_balance_reply) (DBusGProxy *proxy, gint OUT_balance, GError *error, gpointer userdata);
00715
00716 static void
00717 org_atheme_audacious_balance_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
00718 {
00719 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
00720 GError *error = NULL;
00721 gint OUT_balance;
00722 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INT, &OUT_balance, G_TYPE_INVALID);
00723 (*(org_atheme_audacious_balance_reply)data->cb) (proxy, OUT_balance, error, data->userdata);
00724 return;
00725 }
00726
00727 static
00728 #ifdef G_HAVE_INLINE
00729 inline
00730 #endif
00731 DBusGProxyCall*
00732 org_atheme_audacious_balance_async (DBusGProxy *proxy, org_atheme_audacious_balance_reply callback, gpointer userdata)
00733
00734 {
00735 DBusGAsyncData *stuff;
00736 stuff = g_slice_new (DBusGAsyncData);
00737 stuff->cb = G_CALLBACK (callback);
00738 stuff->userdata = userdata;
00739 return dbus_g_proxy_begin_call (proxy, "Balance", org_atheme_audacious_balance_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
00740 }
00741 static
00742 #ifdef G_HAVE_INLINE
00743 inline
00744 #endif
00745 gboolean
00746 org_atheme_audacious_position (DBusGProxy *proxy, guint* OUT_pos, GError **error)
00747
00748 {
00749 return dbus_g_proxy_call (proxy, "Position", error, G_TYPE_INVALID, G_TYPE_UINT, OUT_pos, G_TYPE_INVALID);
00750 }
00751
00752 typedef void (*org_atheme_audacious_position_reply) (DBusGProxy *proxy, guint OUT_pos, GError *error, gpointer userdata);
00753
00754 static void
00755 org_atheme_audacious_position_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
00756 {
00757 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
00758 GError *error = NULL;
00759 guint OUT_pos;
00760 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_UINT, &OUT_pos, G_TYPE_INVALID);
00761 (*(org_atheme_audacious_position_reply)data->cb) (proxy, OUT_pos, error, data->userdata);
00762 return;
00763 }
00764
00765 static
00766 #ifdef G_HAVE_INLINE
00767 inline
00768 #endif
00769 DBusGProxyCall*
00770 org_atheme_audacious_position_async (DBusGProxy *proxy, org_atheme_audacious_position_reply callback, gpointer userdata)
00771
00772 {
00773 DBusGAsyncData *stuff;
00774 stuff = g_slice_new (DBusGAsyncData);
00775 stuff->cb = G_CALLBACK (callback);
00776 stuff->userdata = userdata;
00777 return dbus_g_proxy_begin_call (proxy, "Position", org_atheme_audacious_position_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
00778 }
00779 static
00780 #ifdef G_HAVE_INLINE
00781 inline
00782 #endif
00783 gboolean
00784 org_atheme_audacious_advance (DBusGProxy *proxy, GError **error)
00785
00786 {
00787 return dbus_g_proxy_call (proxy, "Advance", error, G_TYPE_INVALID, G_TYPE_INVALID);
00788 }
00789
00790 typedef void (*org_atheme_audacious_advance_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
00791
00792 static void
00793 org_atheme_audacious_advance_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
00794 {
00795 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
00796 GError *error = NULL;
00797 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
00798 (*(org_atheme_audacious_advance_reply)data->cb) (proxy, error, data->userdata);
00799 return;
00800 }
00801
00802 static
00803 #ifdef G_HAVE_INLINE
00804 inline
00805 #endif
00806 DBusGProxyCall*
00807 org_atheme_audacious_advance_async (DBusGProxy *proxy, org_atheme_audacious_advance_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, "Advance", org_atheme_audacious_advance_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_reverse (DBusGProxy *proxy, GError **error)
00822
00823 {
00824 return dbus_g_proxy_call (proxy, "Reverse", error, G_TYPE_INVALID, G_TYPE_INVALID);
00825 }
00826
00827 typedef void (*org_atheme_audacious_reverse_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
00828
00829 static void
00830 org_atheme_audacious_reverse_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_reverse_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_reverse_async (DBusGProxy *proxy, org_atheme_audacious_reverse_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, "Reverse", org_atheme_audacious_reverse_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
00852 }
00853 static
00854 #ifdef G_HAVE_INLINE
00855 inline
00856 #endif
00857 gboolean
00858 org_atheme_audacious_length (DBusGProxy *proxy, gint* OUT_length, GError **error)
00859
00860 {
00861 return dbus_g_proxy_call (proxy, "Length", error, G_TYPE_INVALID, G_TYPE_INT, OUT_length, G_TYPE_INVALID);
00862 }
00863
00864 typedef void (*org_atheme_audacious_length_reply) (DBusGProxy *proxy, gint OUT_length, GError *error, gpointer userdata);
00865
00866 static void
00867 org_atheme_audacious_length_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
00868 {
00869 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
00870 GError *error = NULL;
00871 gint OUT_length;
00872 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INT, &OUT_length, G_TYPE_INVALID);
00873 (*(org_atheme_audacious_length_reply)data->cb) (proxy, OUT_length, error, data->userdata);
00874 return;
00875 }
00876
00877 static
00878 #ifdef G_HAVE_INLINE
00879 inline
00880 #endif
00881 DBusGProxyCall*
00882 org_atheme_audacious_length_async (DBusGProxy *proxy, org_atheme_audacious_length_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, "Length", org_atheme_audacious_length_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_song_title (DBusGProxy *proxy, const guint IN_pos, char ** OUT_title, GError **error)
00897
00898 {
00899 return dbus_g_proxy_call (proxy, "SongTitle", error, G_TYPE_UINT, IN_pos, G_TYPE_INVALID, G_TYPE_STRING, OUT_title, G_TYPE_INVALID);
00900 }
00901
00902 typedef void (*org_atheme_audacious_song_title_reply) (DBusGProxy *proxy, char * OUT_title, GError *error, gpointer userdata);
00903
00904 static void
00905 org_atheme_audacious_song_title_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
00906 {
00907 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
00908 GError *error = NULL;
00909 char * OUT_title;
00910 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_STRING, &OUT_title, G_TYPE_INVALID);
00911 (*(org_atheme_audacious_song_title_reply)data->cb) (proxy, OUT_title, error, data->userdata);
00912 return;
00913 }
00914
00915 static
00916 #ifdef G_HAVE_INLINE
00917 inline
00918 #endif
00919 DBusGProxyCall*
00920 org_atheme_audacious_song_title_async (DBusGProxy *proxy, const guint IN_pos, org_atheme_audacious_song_title_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, "SongTitle", org_atheme_audacious_song_title_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_UINT, IN_pos, G_TYPE_INVALID);
00928 }
00929 static
00930 #ifdef G_HAVE_INLINE
00931 inline
00932 #endif
00933 gboolean
00934 org_atheme_audacious_song_filename (DBusGProxy *proxy, const guint IN_pos, char ** OUT_filename, GError **error)
00935
00936 {
00937 return dbus_g_proxy_call (proxy, "SongFilename", error, G_TYPE_UINT, IN_pos, G_TYPE_INVALID, G_TYPE_STRING, OUT_filename, G_TYPE_INVALID);
00938 }
00939
00940 typedef void (*org_atheme_audacious_song_filename_reply) (DBusGProxy *proxy, char * OUT_filename, GError *error, gpointer userdata);
00941
00942 static void
00943 org_atheme_audacious_song_filename_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
00944 {
00945 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
00946 GError *error = NULL;
00947 char * OUT_filename;
00948 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_STRING, &OUT_filename, G_TYPE_INVALID);
00949 (*(org_atheme_audacious_song_filename_reply)data->cb) (proxy, OUT_filename, error, data->userdata);
00950 return;
00951 }
00952
00953 static
00954 #ifdef G_HAVE_INLINE
00955 inline
00956 #endif
00957 DBusGProxyCall*
00958 org_atheme_audacious_song_filename_async (DBusGProxy *proxy, const guint IN_pos, org_atheme_audacious_song_filename_reply callback, gpointer userdata)
00959
00960 {
00961 DBusGAsyncData *stuff;
00962 stuff = g_slice_new (DBusGAsyncData);
00963 stuff->cb = G_CALLBACK (callback);
00964 stuff->userdata = userdata;
00965 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);
00966 }
00967 static
00968 #ifdef G_HAVE_INLINE
00969 inline
00970 #endif
00971 gboolean
00972 org_atheme_audacious_song_length (DBusGProxy *proxy, const guint IN_pos, gint* OUT_length, GError **error)
00973
00974 {
00975 return dbus_g_proxy_call (proxy, "SongLength", error, G_TYPE_UINT, IN_pos, G_TYPE_INVALID, G_TYPE_INT, OUT_length, G_TYPE_INVALID);
00976 }
00977
00978 typedef void (*org_atheme_audacious_song_length_reply) (DBusGProxy *proxy, gint OUT_length, GError *error, gpointer userdata);
00979
00980 static void
00981 org_atheme_audacious_song_length_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
00982 {
00983 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
00984 GError *error = NULL;
00985 gint OUT_length;
00986 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INT, &OUT_length, G_TYPE_INVALID);
00987 (*(org_atheme_audacious_song_length_reply)data->cb) (proxy, OUT_length, error, data->userdata);
00988 return;
00989 }
00990
00991 static
00992 #ifdef G_HAVE_INLINE
00993 inline
00994 #endif
00995 DBusGProxyCall*
00996 org_atheme_audacious_song_length_async (DBusGProxy *proxy, const guint IN_pos, org_atheme_audacious_song_length_reply callback, gpointer userdata)
00997
00998 {
00999 DBusGAsyncData *stuff;
01000 stuff = g_slice_new (DBusGAsyncData);
01001 stuff->cb = G_CALLBACK (callback);
01002 stuff->userdata = userdata;
01003 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);
01004 }
01005 static
01006 #ifdef G_HAVE_INLINE
01007 inline
01008 #endif
01009 gboolean
01010 org_atheme_audacious_song_frames (DBusGProxy *proxy, const guint IN_pos, gint* OUT_length, GError **error)
01011
01012 {
01013 return dbus_g_proxy_call (proxy, "SongFrames", error, G_TYPE_UINT, IN_pos, G_TYPE_INVALID, G_TYPE_INT, OUT_length, G_TYPE_INVALID);
01014 }
01015
01016 typedef void (*org_atheme_audacious_song_frames_reply) (DBusGProxy *proxy, gint OUT_length, GError *error, gpointer userdata);
01017
01018 static void
01019 org_atheme_audacious_song_frames_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01020 {
01021 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01022 GError *error = NULL;
01023 gint OUT_length;
01024 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INT, &OUT_length, G_TYPE_INVALID);
01025 (*(org_atheme_audacious_song_frames_reply)data->cb) (proxy, OUT_length, error, data->userdata);
01026 return;
01027 }
01028
01029 static
01030 #ifdef G_HAVE_INLINE
01031 inline
01032 #endif
01033 DBusGProxyCall*
01034 org_atheme_audacious_song_frames_async (DBusGProxy *proxy, const guint IN_pos, org_atheme_audacious_song_frames_reply callback, gpointer userdata)
01035
01036 {
01037 DBusGAsyncData *stuff;
01038 stuff = g_slice_new (DBusGAsyncData);
01039 stuff->cb = G_CALLBACK (callback);
01040 stuff->userdata = userdata;
01041 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);
01042 }
01043 static
01044 #ifdef G_HAVE_INLINE
01045 inline
01046 #endif
01047 gboolean
01048 org_atheme_audacious_song_tuple (DBusGProxy *proxy, const guint IN_pos, const char * IN_tuple, GValue* OUT_value, GError **error)
01049
01050 {
01051 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);
01052 }
01053
01054 typedef void (*org_atheme_audacious_song_tuple_reply) (DBusGProxy *proxy, GValue OUT_value, GError *error, gpointer userdata);
01055
01056 static void
01057 org_atheme_audacious_song_tuple_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01058 {
01059 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01060 GError *error = NULL;
01061 GValue OUT_value = { 0, };
01062 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_VALUE, &OUT_value, G_TYPE_INVALID);
01063 (*(org_atheme_audacious_song_tuple_reply)data->cb) (proxy, OUT_value, error, data->userdata);
01064 return;
01065 }
01066
01067 static
01068 #ifdef G_HAVE_INLINE
01069 inline
01070 #endif
01071 DBusGProxyCall*
01072 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)
01073
01074 {
01075 DBusGAsyncData *stuff;
01076 stuff = g_slice_new (DBusGAsyncData);
01077 stuff->cb = G_CALLBACK (callback);
01078 stuff->userdata = userdata;
01079 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);
01080 }
01081 static
01082 #ifdef G_HAVE_INLINE
01083 inline
01084 #endif
01085 gboolean
01086 org_atheme_audacious_jump (DBusGProxy *proxy, const guint IN_pos, GError **error)
01087
01088 {
01089 return dbus_g_proxy_call (proxy, "Jump", error, G_TYPE_UINT, IN_pos, G_TYPE_INVALID, G_TYPE_INVALID);
01090 }
01091
01092 typedef void (*org_atheme_audacious_jump_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
01093
01094 static void
01095 org_atheme_audacious_jump_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01096 {
01097 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01098 GError *error = NULL;
01099 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
01100 (*(org_atheme_audacious_jump_reply)data->cb) (proxy, error, data->userdata);
01101 return;
01102 }
01103
01104 static
01105 #ifdef G_HAVE_INLINE
01106 inline
01107 #endif
01108 DBusGProxyCall*
01109 org_atheme_audacious_jump_async (DBusGProxy *proxy, const guint IN_pos, org_atheme_audacious_jump_reply callback, gpointer userdata)
01110
01111 {
01112 DBusGAsyncData *stuff;
01113 stuff = g_slice_new (DBusGAsyncData);
01114 stuff->cb = G_CALLBACK (callback);
01115 stuff->userdata = userdata;
01116 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);
01117 }
01118 static
01119 #ifdef G_HAVE_INLINE
01120 inline
01121 #endif
01122 gboolean
01123 org_atheme_audacious_add (DBusGProxy *proxy, const char * IN_file, GError **error)
01124
01125 {
01126 return dbus_g_proxy_call (proxy, "Add", error, G_TYPE_STRING, IN_file, G_TYPE_INVALID, G_TYPE_INVALID);
01127 }
01128
01129 typedef void (*org_atheme_audacious_add_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
01130
01131 static void
01132 org_atheme_audacious_add_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01133 {
01134 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01135 GError *error = NULL;
01136 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
01137 (*(org_atheme_audacious_add_reply)data->cb) (proxy, error, data->userdata);
01138 return;
01139 }
01140
01141 static
01142 #ifdef G_HAVE_INLINE
01143 inline
01144 #endif
01145 DBusGProxyCall*
01146 org_atheme_audacious_add_async (DBusGProxy *proxy, const char * IN_file, org_atheme_audacious_add_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, "Add", org_atheme_audacious_add_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_STRING, IN_file, G_TYPE_INVALID);
01154 }
01155 static
01156 #ifdef G_HAVE_INLINE
01157 inline
01158 #endif
01159 gboolean
01160 org_atheme_audacious_add_url (DBusGProxy *proxy, const char * IN_url, GError **error)
01161
01162 {
01163 return dbus_g_proxy_call (proxy, "AddUrl", error, G_TYPE_STRING, IN_url, G_TYPE_INVALID, G_TYPE_INVALID);
01164 }
01165
01166 typedef void (*org_atheme_audacious_add_url_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
01167
01168 static void
01169 org_atheme_audacious_add_url_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01170 {
01171 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01172 GError *error = NULL;
01173 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
01174 (*(org_atheme_audacious_add_url_reply)data->cb) (proxy, error, data->userdata);
01175 return;
01176 }
01177
01178 static
01179 #ifdef G_HAVE_INLINE
01180 inline
01181 #endif
01182 DBusGProxyCall*
01183 org_atheme_audacious_add_url_async (DBusGProxy *proxy, const char * IN_url, org_atheme_audacious_add_url_reply callback, gpointer userdata)
01184
01185 {
01186 DBusGAsyncData *stuff;
01187 stuff = g_slice_new (DBusGAsyncData);
01188 stuff->cb = G_CALLBACK (callback);
01189 stuff->userdata = userdata;
01190 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);
01191 }
01192 static
01193 #ifdef G_HAVE_INLINE
01194 inline
01195 #endif
01196 gboolean
01197 org_atheme_audacious_add_list (DBusGProxy *proxy, const char ** IN_filenames, GError **error)
01198
01199 {
01200 return dbus_g_proxy_call (proxy, "AddList", error, G_TYPE_STRV, IN_filenames, G_TYPE_INVALID, G_TYPE_INVALID);
01201 }
01202
01203 typedef void (*org_atheme_audacious_add_list_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
01204
01205 static void
01206 org_atheme_audacious_add_list_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01207 {
01208 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01209 GError *error = NULL;
01210 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
01211 (*(org_atheme_audacious_add_list_reply)data->cb) (proxy, error, data->userdata);
01212 return;
01213 }
01214
01215 static
01216 #ifdef G_HAVE_INLINE
01217 inline
01218 #endif
01219 DBusGProxyCall*
01220 org_atheme_audacious_add_list_async (DBusGProxy *proxy, const char ** IN_filenames, org_atheme_audacious_add_list_reply callback, gpointer userdata)
01221
01222 {
01223 DBusGAsyncData *stuff;
01224 stuff = g_slice_new (DBusGAsyncData);
01225 stuff->cb = G_CALLBACK (callback);
01226 stuff->userdata = userdata;
01227 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);
01228 }
01229 static
01230 #ifdef G_HAVE_INLINE
01231 inline
01232 #endif
01233 gboolean
01234 org_atheme_audacious_open_list (DBusGProxy *proxy, const char ** IN_filenames, GError **error)
01235
01236 {
01237 return dbus_g_proxy_call (proxy, "OpenList", error, G_TYPE_STRV, IN_filenames, G_TYPE_INVALID, G_TYPE_INVALID);
01238 }
01239
01240 typedef void (*org_atheme_audacious_open_list_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
01241
01242 static void
01243 org_atheme_audacious_open_list_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01244 {
01245 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01246 GError *error = NULL;
01247 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
01248 (*(org_atheme_audacious_open_list_reply)data->cb) (proxy, error, data->userdata);
01249 return;
01250 }
01251
01252 static
01253 #ifdef G_HAVE_INLINE
01254 inline
01255 #endif
01256 DBusGProxyCall*
01257 org_atheme_audacious_open_list_async (DBusGProxy *proxy, const char ** IN_filenames, org_atheme_audacious_open_list_reply callback, gpointer userdata)
01258
01259 {
01260 DBusGAsyncData *stuff;
01261 stuff = g_slice_new (DBusGAsyncData);
01262 stuff->cb = G_CALLBACK (callback);
01263 stuff->userdata = userdata;
01264 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);
01265 }
01266 static
01267 #ifdef G_HAVE_INLINE
01268 inline
01269 #endif
01270 gboolean
01271 org_atheme_audacious_open_list_to_temp (DBusGProxy *proxy, const char ** IN_filenames, GError **error)
01272
01273 {
01274 return dbus_g_proxy_call (proxy, "OpenListToTemp", error, G_TYPE_STRV, IN_filenames, G_TYPE_INVALID, G_TYPE_INVALID);
01275 }
01276
01277 typedef void (*org_atheme_audacious_open_list_to_temp_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
01278
01279 static void
01280 org_atheme_audacious_open_list_to_temp_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01281 {
01282 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01283 GError *error = NULL;
01284 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
01285 (*(org_atheme_audacious_open_list_to_temp_reply)data->cb) (proxy, error, data->userdata);
01286 return;
01287 }
01288
01289 static
01290 #ifdef G_HAVE_INLINE
01291 inline
01292 #endif
01293 DBusGProxyCall*
01294 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)
01295
01296 {
01297 DBusGAsyncData *stuff;
01298 stuff = g_slice_new (DBusGAsyncData);
01299 stuff->cb = G_CALLBACK (callback);
01300 stuff->userdata = userdata;
01301 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);
01302 }
01303 static
01304 #ifdef G_HAVE_INLINE
01305 inline
01306 #endif
01307 gboolean
01308 org_atheme_audacious_delete (DBusGProxy *proxy, const guint IN_pos, GError **error)
01309
01310 {
01311 return dbus_g_proxy_call (proxy, "Delete", error, G_TYPE_UINT, IN_pos, G_TYPE_INVALID, G_TYPE_INVALID);
01312 }
01313
01314 typedef void (*org_atheme_audacious_delete_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
01315
01316 static void
01317 org_atheme_audacious_delete_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01318 {
01319 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01320 GError *error = NULL;
01321 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
01322 (*(org_atheme_audacious_delete_reply)data->cb) (proxy, error, data->userdata);
01323 return;
01324 }
01325
01326 static
01327 #ifdef G_HAVE_INLINE
01328 inline
01329 #endif
01330 DBusGProxyCall*
01331 org_atheme_audacious_delete_async (DBusGProxy *proxy, const guint IN_pos, org_atheme_audacious_delete_reply callback, gpointer userdata)
01332
01333 {
01334 DBusGAsyncData *stuff;
01335 stuff = g_slice_new (DBusGAsyncData);
01336 stuff->cb = G_CALLBACK (callback);
01337 stuff->userdata = userdata;
01338 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);
01339 }
01340 static
01341 #ifdef G_HAVE_INLINE
01342 inline
01343 #endif
01344 gboolean
01345 org_atheme_audacious_clear (DBusGProxy *proxy, GError **error)
01346
01347 {
01348 return dbus_g_proxy_call (proxy, "Clear", error, G_TYPE_INVALID, G_TYPE_INVALID);
01349 }
01350
01351 typedef void (*org_atheme_audacious_clear_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
01352
01353 static void
01354 org_atheme_audacious_clear_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01355 {
01356 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01357 GError *error = NULL;
01358 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
01359 (*(org_atheme_audacious_clear_reply)data->cb) (proxy, error, data->userdata);
01360 return;
01361 }
01362
01363 static
01364 #ifdef G_HAVE_INLINE
01365 inline
01366 #endif
01367 DBusGProxyCall*
01368 org_atheme_audacious_clear_async (DBusGProxy *proxy, org_atheme_audacious_clear_reply callback, gpointer userdata)
01369
01370 {
01371 DBusGAsyncData *stuff;
01372 stuff = g_slice_new (DBusGAsyncData);
01373 stuff->cb = G_CALLBACK (callback);
01374 stuff->userdata = userdata;
01375 return dbus_g_proxy_begin_call (proxy, "Clear", org_atheme_audacious_clear_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
01376 }
01377 static
01378 #ifdef G_HAVE_INLINE
01379 inline
01380 #endif
01381 gboolean
01382 org_atheme_audacious_auto_advance (DBusGProxy *proxy, gboolean* OUT_is_advance, GError **error)
01383
01384 {
01385 return dbus_g_proxy_call (proxy, "AutoAdvance", error, G_TYPE_INVALID, G_TYPE_BOOLEAN, OUT_is_advance, G_TYPE_INVALID);
01386 }
01387
01388 typedef void (*org_atheme_audacious_auto_advance_reply) (DBusGProxy *proxy, gboolean OUT_is_advance, GError *error, gpointer userdata);
01389
01390 static void
01391 org_atheme_audacious_auto_advance_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01392 {
01393 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01394 GError *error = NULL;
01395 gboolean OUT_is_advance;
01396 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_BOOLEAN, &OUT_is_advance, G_TYPE_INVALID);
01397 (*(org_atheme_audacious_auto_advance_reply)data->cb) (proxy, OUT_is_advance, error, data->userdata);
01398 return;
01399 }
01400
01401 static
01402 #ifdef G_HAVE_INLINE
01403 inline
01404 #endif
01405 DBusGProxyCall*
01406 org_atheme_audacious_auto_advance_async (DBusGProxy *proxy, org_atheme_audacious_auto_advance_reply callback, gpointer userdata)
01407
01408 {
01409 DBusGAsyncData *stuff;
01410 stuff = g_slice_new (DBusGAsyncData);
01411 stuff->cb = G_CALLBACK (callback);
01412 stuff->userdata = userdata;
01413 return dbus_g_proxy_begin_call (proxy, "AutoAdvance", org_atheme_audacious_auto_advance_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
01414 }
01415 static
01416 #ifdef G_HAVE_INLINE
01417 inline
01418 #endif
01419 gboolean
01420 org_atheme_audacious_toggle_auto_advance (DBusGProxy *proxy, GError **error)
01421
01422 {
01423 return dbus_g_proxy_call (proxy, "ToggleAutoAdvance", error, G_TYPE_INVALID, G_TYPE_INVALID);
01424 }
01425
01426 typedef void (*org_atheme_audacious_toggle_auto_advance_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
01427
01428 static void
01429 org_atheme_audacious_toggle_auto_advance_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01430 {
01431 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01432 GError *error = NULL;
01433 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
01434 (*(org_atheme_audacious_toggle_auto_advance_reply)data->cb) (proxy, error, data->userdata);
01435 return;
01436 }
01437
01438 static
01439 #ifdef G_HAVE_INLINE
01440 inline
01441 #endif
01442 DBusGProxyCall*
01443 org_atheme_audacious_toggle_auto_advance_async (DBusGProxy *proxy, org_atheme_audacious_toggle_auto_advance_reply callback, gpointer userdata)
01444
01445 {
01446 DBusGAsyncData *stuff;
01447 stuff = g_slice_new (DBusGAsyncData);
01448 stuff->cb = G_CALLBACK (callback);
01449 stuff->userdata = userdata;
01450 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);
01451 }
01452 static
01453 #ifdef G_HAVE_INLINE
01454 inline
01455 #endif
01456 gboolean
01457 org_atheme_audacious_repeat (DBusGProxy *proxy, gboolean* OUT_is_repeat, GError **error)
01458
01459 {
01460 return dbus_g_proxy_call (proxy, "Repeat", error, G_TYPE_INVALID, G_TYPE_BOOLEAN, OUT_is_repeat, G_TYPE_INVALID);
01461 }
01462
01463 typedef void (*org_atheme_audacious_repeat_reply) (DBusGProxy *proxy, gboolean OUT_is_repeat, GError *error, gpointer userdata);
01464
01465 static void
01466 org_atheme_audacious_repeat_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01467 {
01468 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01469 GError *error = NULL;
01470 gboolean OUT_is_repeat;
01471 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_BOOLEAN, &OUT_is_repeat, G_TYPE_INVALID);
01472 (*(org_atheme_audacious_repeat_reply)data->cb) (proxy, OUT_is_repeat, error, data->userdata);
01473 return;
01474 }
01475
01476 static
01477 #ifdef G_HAVE_INLINE
01478 inline
01479 #endif
01480 DBusGProxyCall*
01481 org_atheme_audacious_repeat_async (DBusGProxy *proxy, org_atheme_audacious_repeat_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, "Repeat", org_atheme_audacious_repeat_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
01489 }
01490 static
01491 #ifdef G_HAVE_INLINE
01492 inline
01493 #endif
01494 gboolean
01495 org_atheme_audacious_toggle_repeat (DBusGProxy *proxy, GError **error)
01496
01497 {
01498 return dbus_g_proxy_call (proxy, "ToggleRepeat", error, G_TYPE_INVALID, G_TYPE_INVALID);
01499 }
01500
01501 typedef void (*org_atheme_audacious_toggle_repeat_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
01502
01503 static void
01504 org_atheme_audacious_toggle_repeat_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_toggle_repeat_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_toggle_repeat_async (DBusGProxy *proxy, org_atheme_audacious_toggle_repeat_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, "ToggleRepeat", org_atheme_audacious_toggle_repeat_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_shuffle (DBusGProxy *proxy, gboolean* OUT_is_shuffle, GError **error)
01533
01534 {
01535 return dbus_g_proxy_call (proxy, "Shuffle", error, G_TYPE_INVALID, G_TYPE_BOOLEAN, OUT_is_shuffle, G_TYPE_INVALID);
01536 }
01537
01538 typedef void (*org_atheme_audacious_shuffle_reply) (DBusGProxy *proxy, gboolean OUT_is_shuffle, GError *error, gpointer userdata);
01539
01540 static void
01541 org_atheme_audacious_shuffle_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01542 {
01543 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01544 GError *error = NULL;
01545 gboolean OUT_is_shuffle;
01546 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_BOOLEAN, &OUT_is_shuffle, G_TYPE_INVALID);
01547 (*(org_atheme_audacious_shuffle_reply)data->cb) (proxy, OUT_is_shuffle, error, data->userdata);
01548 return;
01549 }
01550
01551 static
01552 #ifdef G_HAVE_INLINE
01553 inline
01554 #endif
01555 DBusGProxyCall*
01556 org_atheme_audacious_shuffle_async (DBusGProxy *proxy, org_atheme_audacious_shuffle_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, "Shuffle", org_atheme_audacious_shuffle_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_shuffle (DBusGProxy *proxy, GError **error)
01571
01572 {
01573 return dbus_g_proxy_call (proxy, "ToggleShuffle", error, G_TYPE_INVALID, G_TYPE_INVALID);
01574 }
01575
01576 typedef void (*org_atheme_audacious_toggle_shuffle_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
01577
01578 static void
01579 org_atheme_audacious_toggle_shuffle_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_shuffle_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_shuffle_async (DBusGProxy *proxy, org_atheme_audacious_toggle_shuffle_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, "ToggleShuffle", org_atheme_audacious_toggle_shuffle_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_show_prefs_box (DBusGProxy *proxy, const gboolean IN_show, GError **error)
01608
01609 {
01610 return dbus_g_proxy_call (proxy, "ShowPrefsBox", error, G_TYPE_BOOLEAN, IN_show, G_TYPE_INVALID, G_TYPE_INVALID);
01611 }
01612
01613 typedef void (*org_atheme_audacious_show_prefs_box_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
01614
01615 static void
01616 org_atheme_audacious_show_prefs_box_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01617 {
01618 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01619 GError *error = NULL;
01620 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
01621 (*(org_atheme_audacious_show_prefs_box_reply)data->cb) (proxy, error, data->userdata);
01622 return;
01623 }
01624
01625 static
01626 #ifdef G_HAVE_INLINE
01627 inline
01628 #endif
01629 DBusGProxyCall*
01630 org_atheme_audacious_show_prefs_box_async (DBusGProxy *proxy, const gboolean IN_show, org_atheme_audacious_show_prefs_box_reply callback, gpointer userdata)
01631
01632 {
01633 DBusGAsyncData *stuff;
01634 stuff = g_slice_new (DBusGAsyncData);
01635 stuff->cb = G_CALLBACK (callback);
01636 stuff->userdata = userdata;
01637 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);
01638 }
01639 static
01640 #ifdef G_HAVE_INLINE
01641 inline
01642 #endif
01643 gboolean
01644 org_atheme_audacious_show_about_box (DBusGProxy *proxy, const gboolean IN_show, GError **error)
01645
01646 {
01647 return dbus_g_proxy_call (proxy, "ShowAboutBox", error, G_TYPE_BOOLEAN, IN_show, G_TYPE_INVALID, G_TYPE_INVALID);
01648 }
01649
01650 typedef void (*org_atheme_audacious_show_about_box_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
01651
01652 static void
01653 org_atheme_audacious_show_about_box_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01654 {
01655 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01656 GError *error = NULL;
01657 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
01658 (*(org_atheme_audacious_show_about_box_reply)data->cb) (proxy, error, data->userdata);
01659 return;
01660 }
01661
01662 static
01663 #ifdef G_HAVE_INLINE
01664 inline
01665 #endif
01666 DBusGProxyCall*
01667 org_atheme_audacious_show_about_box_async (DBusGProxy *proxy, const gboolean IN_show, org_atheme_audacious_show_about_box_reply callback, gpointer userdata)
01668
01669 {
01670 DBusGAsyncData *stuff;
01671 stuff = g_slice_new (DBusGAsyncData);
01672 stuff->cb = G_CALLBACK (callback);
01673 stuff->userdata = userdata;
01674 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);
01675 }
01676 static
01677 #ifdef G_HAVE_INLINE
01678 inline
01679 #endif
01680 gboolean
01681 org_atheme_audacious_show_jtf_box (DBusGProxy *proxy, const gboolean IN_show, GError **error)
01682
01683 {
01684 return dbus_g_proxy_call (proxy, "ShowJtfBox", error, G_TYPE_BOOLEAN, IN_show, G_TYPE_INVALID, G_TYPE_INVALID);
01685 }
01686
01687 typedef void (*org_atheme_audacious_show_jtf_box_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
01688
01689 static void
01690 org_atheme_audacious_show_jtf_box_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01691 {
01692 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01693 GError *error = NULL;
01694 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
01695 (*(org_atheme_audacious_show_jtf_box_reply)data->cb) (proxy, error, data->userdata);
01696 return;
01697 }
01698
01699 static
01700 #ifdef G_HAVE_INLINE
01701 inline
01702 #endif
01703 DBusGProxyCall*
01704 org_atheme_audacious_show_jtf_box_async (DBusGProxy *proxy, const gboolean IN_show, org_atheme_audacious_show_jtf_box_reply callback, gpointer userdata)
01705
01706 {
01707 DBusGAsyncData *stuff;
01708 stuff = g_slice_new (DBusGAsyncData);
01709 stuff->cb = G_CALLBACK (callback);
01710 stuff->userdata = userdata;
01711 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);
01712 }
01713 static
01714 #ifdef G_HAVE_INLINE
01715 inline
01716 #endif
01717 gboolean
01718 org_atheme_audacious_show_filebrowser (DBusGProxy *proxy, const gboolean IN_show, GError **error)
01719
01720 {
01721 return dbus_g_proxy_call (proxy, "ShowFilebrowser", error, G_TYPE_BOOLEAN, IN_show, G_TYPE_INVALID, G_TYPE_INVALID);
01722 }
01723
01724 typedef void (*org_atheme_audacious_show_filebrowser_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
01725
01726 static void
01727 org_atheme_audacious_show_filebrowser_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01728 {
01729 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01730 GError *error = NULL;
01731 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
01732 (*(org_atheme_audacious_show_filebrowser_reply)data->cb) (proxy, error, data->userdata);
01733 return;
01734 }
01735
01736 static
01737 #ifdef G_HAVE_INLINE
01738 inline
01739 #endif
01740 DBusGProxyCall*
01741 org_atheme_audacious_show_filebrowser_async (DBusGProxy *proxy, const gboolean IN_show, org_atheme_audacious_show_filebrowser_reply callback, gpointer userdata)
01742
01743 {
01744 DBusGAsyncData *stuff;
01745 stuff = g_slice_new (DBusGAsyncData);
01746 stuff->cb = G_CALLBACK (callback);
01747 stuff->userdata = userdata;
01748 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);
01749 }
01750 static
01751 #ifdef G_HAVE_INLINE
01752 inline
01753 #endif
01754 gboolean
01755 org_atheme_audacious_play_pause (DBusGProxy *proxy, GError **error)
01756
01757 {
01758 return dbus_g_proxy_call (proxy, "PlayPause", error, G_TYPE_INVALID, G_TYPE_INVALID);
01759 }
01760
01761 typedef void (*org_atheme_audacious_play_pause_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
01762
01763 static void
01764 org_atheme_audacious_play_pause_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01765 {
01766 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01767 GError *error = NULL;
01768 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
01769 (*(org_atheme_audacious_play_pause_reply)data->cb) (proxy, error, data->userdata);
01770 return;
01771 }
01772
01773 static
01774 #ifdef G_HAVE_INLINE
01775 inline
01776 #endif
01777 DBusGProxyCall*
01778 org_atheme_audacious_play_pause_async (DBusGProxy *proxy, org_atheme_audacious_play_pause_reply callback, gpointer userdata)
01779
01780 {
01781 DBusGAsyncData *stuff;
01782 stuff = g_slice_new (DBusGAsyncData);
01783 stuff->cb = G_CALLBACK (callback);
01784 stuff->userdata = userdata;
01785 return dbus_g_proxy_begin_call (proxy, "PlayPause", org_atheme_audacious_play_pause_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
01786 }
01787 static
01788 #ifdef G_HAVE_INLINE
01789 inline
01790 #endif
01791 gboolean
01792 org_atheme_audacious_queue_get_list_pos (DBusGProxy *proxy, const guint IN_qpos, guint* OUT_pos, GError **error)
01793
01794 {
01795 return dbus_g_proxy_call (proxy, "QueueGetListPos", error, G_TYPE_UINT, IN_qpos, G_TYPE_INVALID, G_TYPE_UINT, OUT_pos, G_TYPE_INVALID);
01796 }
01797
01798 typedef void (*org_atheme_audacious_queue_get_list_pos_reply) (DBusGProxy *proxy, guint OUT_pos, GError *error, gpointer userdata);
01799
01800 static void
01801 org_atheme_audacious_queue_get_list_pos_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01802 {
01803 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01804 GError *error = NULL;
01805 guint OUT_pos;
01806 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_UINT, &OUT_pos, G_TYPE_INVALID);
01807 (*(org_atheme_audacious_queue_get_list_pos_reply)data->cb) (proxy, OUT_pos, error, data->userdata);
01808 return;
01809 }
01810
01811 static
01812 #ifdef G_HAVE_INLINE
01813 inline
01814 #endif
01815 DBusGProxyCall*
01816 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)
01817
01818 {
01819 DBusGAsyncData *stuff;
01820 stuff = g_slice_new (DBusGAsyncData);
01821 stuff->cb = G_CALLBACK (callback);
01822 stuff->userdata = userdata;
01823 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);
01824 }
01825 static
01826 #ifdef G_HAVE_INLINE
01827 inline
01828 #endif
01829 gboolean
01830 org_atheme_audacious_queue_get_queue_pos (DBusGProxy *proxy, const guint IN_pos, guint* OUT_qpos, GError **error)
01831
01832 {
01833 return dbus_g_proxy_call (proxy, "QueueGetQueuePos", error, G_TYPE_UINT, IN_pos, G_TYPE_INVALID, G_TYPE_UINT, OUT_qpos, G_TYPE_INVALID);
01834 }
01835
01836 typedef void (*org_atheme_audacious_queue_get_queue_pos_reply) (DBusGProxy *proxy, guint OUT_qpos, GError *error, gpointer userdata);
01837
01838 static void
01839 org_atheme_audacious_queue_get_queue_pos_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01840 {
01841 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01842 GError *error = NULL;
01843 guint OUT_qpos;
01844 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_UINT, &OUT_qpos, G_TYPE_INVALID);
01845 (*(org_atheme_audacious_queue_get_queue_pos_reply)data->cb) (proxy, OUT_qpos, error, data->userdata);
01846 return;
01847 }
01848
01849 static
01850 #ifdef G_HAVE_INLINE
01851 inline
01852 #endif
01853 DBusGProxyCall*
01854 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)
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, "QueueGetQueuePos", org_atheme_audacious_queue_get_queue_pos_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_UINT, IN_pos, G_TYPE_INVALID);
01862 }
01863 static
01864 #ifdef G_HAVE_INLINE
01865 inline
01866 #endif
01867 gboolean
01868 org_atheme_audacious_get_info (DBusGProxy *proxy, gint* OUT_rate, gint* OUT_freq, gint* OUT_nch, GError **error)
01869
01870 {
01871 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);
01872 }
01873
01874 typedef void (*org_atheme_audacious_get_info_reply) (DBusGProxy *proxy, gint OUT_rate, gint OUT_freq, gint OUT_nch, GError *error, gpointer userdata);
01875
01876 static void
01877 org_atheme_audacious_get_info_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01878 {
01879 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01880 GError *error = NULL;
01881 gint OUT_rate;
01882 gint OUT_freq;
01883 gint OUT_nch;
01884 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);
01885 (*(org_atheme_audacious_get_info_reply)data->cb) (proxy, OUT_rate, OUT_freq, OUT_nch, error, data->userdata);
01886 return;
01887 }
01888
01889 static
01890 #ifdef G_HAVE_INLINE
01891 inline
01892 #endif
01893 DBusGProxyCall*
01894 org_atheme_audacious_get_info_async (DBusGProxy *proxy, org_atheme_audacious_get_info_reply callback, gpointer userdata)
01895
01896 {
01897 DBusGAsyncData *stuff;
01898 stuff = g_slice_new (DBusGAsyncData);
01899 stuff->cb = G_CALLBACK (callback);
01900 stuff->userdata = userdata;
01901 return dbus_g_proxy_begin_call (proxy, "GetInfo", org_atheme_audacious_get_info_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
01902 }
01903 static
01904 #ifdef G_HAVE_INLINE
01905 inline
01906 #endif
01907 gboolean
01908 org_atheme_audacious_toggle_aot (DBusGProxy *proxy, const gboolean IN_ontop, GError **error)
01909
01910 {
01911 return dbus_g_proxy_call (proxy, "ToggleAot", error, G_TYPE_BOOLEAN, IN_ontop, G_TYPE_INVALID, G_TYPE_INVALID);
01912 }
01913
01914 typedef void (*org_atheme_audacious_toggle_aot_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
01915
01916 static void
01917 org_atheme_audacious_toggle_aot_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01918 {
01919 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01920 GError *error = NULL;
01921 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
01922 (*(org_atheme_audacious_toggle_aot_reply)data->cb) (proxy, error, data->userdata);
01923 return;
01924 }
01925
01926 static
01927 #ifdef G_HAVE_INLINE
01928 inline
01929 #endif
01930 DBusGProxyCall*
01931 org_atheme_audacious_toggle_aot_async (DBusGProxy *proxy, const gboolean IN_ontop, org_atheme_audacious_toggle_aot_reply callback, gpointer userdata)
01932
01933 {
01934 DBusGAsyncData *stuff;
01935 stuff = g_slice_new (DBusGAsyncData);
01936 stuff->cb = G_CALLBACK (callback);
01937 stuff->userdata = userdata;
01938 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);
01939 }
01940 static
01941 #ifdef G_HAVE_INLINE
01942 inline
01943 #endif
01944 gboolean
01945 org_atheme_audacious_get_playqueue_length (DBusGProxy *proxy, gint* OUT_length, GError **error)
01946
01947 {
01948 return dbus_g_proxy_call (proxy, "GetPlayqueueLength", error, G_TYPE_INVALID, G_TYPE_INT, OUT_length, G_TYPE_INVALID);
01949 }
01950
01951 typedef void (*org_atheme_audacious_get_playqueue_length_reply) (DBusGProxy *proxy, gint OUT_length, GError *error, gpointer userdata);
01952
01953 static void
01954 org_atheme_audacious_get_playqueue_length_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01955 {
01956 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01957 GError *error = NULL;
01958 gint OUT_length;
01959 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INT, &OUT_length, G_TYPE_INVALID);
01960 (*(org_atheme_audacious_get_playqueue_length_reply)data->cb) (proxy, OUT_length, error, data->userdata);
01961 return;
01962 }
01963
01964 static
01965 #ifdef G_HAVE_INLINE
01966 inline
01967 #endif
01968 DBusGProxyCall*
01969 org_atheme_audacious_get_playqueue_length_async (DBusGProxy *proxy, org_atheme_audacious_get_playqueue_length_reply callback, gpointer userdata)
01970
01971 {
01972 DBusGAsyncData *stuff;
01973 stuff = g_slice_new (DBusGAsyncData);
01974 stuff->cb = G_CALLBACK (callback);
01975 stuff->userdata = userdata;
01976 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);
01977 }
01978 static
01979 #ifdef G_HAVE_INLINE
01980 inline
01981 #endif
01982 gboolean
01983 org_atheme_audacious_playlist_ins_url_string (DBusGProxy *proxy, const char * IN_url, const gint IN_pos, GError **error)
01984
01985 {
01986 return dbus_g_proxy_call (proxy, "PlaylistInsUrlString", error, G_TYPE_STRING, IN_url, G_TYPE_INT, IN_pos, G_TYPE_INVALID, G_TYPE_INVALID);
01987 }
01988
01989 typedef void (*org_atheme_audacious_playlist_ins_url_string_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
01990
01991 static void
01992 org_atheme_audacious_playlist_ins_url_string_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01993 {
01994 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01995 GError *error = NULL;
01996 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
01997 (*(org_atheme_audacious_playlist_ins_url_string_reply)data->cb) (proxy, error, data->userdata);
01998 return;
01999 }
02000
02001 static
02002 #ifdef G_HAVE_INLINE
02003 inline
02004 #endif
02005 DBusGProxyCall*
02006 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)
02007
02008 {
02009 DBusGAsyncData *stuff;
02010 stuff = g_slice_new (DBusGAsyncData);
02011 stuff->cb = G_CALLBACK (callback);
02012 stuff->userdata = userdata;
02013 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);
02014 }
02015 static
02016 #ifdef G_HAVE_INLINE
02017 inline
02018 #endif
02019 gboolean
02020 org_atheme_audacious_playlist_add (DBusGProxy *proxy, const char * IN_list, GError **error)
02021
02022 {
02023 return dbus_g_proxy_call (proxy, "PlaylistAdd", error, G_TYPE_STRING, IN_list, G_TYPE_INVALID, G_TYPE_INVALID);
02024 }
02025
02026 typedef void (*org_atheme_audacious_playlist_add_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
02027
02028 static void
02029 org_atheme_audacious_playlist_add_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
02030 {
02031 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
02032 GError *error = NULL;
02033 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
02034 (*(org_atheme_audacious_playlist_add_reply)data->cb) (proxy, error, data->userdata);
02035 return;
02036 }
02037
02038 static
02039 #ifdef G_HAVE_INLINE
02040 inline
02041 #endif
02042 DBusGProxyCall*
02043 org_atheme_audacious_playlist_add_async (DBusGProxy *proxy, const char * IN_list, org_atheme_audacious_playlist_add_reply callback, gpointer userdata)
02044
02045 {
02046 DBusGAsyncData *stuff;
02047 stuff = g_slice_new (DBusGAsyncData);
02048 stuff->cb = G_CALLBACK (callback);
02049 stuff->userdata = userdata;
02050 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);
02051 }
02052 static
02053 #ifdef G_HAVE_INLINE
02054 inline
02055 #endif
02056 gboolean
02057 org_atheme_audacious_playqueue_add (DBusGProxy *proxy, const gint IN_pos, GError **error)
02058
02059 {
02060 return dbus_g_proxy_call (proxy, "PlayqueueAdd", error, G_TYPE_INT, IN_pos, G_TYPE_INVALID, G_TYPE_INVALID);
02061 }
02062
02063 typedef void (*org_atheme_audacious_playqueue_add_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
02064
02065 static void
02066 org_atheme_audacious_playqueue_add_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
02067 {
02068 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
02069 GError *error = NULL;
02070 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
02071 (*(org_atheme_audacious_playqueue_add_reply)data->cb) (proxy, error, data->userdata);
02072 return;
02073 }
02074
02075 static
02076 #ifdef G_HAVE_INLINE
02077 inline
02078 #endif
02079 DBusGProxyCall*
02080 org_atheme_audacious_playqueue_add_async (DBusGProxy *proxy, const gint IN_pos, org_atheme_audacious_playqueue_add_reply callback, gpointer userdata)
02081
02082 {
02083 DBusGAsyncData *stuff;
02084 stuff = g_slice_new (DBusGAsyncData);
02085 stuff->cb = G_CALLBACK (callback);
02086 stuff->userdata = userdata;
02087 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);
02088 }
02089 static
02090 #ifdef G_HAVE_INLINE
02091 inline
02092 #endif
02093 gboolean
02094 org_atheme_audacious_playqueue_remove (DBusGProxy *proxy, const gint IN_pos, GError **error)
02095
02096 {
02097 return dbus_g_proxy_call (proxy, "PlayqueueRemove", error, G_TYPE_INT, IN_pos, G_TYPE_INVALID, G_TYPE_INVALID);
02098 }
02099
02100 typedef void (*org_atheme_audacious_playqueue_remove_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
02101
02102 static void
02103 org_atheme_audacious_playqueue_remove_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
02104 {
02105 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
02106 GError *error = NULL;
02107 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
02108 (*(org_atheme_audacious_playqueue_remove_reply)data->cb) (proxy, error, data->userdata);
02109 return;
02110 }
02111
02112 static
02113 #ifdef G_HAVE_INLINE
02114 inline
02115 #endif
02116 DBusGProxyCall*
02117 org_atheme_audacious_playqueue_remove_async (DBusGProxy *proxy, const gint IN_pos, org_atheme_audacious_playqueue_remove_reply callback, gpointer userdata)
02118
02119 {
02120 DBusGAsyncData *stuff;
02121 stuff = g_slice_new (DBusGAsyncData);
02122 stuff->cb = G_CALLBACK (callback);
02123 stuff->userdata = userdata;
02124 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);
02125 }
02126 static
02127 #ifdef G_HAVE_INLINE
02128 inline
02129 #endif
02130 gboolean
02131 org_atheme_audacious_playqueue_clear (DBusGProxy *proxy, GError **error)
02132
02133 {
02134 return dbus_g_proxy_call (proxy, "PlayqueueClear", error, G_TYPE_INVALID, G_TYPE_INVALID);
02135 }
02136
02137 typedef void (*org_atheme_audacious_playqueue_clear_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
02138
02139 static void
02140 org_atheme_audacious_playqueue_clear_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
02141 {
02142 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
02143 GError *error = NULL;
02144 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
02145 (*(org_atheme_audacious_playqueue_clear_reply)data->cb) (proxy, error, data->userdata);
02146 return;
02147 }
02148
02149 static
02150 #ifdef G_HAVE_INLINE
02151 inline
02152 #endif
02153 DBusGProxyCall*
02154 org_atheme_audacious_playqueue_clear_async (DBusGProxy *proxy, org_atheme_audacious_playqueue_clear_reply callback, gpointer userdata)
02155
02156 {
02157 DBusGAsyncData *stuff;
02158 stuff = g_slice_new (DBusGAsyncData);
02159 stuff->cb = G_CALLBACK (callback);
02160 stuff->userdata = userdata;
02161 return dbus_g_proxy_begin_call (proxy, "PlayqueueClear", org_atheme_audacious_playqueue_clear_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
02162 }
02163 static
02164 #ifdef G_HAVE_INLINE
02165 inline
02166 #endif
02167 gboolean
02168 org_atheme_audacious_playqueue_is_queued (DBusGProxy *proxy, const gint IN_pos, gboolean* OUT_is_queued, GError **error)
02169
02170 {
02171 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);
02172 }
02173
02174 typedef void (*org_atheme_audacious_playqueue_is_queued_reply) (DBusGProxy *proxy, gboolean OUT_is_queued, GError *error, gpointer userdata);
02175
02176 static void
02177 org_atheme_audacious_playqueue_is_queued_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
02178 {
02179 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
02180 GError *error = NULL;
02181 gboolean OUT_is_queued;
02182 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_BOOLEAN, &OUT_is_queued, G_TYPE_INVALID);
02183 (*(org_atheme_audacious_playqueue_is_queued_reply)data->cb) (proxy, OUT_is_queued, error, data->userdata);
02184 return;
02185 }
02186
02187 static
02188 #ifdef G_HAVE_INLINE
02189 inline
02190 #endif
02191 DBusGProxyCall*
02192 org_atheme_audacious_playqueue_is_queued_async (DBusGProxy *proxy, const gint IN_pos, org_atheme_audacious_playqueue_is_queued_reply callback, gpointer userdata)
02193
02194 {
02195 DBusGAsyncData *stuff;
02196 stuff = g_slice_new (DBusGAsyncData);
02197 stuff->cb = G_CALLBACK (callback);
02198 stuff->userdata = userdata;
02199 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);
02200 }
02201 static
02202 #ifdef G_HAVE_INLINE
02203 inline
02204 #endif
02205 gboolean
02206 org_atheme_audacious_playlist_enqueue_to_temp (DBusGProxy *proxy, const char * IN_url, GError **error)
02207
02208 {
02209 return dbus_g_proxy_call (proxy, "PlaylistEnqueueToTemp", error, G_TYPE_STRING, IN_url, G_TYPE_INVALID, G_TYPE_INVALID);
02210 }
02211
02212 typedef void (*org_atheme_audacious_playlist_enqueue_to_temp_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
02213
02214 static void
02215 org_atheme_audacious_playlist_enqueue_to_temp_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
02216 {
02217 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
02218 GError *error = NULL;
02219 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
02220 (*(org_atheme_audacious_playlist_enqueue_to_temp_reply)data->cb) (proxy, error, data->userdata);
02221 return;
02222 }
02223
02224 static
02225 #ifdef G_HAVE_INLINE
02226 inline
02227 #endif
02228 DBusGProxyCall*
02229 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)
02230
02231 {
02232 DBusGAsyncData *stuff;
02233 stuff = g_slice_new (DBusGAsyncData);
02234 stuff->cb = G_CALLBACK (callback);
02235 stuff->userdata = userdata;
02236 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);
02237 }
02238 static
02239 #ifdef G_HAVE_INLINE
02240 inline
02241 #endif
02242 gboolean
02243 org_atheme_audacious_get_eq (DBusGProxy *proxy, gdouble* OUT_preamp, GArray** OUT_bands, GError **error)
02244
02245 {
02246 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);
02247 }
02248
02249 typedef void (*org_atheme_audacious_get_eq_reply) (DBusGProxy *proxy, gdouble OUT_preamp, GArray *OUT_bands, GError *error, gpointer userdata);
02250
02251 static void
02252 org_atheme_audacious_get_eq_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
02253 {
02254 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
02255 GError *error = NULL;
02256 gdouble OUT_preamp;
02257 GArray* OUT_bands;
02258 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);
02259 (*(org_atheme_audacious_get_eq_reply)data->cb) (proxy, OUT_preamp, OUT_bands, error, data->userdata);
02260 return;
02261 }
02262
02263 static
02264 #ifdef G_HAVE_INLINE
02265 inline
02266 #endif
02267 DBusGProxyCall*
02268 org_atheme_audacious_get_eq_async (DBusGProxy *proxy, org_atheme_audacious_get_eq_reply callback, gpointer userdata)
02269
02270 {
02271 DBusGAsyncData *stuff;
02272 stuff = g_slice_new (DBusGAsyncData);
02273 stuff->cb = G_CALLBACK (callback);
02274 stuff->userdata = userdata;
02275 return dbus_g_proxy_begin_call (proxy, "GetEq", org_atheme_audacious_get_eq_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
02276 }
02277 static
02278 #ifdef G_HAVE_INLINE
02279 inline
02280 #endif
02281 gboolean
02282 org_atheme_audacious_get_eq_preamp (DBusGProxy *proxy, gdouble* OUT_preamp, GError **error)
02283
02284 {
02285 return dbus_g_proxy_call (proxy, "GetEqPreamp", error, G_TYPE_INVALID, G_TYPE_DOUBLE, OUT_preamp, G_TYPE_INVALID);
02286 }
02287
02288 typedef void (*org_atheme_audacious_get_eq_preamp_reply) (DBusGProxy *proxy, gdouble OUT_preamp, GError *error, gpointer userdata);
02289
02290 static void
02291 org_atheme_audacious_get_eq_preamp_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
02292 {
02293 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
02294 GError *error = NULL;
02295 gdouble OUT_preamp;
02296 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_DOUBLE, &OUT_preamp, G_TYPE_INVALID);
02297 (*(org_atheme_audacious_get_eq_preamp_reply)data->cb) (proxy, OUT_preamp, error, data->userdata);
02298 return;
02299 }
02300
02301 static
02302 #ifdef G_HAVE_INLINE
02303 inline
02304 #endif
02305 DBusGProxyCall*
02306 org_atheme_audacious_get_eq_preamp_async (DBusGProxy *proxy, org_atheme_audacious_get_eq_preamp_reply callback, gpointer userdata)
02307
02308 {
02309 DBusGAsyncData *stuff;
02310 stuff = g_slice_new (DBusGAsyncData);
02311 stuff->cb = G_CALLBACK (callback);
02312 stuff->userdata = userdata;
02313 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);
02314 }
02315 static
02316 #ifdef G_HAVE_INLINE
02317 inline
02318 #endif
02319 gboolean
02320 org_atheme_audacious_get_eq_band (DBusGProxy *proxy, const gint IN_band, gdouble* OUT_value, GError **error)
02321
02322 {
02323 return dbus_g_proxy_call (proxy, "GetEqBand", error, G_TYPE_INT, IN_band, G_TYPE_INVALID, G_TYPE_DOUBLE, OUT_value, G_TYPE_INVALID);
02324 }
02325
02326 typedef void (*org_atheme_audacious_get_eq_band_reply) (DBusGProxy *proxy, gdouble OUT_value, GError *error, gpointer userdata);
02327
02328 static void
02329 org_atheme_audacious_get_eq_band_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
02330 {
02331 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
02332 GError *error = NULL;
02333 gdouble OUT_value;
02334 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_DOUBLE, &OUT_value, G_TYPE_INVALID);
02335 (*(org_atheme_audacious_get_eq_band_reply)data->cb) (proxy, OUT_value, error, data->userdata);
02336 return;
02337 }
02338
02339 static
02340 #ifdef G_HAVE_INLINE
02341 inline
02342 #endif
02343 DBusGProxyCall*
02344 org_atheme_audacious_get_eq_band_async (DBusGProxy *proxy, const gint IN_band, org_atheme_audacious_get_eq_band_reply callback, gpointer userdata)
02345
02346 {
02347 DBusGAsyncData *stuff;
02348 stuff = g_slice_new (DBusGAsyncData);
02349 stuff->cb = G_CALLBACK (callback);
02350 stuff->userdata = userdata;
02351 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);
02352 }
02353 static
02354 #ifdef G_HAVE_INLINE
02355 inline
02356 #endif
02357 gboolean
02358 org_atheme_audacious_set_eq (DBusGProxy *proxy, const gdouble IN_preamp, const GArray* IN_bands, GError **error)
02359
02360 {
02361 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);
02362 }
02363
02364 typedef void (*org_atheme_audacious_set_eq_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
02365
02366 static void
02367 org_atheme_audacious_set_eq_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
02368 {
02369 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
02370 GError *error = NULL;
02371 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
02372 (*(org_atheme_audacious_set_eq_reply)data->cb) (proxy, error, data->userdata);
02373 return;
02374 }
02375
02376 static
02377 #ifdef G_HAVE_INLINE
02378 inline
02379 #endif
02380 DBusGProxyCall*
02381 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)
02382
02383 {
02384 DBusGAsyncData *stuff;
02385 stuff = g_slice_new (DBusGAsyncData);
02386 stuff->cb = G_CALLBACK (callback);
02387 stuff->userdata = userdata;
02388 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);
02389 }
02390 static
02391 #ifdef G_HAVE_INLINE
02392 inline
02393 #endif
02394 gboolean
02395 org_atheme_audacious_set_eq_preamp (DBusGProxy *proxy, const gdouble IN_preamp, GError **error)
02396
02397 {
02398 return dbus_g_proxy_call (proxy, "SetEqPreamp", error, G_TYPE_DOUBLE, IN_preamp, G_TYPE_INVALID, G_TYPE_INVALID);
02399 }
02400
02401 typedef void (*org_atheme_audacious_set_eq_preamp_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
02402
02403 static void
02404 org_atheme_audacious_set_eq_preamp_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
02405 {
02406 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
02407 GError *error = NULL;
02408 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
02409 (*(org_atheme_audacious_set_eq_preamp_reply)data->cb) (proxy, error, data->userdata);
02410 return;
02411 }
02412
02413 static
02414 #ifdef G_HAVE_INLINE
02415 inline
02416 #endif
02417 DBusGProxyCall*
02418 org_atheme_audacious_set_eq_preamp_async (DBusGProxy *proxy, const gdouble IN_preamp, org_atheme_audacious_set_eq_preamp_reply callback, gpointer userdata)
02419
02420 {
02421 DBusGAsyncData *stuff;
02422 stuff = g_slice_new (DBusGAsyncData);
02423 stuff->cb = G_CALLBACK (callback);
02424 stuff->userdata = userdata;
02425 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);
02426 }
02427 static
02428 #ifdef G_HAVE_INLINE
02429 inline
02430 #endif
02431 gboolean
02432 org_atheme_audacious_set_eq_band (DBusGProxy *proxy, const gint IN_band, const gdouble IN_value, GError **error)
02433
02434 {
02435 return dbus_g_proxy_call (proxy, "SetEqBand", error, G_TYPE_INT, IN_band, G_TYPE_DOUBLE, IN_value, G_TYPE_INVALID, G_TYPE_INVALID);
02436 }
02437
02438 typedef void (*org_atheme_audacious_set_eq_band_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
02439
02440 static void
02441 org_atheme_audacious_set_eq_band_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
02442 {
02443 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
02444 GError *error = NULL;
02445 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
02446 (*(org_atheme_audacious_set_eq_band_reply)data->cb) (proxy, error, data->userdata);
02447 return;
02448 }
02449
02450 static
02451 #ifdef G_HAVE_INLINE
02452 inline
02453 #endif
02454 DBusGProxyCall*
02455 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)
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, "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);
02463 }
02464 static
02465 #ifdef G_HAVE_INLINE
02466 inline
02467 #endif
02468 gboolean
02469 org_atheme_audacious_equalizer_activate (DBusGProxy *proxy, const gboolean IN_active, GError **error)
02470
02471 {
02472 return dbus_g_proxy_call (proxy, "EqualizerActivate", error, G_TYPE_BOOLEAN, IN_active, G_TYPE_INVALID, G_TYPE_INVALID);
02473 }
02474
02475 typedef void (*org_atheme_audacious_equalizer_activate_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
02476
02477 static void
02478 org_atheme_audacious_equalizer_activate_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
02479 {
02480 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
02481 GError *error = NULL;
02482 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
02483 (*(org_atheme_audacious_equalizer_activate_reply)data->cb) (proxy, error, data->userdata);
02484 return;
02485 }
02486
02487 static
02488 #ifdef G_HAVE_INLINE
02489 inline
02490 #endif
02491 DBusGProxyCall*
02492 org_atheme_audacious_equalizer_activate_async (DBusGProxy *proxy, const gboolean IN_active, org_atheme_audacious_equalizer_activate_reply callback, gpointer userdata)
02493
02494 {
02495 DBusGAsyncData *stuff;
02496 stuff = g_slice_new (DBusGAsyncData);
02497 stuff->cb = G_CALLBACK (callback);
02498 stuff->userdata = userdata;
02499 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);
02500 }
02501 static
02502 #ifdef G_HAVE_INLINE
02503 inline
02504 #endif
02505 gboolean
02506 org_atheme_audacious_get_active_playlist_name (DBusGProxy *proxy, char ** OUT_plname, GError **error)
02507
02508 {
02509 return dbus_g_proxy_call (proxy, "GetActivePlaylistName", error, G_TYPE_INVALID, G_TYPE_STRING, OUT_plname, G_TYPE_INVALID);
02510 }
02511
02512 typedef void (*org_atheme_audacious_get_active_playlist_name_reply) (DBusGProxy *proxy, char * OUT_plname, GError *error, gpointer userdata);
02513
02514 static void
02515 org_atheme_audacious_get_active_playlist_name_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
02516 {
02517 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
02518 GError *error = NULL;
02519 char * OUT_plname;
02520 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_STRING, &OUT_plname, G_TYPE_INVALID);
02521 (*(org_atheme_audacious_get_active_playlist_name_reply)data->cb) (proxy, OUT_plname, error, data->userdata);
02522 return;
02523 }
02524
02525 static
02526 #ifdef G_HAVE_INLINE
02527 inline
02528 #endif
02529 DBusGProxyCall*
02530 org_atheme_audacious_get_active_playlist_name_async (DBusGProxy *proxy, org_atheme_audacious_get_active_playlist_name_reply callback, gpointer userdata)
02531
02532 {
02533 DBusGAsyncData *stuff;
02534 stuff = g_slice_new (DBusGAsyncData);
02535 stuff->cb = G_CALLBACK (callback);
02536 stuff->userdata = userdata;
02537 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);
02538 }
02539 #endif
02540
02541 G_END_DECLS