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_stop_after (DBusGProxy *proxy, gboolean* OUT_is_stopping, GError **error)
01608
01609 {
01610 return dbus_g_proxy_call (proxy, "StopAfter", error, G_TYPE_INVALID, G_TYPE_BOOLEAN, OUT_is_stopping, G_TYPE_INVALID);
01611 }
01612
01613 typedef void (*org_atheme_audacious_stop_after_reply) (DBusGProxy *proxy, gboolean OUT_is_stopping, GError *error, gpointer userdata);
01614
01615 static void
01616 org_atheme_audacious_stop_after_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01617 {
01618 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01619 GError *error = NULL;
01620 gboolean OUT_is_stopping;
01621 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_BOOLEAN, &OUT_is_stopping, G_TYPE_INVALID);
01622 (*(org_atheme_audacious_stop_after_reply)data->cb) (proxy, OUT_is_stopping, error, data->userdata);
01623 return;
01624 }
01625
01626 static
01627 #ifdef G_HAVE_INLINE
01628 inline
01629 #endif
01630 DBusGProxyCall*
01631 org_atheme_audacious_stop_after_async (DBusGProxy *proxy, org_atheme_audacious_stop_after_reply callback, gpointer userdata)
01632
01633 {
01634 DBusGAsyncData *stuff;
01635 stuff = g_slice_new (DBusGAsyncData);
01636 stuff->cb = G_CALLBACK (callback);
01637 stuff->userdata = userdata;
01638 return dbus_g_proxy_begin_call (proxy, "StopAfter", org_atheme_audacious_stop_after_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
01639 }
01640 static
01641 #ifdef G_HAVE_INLINE
01642 inline
01643 #endif
01644 gboolean
01645 org_atheme_audacious_toggle_stop_after (DBusGProxy *proxy, GError **error)
01646
01647 {
01648 return dbus_g_proxy_call (proxy, "ToggleStopAfter", error, G_TYPE_INVALID, G_TYPE_INVALID);
01649 }
01650
01651 typedef void (*org_atheme_audacious_toggle_stop_after_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
01652
01653 static void
01654 org_atheme_audacious_toggle_stop_after_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01655 {
01656 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01657 GError *error = NULL;
01658 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
01659 (*(org_atheme_audacious_toggle_stop_after_reply)data->cb) (proxy, error, data->userdata);
01660 return;
01661 }
01662
01663 static
01664 #ifdef G_HAVE_INLINE
01665 inline
01666 #endif
01667 DBusGProxyCall*
01668 org_atheme_audacious_toggle_stop_after_async (DBusGProxy *proxy, org_atheme_audacious_toggle_stop_after_reply callback, gpointer userdata)
01669
01670 {
01671 DBusGAsyncData *stuff;
01672 stuff = g_slice_new (DBusGAsyncData);
01673 stuff->cb = G_CALLBACK (callback);
01674 stuff->userdata = userdata;
01675 return dbus_g_proxy_begin_call (proxy, "ToggleStopAfter", org_atheme_audacious_toggle_stop_after_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
01676 }
01677 static
01678 #ifdef G_HAVE_INLINE
01679 inline
01680 #endif
01681 gboolean
01682 org_atheme_audacious_show_prefs_box (DBusGProxy *proxy, const gboolean IN_show, GError **error)
01683
01684 {
01685 return dbus_g_proxy_call (proxy, "ShowPrefsBox", error, G_TYPE_BOOLEAN, IN_show, G_TYPE_INVALID, G_TYPE_INVALID);
01686 }
01687
01688 typedef void (*org_atheme_audacious_show_prefs_box_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
01689
01690 static void
01691 org_atheme_audacious_show_prefs_box_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01692 {
01693 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01694 GError *error = NULL;
01695 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
01696 (*(org_atheme_audacious_show_prefs_box_reply)data->cb) (proxy, error, data->userdata);
01697 return;
01698 }
01699
01700 static
01701 #ifdef G_HAVE_INLINE
01702 inline
01703 #endif
01704 DBusGProxyCall*
01705 org_atheme_audacious_show_prefs_box_async (DBusGProxy *proxy, const gboolean IN_show, org_atheme_audacious_show_prefs_box_reply callback, gpointer userdata)
01706
01707 {
01708 DBusGAsyncData *stuff;
01709 stuff = g_slice_new (DBusGAsyncData);
01710 stuff->cb = G_CALLBACK (callback);
01711 stuff->userdata = userdata;
01712 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);
01713 }
01714 static
01715 #ifdef G_HAVE_INLINE
01716 inline
01717 #endif
01718 gboolean
01719 org_atheme_audacious_show_about_box (DBusGProxy *proxy, const gboolean IN_show, GError **error)
01720
01721 {
01722 return dbus_g_proxy_call (proxy, "ShowAboutBox", error, G_TYPE_BOOLEAN, IN_show, G_TYPE_INVALID, G_TYPE_INVALID);
01723 }
01724
01725 typedef void (*org_atheme_audacious_show_about_box_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
01726
01727 static void
01728 org_atheme_audacious_show_about_box_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01729 {
01730 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01731 GError *error = NULL;
01732 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
01733 (*(org_atheme_audacious_show_about_box_reply)data->cb) (proxy, error, data->userdata);
01734 return;
01735 }
01736
01737 static
01738 #ifdef G_HAVE_INLINE
01739 inline
01740 #endif
01741 DBusGProxyCall*
01742 org_atheme_audacious_show_about_box_async (DBusGProxy *proxy, const gboolean IN_show, org_atheme_audacious_show_about_box_reply callback, gpointer userdata)
01743
01744 {
01745 DBusGAsyncData *stuff;
01746 stuff = g_slice_new (DBusGAsyncData);
01747 stuff->cb = G_CALLBACK (callback);
01748 stuff->userdata = userdata;
01749 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);
01750 }
01751 static
01752 #ifdef G_HAVE_INLINE
01753 inline
01754 #endif
01755 gboolean
01756 org_atheme_audacious_show_jtf_box (DBusGProxy *proxy, const gboolean IN_show, GError **error)
01757
01758 {
01759 return dbus_g_proxy_call (proxy, "ShowJtfBox", error, G_TYPE_BOOLEAN, IN_show, G_TYPE_INVALID, G_TYPE_INVALID);
01760 }
01761
01762 typedef void (*org_atheme_audacious_show_jtf_box_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
01763
01764 static void
01765 org_atheme_audacious_show_jtf_box_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01766 {
01767 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01768 GError *error = NULL;
01769 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
01770 (*(org_atheme_audacious_show_jtf_box_reply)data->cb) (proxy, error, data->userdata);
01771 return;
01772 }
01773
01774 static
01775 #ifdef G_HAVE_INLINE
01776 inline
01777 #endif
01778 DBusGProxyCall*
01779 org_atheme_audacious_show_jtf_box_async (DBusGProxy *proxy, const gboolean IN_show, org_atheme_audacious_show_jtf_box_reply callback, gpointer userdata)
01780
01781 {
01782 DBusGAsyncData *stuff;
01783 stuff = g_slice_new (DBusGAsyncData);
01784 stuff->cb = G_CALLBACK (callback);
01785 stuff->userdata = userdata;
01786 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);
01787 }
01788 static
01789 #ifdef G_HAVE_INLINE
01790 inline
01791 #endif
01792 gboolean
01793 org_atheme_audacious_show_filebrowser (DBusGProxy *proxy, const gboolean IN_show, GError **error)
01794
01795 {
01796 return dbus_g_proxy_call (proxy, "ShowFilebrowser", error, G_TYPE_BOOLEAN, IN_show, G_TYPE_INVALID, G_TYPE_INVALID);
01797 }
01798
01799 typedef void (*org_atheme_audacious_show_filebrowser_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
01800
01801 static void
01802 org_atheme_audacious_show_filebrowser_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01803 {
01804 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01805 GError *error = NULL;
01806 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
01807 (*(org_atheme_audacious_show_filebrowser_reply)data->cb) (proxy, error, data->userdata);
01808 return;
01809 }
01810
01811 static
01812 #ifdef G_HAVE_INLINE
01813 inline
01814 #endif
01815 DBusGProxyCall*
01816 org_atheme_audacious_show_filebrowser_async (DBusGProxy *proxy, const gboolean IN_show, org_atheme_audacious_show_filebrowser_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, "ShowFilebrowser", org_atheme_audacious_show_filebrowser_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_BOOLEAN, IN_show, G_TYPE_INVALID);
01824 }
01825 static
01826 #ifdef G_HAVE_INLINE
01827 inline
01828 #endif
01829 gboolean
01830 org_atheme_audacious_play_pause (DBusGProxy *proxy, GError **error)
01831
01832 {
01833 return dbus_g_proxy_call (proxy, "PlayPause", error, G_TYPE_INVALID, G_TYPE_INVALID);
01834 }
01835
01836 typedef void (*org_atheme_audacious_play_pause_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
01837
01838 static void
01839 org_atheme_audacious_play_pause_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01840 {
01841 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01842 GError *error = NULL;
01843 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
01844 (*(org_atheme_audacious_play_pause_reply)data->cb) (proxy, error, data->userdata);
01845 return;
01846 }
01847
01848 static
01849 #ifdef G_HAVE_INLINE
01850 inline
01851 #endif
01852 DBusGProxyCall*
01853 org_atheme_audacious_play_pause_async (DBusGProxy *proxy, org_atheme_audacious_play_pause_reply callback, gpointer userdata)
01854
01855 {
01856 DBusGAsyncData *stuff;
01857 stuff = g_slice_new (DBusGAsyncData);
01858 stuff->cb = G_CALLBACK (callback);
01859 stuff->userdata = userdata;
01860 return dbus_g_proxy_begin_call (proxy, "PlayPause", org_atheme_audacious_play_pause_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
01861 }
01862 static
01863 #ifdef G_HAVE_INLINE
01864 inline
01865 #endif
01866 gboolean
01867 org_atheme_audacious_queue_get_list_pos (DBusGProxy *proxy, const guint IN_qpos, guint* OUT_pos, GError **error)
01868
01869 {
01870 return dbus_g_proxy_call (proxy, "QueueGetListPos", error, G_TYPE_UINT, IN_qpos, G_TYPE_INVALID, G_TYPE_UINT, OUT_pos, G_TYPE_INVALID);
01871 }
01872
01873 typedef void (*org_atheme_audacious_queue_get_list_pos_reply) (DBusGProxy *proxy, guint OUT_pos, GError *error, gpointer userdata);
01874
01875 static void
01876 org_atheme_audacious_queue_get_list_pos_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01877 {
01878 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01879 GError *error = NULL;
01880 guint OUT_pos;
01881 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_UINT, &OUT_pos, G_TYPE_INVALID);
01882 (*(org_atheme_audacious_queue_get_list_pos_reply)data->cb) (proxy, OUT_pos, error, data->userdata);
01883 return;
01884 }
01885
01886 static
01887 #ifdef G_HAVE_INLINE
01888 inline
01889 #endif
01890 DBusGProxyCall*
01891 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)
01892
01893 {
01894 DBusGAsyncData *stuff;
01895 stuff = g_slice_new (DBusGAsyncData);
01896 stuff->cb = G_CALLBACK (callback);
01897 stuff->userdata = userdata;
01898 return dbus_g_proxy_begin_call (proxy, "QueueGetListPos", org_atheme_audacious_queue_get_list_pos_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_UINT, IN_qpos, G_TYPE_INVALID);
01899 }
01900 static
01901 #ifdef G_HAVE_INLINE
01902 inline
01903 #endif
01904 gboolean
01905 org_atheme_audacious_queue_get_queue_pos (DBusGProxy *proxy, const guint IN_pos, guint* OUT_qpos, GError **error)
01906
01907 {
01908 return dbus_g_proxy_call (proxy, "QueueGetQueuePos", error, G_TYPE_UINT, IN_pos, G_TYPE_INVALID, G_TYPE_UINT, OUT_qpos, G_TYPE_INVALID);
01909 }
01910
01911 typedef void (*org_atheme_audacious_queue_get_queue_pos_reply) (DBusGProxy *proxy, guint OUT_qpos, GError *error, gpointer userdata);
01912
01913 static void
01914 org_atheme_audacious_queue_get_queue_pos_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01915 {
01916 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01917 GError *error = NULL;
01918 guint OUT_qpos;
01919 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_UINT, &OUT_qpos, G_TYPE_INVALID);
01920 (*(org_atheme_audacious_queue_get_queue_pos_reply)data->cb) (proxy, OUT_qpos, error, data->userdata);
01921 return;
01922 }
01923
01924 static
01925 #ifdef G_HAVE_INLINE
01926 inline
01927 #endif
01928 DBusGProxyCall*
01929 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)
01930
01931 {
01932 DBusGAsyncData *stuff;
01933 stuff = g_slice_new (DBusGAsyncData);
01934 stuff->cb = G_CALLBACK (callback);
01935 stuff->userdata = userdata;
01936 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);
01937 }
01938 static
01939 #ifdef G_HAVE_INLINE
01940 inline
01941 #endif
01942 gboolean
01943 org_atheme_audacious_get_info (DBusGProxy *proxy, gint* OUT_rate, gint* OUT_freq, gint* OUT_nch, GError **error)
01944
01945 {
01946 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);
01947 }
01948
01949 typedef void (*org_atheme_audacious_get_info_reply) (DBusGProxy *proxy, gint OUT_rate, gint OUT_freq, gint OUT_nch, GError *error, gpointer userdata);
01950
01951 static void
01952 org_atheme_audacious_get_info_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01953 {
01954 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01955 GError *error = NULL;
01956 gint OUT_rate;
01957 gint OUT_freq;
01958 gint OUT_nch;
01959 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);
01960 (*(org_atheme_audacious_get_info_reply)data->cb) (proxy, OUT_rate, OUT_freq, OUT_nch, 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_info_async (DBusGProxy *proxy, org_atheme_audacious_get_info_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, "GetInfo", org_atheme_audacious_get_info_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_toggle_aot (DBusGProxy *proxy, const gboolean IN_ontop, GError **error)
01984
01985 {
01986 return dbus_g_proxy_call (proxy, "ToggleAot", error, G_TYPE_BOOLEAN, IN_ontop, G_TYPE_INVALID, G_TYPE_INVALID);
01987 }
01988
01989 typedef void (*org_atheme_audacious_toggle_aot_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
01990
01991 static void
01992 org_atheme_audacious_toggle_aot_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_toggle_aot_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_toggle_aot_async (DBusGProxy *proxy, const gboolean IN_ontop, org_atheme_audacious_toggle_aot_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, "ToggleAot", org_atheme_audacious_toggle_aot_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_BOOLEAN, IN_ontop, G_TYPE_INVALID);
02014 }
02015 static
02016 #ifdef G_HAVE_INLINE
02017 inline
02018 #endif
02019 gboolean
02020 org_atheme_audacious_get_playqueue_length (DBusGProxy *proxy, gint* OUT_length, GError **error)
02021
02022 {
02023 return dbus_g_proxy_call (proxy, "GetPlayqueueLength", error, G_TYPE_INVALID, G_TYPE_INT, OUT_length, G_TYPE_INVALID);
02024 }
02025
02026 typedef void (*org_atheme_audacious_get_playqueue_length_reply) (DBusGProxy *proxy, gint OUT_length, GError *error, gpointer userdata);
02027
02028 static void
02029 org_atheme_audacious_get_playqueue_length_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
02030 {
02031 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
02032 GError *error = NULL;
02033 gint OUT_length;
02034 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INT, &OUT_length, G_TYPE_INVALID);
02035 (*(org_atheme_audacious_get_playqueue_length_reply)data->cb) (proxy, OUT_length, error, data->userdata);
02036 return;
02037 }
02038
02039 static
02040 #ifdef G_HAVE_INLINE
02041 inline
02042 #endif
02043 DBusGProxyCall*
02044 org_atheme_audacious_get_playqueue_length_async (DBusGProxy *proxy, org_atheme_audacious_get_playqueue_length_reply callback, gpointer userdata)
02045
02046 {
02047 DBusGAsyncData *stuff;
02048 stuff = g_slice_new (DBusGAsyncData);
02049 stuff->cb = G_CALLBACK (callback);
02050 stuff->userdata = userdata;
02051 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);
02052 }
02053 static
02054 #ifdef G_HAVE_INLINE
02055 inline
02056 #endif
02057 gboolean
02058 org_atheme_audacious_playlist_ins_url_string (DBusGProxy *proxy, const char * IN_url, const gint IN_pos, GError **error)
02059
02060 {
02061 return dbus_g_proxy_call (proxy, "PlaylistInsUrlString", error, G_TYPE_STRING, IN_url, G_TYPE_INT, IN_pos, G_TYPE_INVALID, G_TYPE_INVALID);
02062 }
02063
02064 typedef void (*org_atheme_audacious_playlist_ins_url_string_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
02065
02066 static void
02067 org_atheme_audacious_playlist_ins_url_string_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
02068 {
02069 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
02070 GError *error = NULL;
02071 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
02072 (*(org_atheme_audacious_playlist_ins_url_string_reply)data->cb) (proxy, error, data->userdata);
02073 return;
02074 }
02075
02076 static
02077 #ifdef G_HAVE_INLINE
02078 inline
02079 #endif
02080 DBusGProxyCall*
02081 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)
02082
02083 {
02084 DBusGAsyncData *stuff;
02085 stuff = g_slice_new (DBusGAsyncData);
02086 stuff->cb = G_CALLBACK (callback);
02087 stuff->userdata = userdata;
02088 return dbus_g_proxy_begin_call (proxy, "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);
02089 }
02090 static
02091 #ifdef G_HAVE_INLINE
02092 inline
02093 #endif
02094 gboolean
02095 org_atheme_audacious_playlist_add (DBusGProxy *proxy, const char * IN_list, GError **error)
02096
02097 {
02098 return dbus_g_proxy_call (proxy, "PlaylistAdd", error, G_TYPE_STRING, IN_list, G_TYPE_INVALID, G_TYPE_INVALID);
02099 }
02100
02101 typedef void (*org_atheme_audacious_playlist_add_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
02102
02103 static void
02104 org_atheme_audacious_playlist_add_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
02105 {
02106 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
02107 GError *error = NULL;
02108 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
02109 (*(org_atheme_audacious_playlist_add_reply)data->cb) (proxy, error, data->userdata);
02110 return;
02111 }
02112
02113 static
02114 #ifdef G_HAVE_INLINE
02115 inline
02116 #endif
02117 DBusGProxyCall*
02118 org_atheme_audacious_playlist_add_async (DBusGProxy *proxy, const char * IN_list, org_atheme_audacious_playlist_add_reply callback, gpointer userdata)
02119
02120 {
02121 DBusGAsyncData *stuff;
02122 stuff = g_slice_new (DBusGAsyncData);
02123 stuff->cb = G_CALLBACK (callback);
02124 stuff->userdata = userdata;
02125 return dbus_g_proxy_begin_call (proxy, "PlaylistAdd", org_atheme_audacious_playlist_add_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_STRING, IN_list, G_TYPE_INVALID);
02126 }
02127 static
02128 #ifdef G_HAVE_INLINE
02129 inline
02130 #endif
02131 gboolean
02132 org_atheme_audacious_playqueue_add (DBusGProxy *proxy, const gint IN_pos, GError **error)
02133
02134 {
02135 return dbus_g_proxy_call (proxy, "PlayqueueAdd", error, G_TYPE_INT, IN_pos, G_TYPE_INVALID, G_TYPE_INVALID);
02136 }
02137
02138 typedef void (*org_atheme_audacious_playqueue_add_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
02139
02140 static void
02141 org_atheme_audacious_playqueue_add_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
02142 {
02143 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
02144 GError *error = NULL;
02145 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
02146 (*(org_atheme_audacious_playqueue_add_reply)data->cb) (proxy, error, data->userdata);
02147 return;
02148 }
02149
02150 static
02151 #ifdef G_HAVE_INLINE
02152 inline
02153 #endif
02154 DBusGProxyCall*
02155 org_atheme_audacious_playqueue_add_async (DBusGProxy *proxy, const gint IN_pos, org_atheme_audacious_playqueue_add_reply callback, gpointer userdata)
02156
02157 {
02158 DBusGAsyncData *stuff;
02159 stuff = g_slice_new (DBusGAsyncData);
02160 stuff->cb = G_CALLBACK (callback);
02161 stuff->userdata = userdata;
02162 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);
02163 }
02164 static
02165 #ifdef G_HAVE_INLINE
02166 inline
02167 #endif
02168 gboolean
02169 org_atheme_audacious_playqueue_remove (DBusGProxy *proxy, const gint IN_pos, GError **error)
02170
02171 {
02172 return dbus_g_proxy_call (proxy, "PlayqueueRemove", error, G_TYPE_INT, IN_pos, G_TYPE_INVALID, G_TYPE_INVALID);
02173 }
02174
02175 typedef void (*org_atheme_audacious_playqueue_remove_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
02176
02177 static void
02178 org_atheme_audacious_playqueue_remove_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
02179 {
02180 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
02181 GError *error = NULL;
02182 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
02183 (*(org_atheme_audacious_playqueue_remove_reply)data->cb) (proxy, 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_remove_async (DBusGProxy *proxy, const gint IN_pos, org_atheme_audacious_playqueue_remove_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, "PlayqueueRemove", org_atheme_audacious_playqueue_remove_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_playqueue_clear (DBusGProxy *proxy, GError **error)
02207
02208 {
02209 return dbus_g_proxy_call (proxy, "PlayqueueClear", error, G_TYPE_INVALID, G_TYPE_INVALID);
02210 }
02211
02212 typedef void (*org_atheme_audacious_playqueue_clear_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
02213
02214 static void
02215 org_atheme_audacious_playqueue_clear_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_playqueue_clear_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_playqueue_clear_async (DBusGProxy *proxy, org_atheme_audacious_playqueue_clear_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, "PlayqueueClear", org_atheme_audacious_playqueue_clear_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
02237 }
02238 static
02239 #ifdef G_HAVE_INLINE
02240 inline
02241 #endif
02242 gboolean
02243 org_atheme_audacious_playqueue_is_queued (DBusGProxy *proxy, const gint IN_pos, gboolean* OUT_is_queued, GError **error)
02244
02245 {
02246 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);
02247 }
02248
02249 typedef void (*org_atheme_audacious_playqueue_is_queued_reply) (DBusGProxy *proxy, gboolean OUT_is_queued, GError *error, gpointer userdata);
02250
02251 static void
02252 org_atheme_audacious_playqueue_is_queued_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
02253 {
02254 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
02255 GError *error = NULL;
02256 gboolean OUT_is_queued;
02257 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_BOOLEAN, &OUT_is_queued, G_TYPE_INVALID);
02258 (*(org_atheme_audacious_playqueue_is_queued_reply)data->cb) (proxy, OUT_is_queued, error, data->userdata);
02259 return;
02260 }
02261
02262 static
02263 #ifdef G_HAVE_INLINE
02264 inline
02265 #endif
02266 DBusGProxyCall*
02267 org_atheme_audacious_playqueue_is_queued_async (DBusGProxy *proxy, const gint IN_pos, org_atheme_audacious_playqueue_is_queued_reply callback, gpointer userdata)
02268
02269 {
02270 DBusGAsyncData *stuff;
02271 stuff = g_slice_new (DBusGAsyncData);
02272 stuff->cb = G_CALLBACK (callback);
02273 stuff->userdata = userdata;
02274 return dbus_g_proxy_begin_call (proxy, "PlayqueueIsQueued", org_atheme_audacious_playqueue_is_queued_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INT, IN_pos, G_TYPE_INVALID);
02275 }
02276 static
02277 #ifdef G_HAVE_INLINE
02278 inline
02279 #endif
02280 gboolean
02281 org_atheme_audacious_playlist_enqueue_to_temp (DBusGProxy *proxy, const char * IN_url, GError **error)
02282
02283 {
02284 return dbus_g_proxy_call (proxy, "PlaylistEnqueueToTemp", error, G_TYPE_STRING, IN_url, G_TYPE_INVALID, G_TYPE_INVALID);
02285 }
02286
02287 typedef void (*org_atheme_audacious_playlist_enqueue_to_temp_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
02288
02289 static void
02290 org_atheme_audacious_playlist_enqueue_to_temp_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
02291 {
02292 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
02293 GError *error = NULL;
02294 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
02295 (*(org_atheme_audacious_playlist_enqueue_to_temp_reply)data->cb) (proxy, error, data->userdata);
02296 return;
02297 }
02298
02299 static
02300 #ifdef G_HAVE_INLINE
02301 inline
02302 #endif
02303 DBusGProxyCall*
02304 org_atheme_audacious_playlist_enqueue_to_temp_async (DBusGProxy *proxy, const char * IN_url, org_atheme_audacious_playlist_enqueue_to_temp_reply callback, gpointer userdata)
02305
02306 {
02307 DBusGAsyncData *stuff;
02308 stuff = g_slice_new (DBusGAsyncData);
02309 stuff->cb = G_CALLBACK (callback);
02310 stuff->userdata = userdata;
02311 return dbus_g_proxy_begin_call (proxy, "PlaylistEnqueueToTemp", org_atheme_audacious_playlist_enqueue_to_temp_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_STRING, IN_url, G_TYPE_INVALID);
02312 }
02313 static
02314 #ifdef G_HAVE_INLINE
02315 inline
02316 #endif
02317 gboolean
02318 org_atheme_audacious_get_eq (DBusGProxy *proxy, gdouble* OUT_preamp, GArray** OUT_bands, GError **error)
02319
02320 {
02321 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);
02322 }
02323
02324 typedef void (*org_atheme_audacious_get_eq_reply) (DBusGProxy *proxy, gdouble OUT_preamp, GArray *OUT_bands, GError *error, gpointer userdata);
02325
02326 static void
02327 org_atheme_audacious_get_eq_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
02328 {
02329 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
02330 GError *error = NULL;
02331 gdouble OUT_preamp;
02332 GArray* OUT_bands;
02333 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);
02334 (*(org_atheme_audacious_get_eq_reply)data->cb) (proxy, OUT_preamp, OUT_bands, error, data->userdata);
02335 return;
02336 }
02337
02338 static
02339 #ifdef G_HAVE_INLINE
02340 inline
02341 #endif
02342 DBusGProxyCall*
02343 org_atheme_audacious_get_eq_async (DBusGProxy *proxy, org_atheme_audacious_get_eq_reply callback, gpointer userdata)
02344
02345 {
02346 DBusGAsyncData *stuff;
02347 stuff = g_slice_new (DBusGAsyncData);
02348 stuff->cb = G_CALLBACK (callback);
02349 stuff->userdata = userdata;
02350 return dbus_g_proxy_begin_call (proxy, "GetEq", org_atheme_audacious_get_eq_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
02351 }
02352 static
02353 #ifdef G_HAVE_INLINE
02354 inline
02355 #endif
02356 gboolean
02357 org_atheme_audacious_get_eq_preamp (DBusGProxy *proxy, gdouble* OUT_preamp, GError **error)
02358
02359 {
02360 return dbus_g_proxy_call (proxy, "GetEqPreamp", error, G_TYPE_INVALID, G_TYPE_DOUBLE, OUT_preamp, G_TYPE_INVALID);
02361 }
02362
02363 typedef void (*org_atheme_audacious_get_eq_preamp_reply) (DBusGProxy *proxy, gdouble OUT_preamp, GError *error, gpointer userdata);
02364
02365 static void
02366 org_atheme_audacious_get_eq_preamp_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
02367 {
02368 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
02369 GError *error = NULL;
02370 gdouble OUT_preamp;
02371 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_DOUBLE, &OUT_preamp, G_TYPE_INVALID);
02372 (*(org_atheme_audacious_get_eq_preamp_reply)data->cb) (proxy, OUT_preamp, error, data->userdata);
02373 return;
02374 }
02375
02376 static
02377 #ifdef G_HAVE_INLINE
02378 inline
02379 #endif
02380 DBusGProxyCall*
02381 org_atheme_audacious_get_eq_preamp_async (DBusGProxy *proxy, org_atheme_audacious_get_eq_preamp_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, "GetEqPreamp", org_atheme_audacious_get_eq_preamp_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
02389 }
02390 static
02391 #ifdef G_HAVE_INLINE
02392 inline
02393 #endif
02394 gboolean
02395 org_atheme_audacious_get_eq_band (DBusGProxy *proxy, const gint IN_band, gdouble* OUT_value, GError **error)
02396
02397 {
02398 return dbus_g_proxy_call (proxy, "GetEqBand", error, G_TYPE_INT, IN_band, G_TYPE_INVALID, G_TYPE_DOUBLE, OUT_value, G_TYPE_INVALID);
02399 }
02400
02401 typedef void (*org_atheme_audacious_get_eq_band_reply) (DBusGProxy *proxy, gdouble OUT_value, GError *error, gpointer userdata);
02402
02403 static void
02404 org_atheme_audacious_get_eq_band_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
02405 {
02406 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
02407 GError *error = NULL;
02408 gdouble OUT_value;
02409 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_DOUBLE, &OUT_value, G_TYPE_INVALID);
02410 (*(org_atheme_audacious_get_eq_band_reply)data->cb) (proxy, OUT_value, error, data->userdata);
02411 return;
02412 }
02413
02414 static
02415 #ifdef G_HAVE_INLINE
02416 inline
02417 #endif
02418 DBusGProxyCall*
02419 org_atheme_audacious_get_eq_band_async (DBusGProxy *proxy, const gint IN_band, org_atheme_audacious_get_eq_band_reply callback, gpointer userdata)
02420
02421 {
02422 DBusGAsyncData *stuff;
02423 stuff = g_slice_new (DBusGAsyncData);
02424 stuff->cb = G_CALLBACK (callback);
02425 stuff->userdata = userdata;
02426 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);
02427 }
02428 static
02429 #ifdef G_HAVE_INLINE
02430 inline
02431 #endif
02432 gboolean
02433 org_atheme_audacious_set_eq (DBusGProxy *proxy, const gdouble IN_preamp, const GArray* IN_bands, GError **error)
02434
02435 {
02436 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);
02437 }
02438
02439 typedef void (*org_atheme_audacious_set_eq_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
02440
02441 static void
02442 org_atheme_audacious_set_eq_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
02443 {
02444 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
02445 GError *error = NULL;
02446 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
02447 (*(org_atheme_audacious_set_eq_reply)data->cb) (proxy, error, data->userdata);
02448 return;
02449 }
02450
02451 static
02452 #ifdef G_HAVE_INLINE
02453 inline
02454 #endif
02455 DBusGProxyCall*
02456 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)
02457
02458 {
02459 DBusGAsyncData *stuff;
02460 stuff = g_slice_new (DBusGAsyncData);
02461 stuff->cb = G_CALLBACK (callback);
02462 stuff->userdata = userdata;
02463 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);
02464 }
02465 static
02466 #ifdef G_HAVE_INLINE
02467 inline
02468 #endif
02469 gboolean
02470 org_atheme_audacious_set_eq_preamp (DBusGProxy *proxy, const gdouble IN_preamp, GError **error)
02471
02472 {
02473 return dbus_g_proxy_call (proxy, "SetEqPreamp", error, G_TYPE_DOUBLE, IN_preamp, G_TYPE_INVALID, G_TYPE_INVALID);
02474 }
02475
02476 typedef void (*org_atheme_audacious_set_eq_preamp_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
02477
02478 static void
02479 org_atheme_audacious_set_eq_preamp_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
02480 {
02481 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
02482 GError *error = NULL;
02483 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
02484 (*(org_atheme_audacious_set_eq_preamp_reply)data->cb) (proxy, error, data->userdata);
02485 return;
02486 }
02487
02488 static
02489 #ifdef G_HAVE_INLINE
02490 inline
02491 #endif
02492 DBusGProxyCall*
02493 org_atheme_audacious_set_eq_preamp_async (DBusGProxy *proxy, const gdouble IN_preamp, org_atheme_audacious_set_eq_preamp_reply callback, gpointer userdata)
02494
02495 {
02496 DBusGAsyncData *stuff;
02497 stuff = g_slice_new (DBusGAsyncData);
02498 stuff->cb = G_CALLBACK (callback);
02499 stuff->userdata = userdata;
02500 return dbus_g_proxy_begin_call (proxy, "SetEqPreamp", org_atheme_audacious_set_eq_preamp_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_DOUBLE, IN_preamp, G_TYPE_INVALID);
02501 }
02502 static
02503 #ifdef G_HAVE_INLINE
02504 inline
02505 #endif
02506 gboolean
02507 org_atheme_audacious_set_eq_band (DBusGProxy *proxy, const gint IN_band, const gdouble IN_value, GError **error)
02508
02509 {
02510 return dbus_g_proxy_call (proxy, "SetEqBand", error, G_TYPE_INT, IN_band, G_TYPE_DOUBLE, IN_value, G_TYPE_INVALID, G_TYPE_INVALID);
02511 }
02512
02513 typedef void (*org_atheme_audacious_set_eq_band_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
02514
02515 static void
02516 org_atheme_audacious_set_eq_band_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
02517 {
02518 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
02519 GError *error = NULL;
02520 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
02521 (*(org_atheme_audacious_set_eq_band_reply)data->cb) (proxy, error, data->userdata);
02522 return;
02523 }
02524
02525 static
02526 #ifdef G_HAVE_INLINE
02527 inline
02528 #endif
02529 DBusGProxyCall*
02530 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)
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, "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);
02538 }
02539 static
02540 #ifdef G_HAVE_INLINE
02541 inline
02542 #endif
02543 gboolean
02544 org_atheme_audacious_equalizer_activate (DBusGProxy *proxy, const gboolean IN_active, GError **error)
02545
02546 {
02547 return dbus_g_proxy_call (proxy, "EqualizerActivate", error, G_TYPE_BOOLEAN, IN_active, G_TYPE_INVALID, G_TYPE_INVALID);
02548 }
02549
02550 typedef void (*org_atheme_audacious_equalizer_activate_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
02551
02552 static void
02553 org_atheme_audacious_equalizer_activate_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
02554 {
02555 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
02556 GError *error = NULL;
02557 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
02558 (*(org_atheme_audacious_equalizer_activate_reply)data->cb) (proxy, error, data->userdata);
02559 return;
02560 }
02561
02562 static
02563 #ifdef G_HAVE_INLINE
02564 inline
02565 #endif
02566 DBusGProxyCall*
02567 org_atheme_audacious_equalizer_activate_async (DBusGProxy *proxy, const gboolean IN_active, org_atheme_audacious_equalizer_activate_reply callback, gpointer userdata)
02568
02569 {
02570 DBusGAsyncData *stuff;
02571 stuff = g_slice_new (DBusGAsyncData);
02572 stuff->cb = G_CALLBACK (callback);
02573 stuff->userdata = userdata;
02574 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);
02575 }
02576 static
02577 #ifdef G_HAVE_INLINE
02578 inline
02579 #endif
02580 gboolean
02581 org_atheme_audacious_get_active_playlist_name (DBusGProxy *proxy, char ** OUT_plname, GError **error)
02582
02583 {
02584 return dbus_g_proxy_call (proxy, "GetActivePlaylistName", error, G_TYPE_INVALID, G_TYPE_STRING, OUT_plname, G_TYPE_INVALID);
02585 }
02586
02587 typedef void (*org_atheme_audacious_get_active_playlist_name_reply) (DBusGProxy *proxy, char * OUT_plname, GError *error, gpointer userdata);
02588
02589 static void
02590 org_atheme_audacious_get_active_playlist_name_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
02591 {
02592 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
02593 GError *error = NULL;
02594 char * OUT_plname;
02595 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_STRING, &OUT_plname, G_TYPE_INVALID);
02596 (*(org_atheme_audacious_get_active_playlist_name_reply)data->cb) (proxy, OUT_plname, error, data->userdata);
02597 return;
02598 }
02599
02600 static
02601 #ifdef G_HAVE_INLINE
02602 inline
02603 #endif
02604 DBusGProxyCall*
02605 org_atheme_audacious_get_active_playlist_name_async (DBusGProxy *proxy, org_atheme_audacious_get_active_playlist_name_reply callback, gpointer userdata)
02606
02607 {
02608 DBusGAsyncData *stuff;
02609 stuff = g_slice_new (DBusGAsyncData);
02610 stuff->cb = G_CALLBACK (callback);
02611 stuff->userdata = userdata;
02612 return dbus_g_proxy_begin_call (proxy, "GetActivePlaylistName", org_atheme_audacious_get_active_playlist_name_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
02613 }
02614 #endif
02615
02616 G_END_DECLS