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