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