• Main Page
  • Related Pages
  • Classes
  • Files
  • File List
  • File Members

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

Generated on Wed Apr 6 2011 for Audacious by  doxygen 1.7.1