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