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