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